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