Java基礎之：OOP——代碼塊

代碼塊又稱初始化塊，是類中的成員(即類的一部分)，類似于方法，將邏輯陳述句封裝在方法體中，通過{}包圍起來，也是通過呼叫執行，

但和方法不同，沒有方法名，沒有回傳，沒有引數，只有方法體，而且不用通過物件或類顯式呼叫，而是加載類時，或創建物件時隱式呼叫，

基本語法

[修飾符]{

代碼(方法體)

};

說明：

修飾符可選是否添加，但只能添加static
代碼塊分為兩種，加了static的靜態代碼塊，沒加static的普通代碼塊
邏輯陳述句可以是任何邏輯陳述句(輸入、輸出、方法呼叫、回圈、判斷等)
結尾的“;”號可以不寫，[建議不寫]

代碼塊優點

代碼塊相當于另外一種形式的構造器(對構造器的補充機制)，可以作初始化的操作，

當構造器多載時，可以提取多個構造器重復執行的代碼，放入代碼塊中，

簡單案例

電影放映

public class CodeBlockTest02 {
?
    public static void main(String[] args) {
?
        new Movie();
        
        System.out.println("----------------");
        new Movie("唐人街探案3..");
        
        System.out.println("---------------");
        new Movie("我和我的祖國...", 80, "張藝謀");
    }
?
}
?
class Movie {
    
    private String name;
    private double price;
    private String director;
    
    //代碼塊
    {
        System.out.println("電影開始播放廣告...");
        System.out.println("電影螢屏拉下來.");
        System.out.println("電影播放.");
    }
    
    public Movie() {
        
        
    }
    public Movie(String name) {
    
        this.name = name;
    }
    public Movie(String name, double price, String director) {
        
        
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

結果輸出

代碼塊使用說明

static代碼塊又稱靜態代碼塊，靜態代碼塊在類加載時就會執行且僅執行一次，和靜態屬性/靜態方法相同，靜態代碼塊的作用就是初始化類，
普通的代碼塊，每宣告一個物件執行一次普通代碼塊，所以我們又可以將普通代碼塊看成構造器的一部分，
如果只使用類的靜態成員，則不會執行普通代碼塊，因為只要不宣告物件，普通代碼塊就不會執行，

什么時候類被加載：

創建物件時： Person p = new Person();
創建子類物件時，父類也會被加載：Student s = new Student(); (Student extends Person，Student和Person都會被加載)
使用類的靜態成員(靜態屬性，靜態方法)時：Student.totalFee; (private static double totalFee)

創建物件時，類的呼叫順序

呼叫靜態代碼塊和靜態屬性初始化(注意：靜態代碼塊和靜態屬性初始化呼叫的優先級一樣，如果有多個靜態代碼塊和多個靜態變數初始化，則按他們定義的順序呼叫)
呼叫普通代碼塊和普通屬性的初始化(注意：普通代碼塊和普通屬性初始化呼叫的優先級一樣，如果有多個普通代碼塊和多個普通屬性初始化，則按定義順序呼叫)
呼叫構造方法，

構造方法(構造器) 的最前面其實隱含了 super()和呼叫普通代碼塊，

class Person{
    public Person(){
        super();
        //呼叫普通代碼塊
        System.out.println("Person");
    }
}

靜態相關的代碼塊，屬性初始化，在類加載時，就執行完畢, 因此是優先于構造器和普通代碼塊執行的，

靜態代碼塊只能直接呼叫靜態成員，普通代碼塊可以呼叫任意成員，(因為在靜態代碼塊執行時，只有靜態成員已經被加載了)

物件加載順序案例

package codeBlock;
?
public class Extends_blockTest {
?
    public static void main(String[] args) {
        new C();
    }
?
}
class A{
    
    private String name = nameA();
    private static int age = ageA();
    
    static {
        System.out.println("A .... static Block");
    }
    
    {
        System.out.println("A .... ordinary Block");
    }
    
    public String nameA() {
        System.out.println("A .... ordinary Args");
        return "AAA";
    }
    
    public static int ageA() {
        System.out.println("A .... static Args");
        return 18;
    }
?
    public A() {
        System.out.println("A .... constructor");
    }
}
?
class B extends A{
    
    static {
        System.out.println("B .... static Block");
    }
    
    private String name = nameB();
    private static int age = ageB();
    
?
    {
        System.out.println("B .... ordinary Block");
    }
    
    public String nameB() {
        System.out.println("B .... ordinary Args");
        return "BBB";
    }
    
    public static int ageB() {
        System.out.println("B .... static Args");
        return 18;
    }
?
    public B() {
        System.out.println("B .... constructor");
    }
}
?
class C extends B{
    private String name = nameC();
    private static int age = ageC();
    
    static {
        System.out.println("C .... static Block");
    }
    
    {
        System.out.println("C .... ordinary Block");
    }
    
    public String nameC() {
        System.out.println("C .... ordinary Args");
        return "CCC";
    }
    
    public static int ageC() {
        System.out.println("C .... static Args");
        return 18;
    }
?
    public C() {
        System.out.println("C .... constructor");
    }
?
}

輸出結果

A .... static Args

A .... static Block

B .... static Block

B .... static Args

C .... static Args

C .... static Block

A .... ordinary Args

A .... ordinary Block

A .... constructor

B .... ordinary Args

B .... ordinary Block

B .... constructor

C .... ordinary Args

C .... ordinary Block

C .... constructor

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/234128.html

標籤：其他

上一篇：第一個django應用--簡單的 hello world 專案

下一篇：Java基礎之：單例模式