Java代碼塊的使用細節有哪些

這篇文章主要講解了“Java代碼塊的使用細節有哪些”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java代碼塊的使用細節有哪些”吧！

1.基本介紹

代碼塊又稱為初始化塊，屬于類中的成員（類的一部分），類似于方法，講邏輯語句封裝在方法體中，用{}抱起來；

但和方法不同，沒有方法名，沒有返回，沒有參數，只有方法體，而且不用通過對象或類顯式調用。

基本語法

（修飾符）（可有可無）{代碼}；

注：

1.修飾符可選，要寫只能寫static

2.代碼塊可分為兩類，使用static修飾的叫靜態代碼塊，沒有static修飾的叫普通代碼塊。

3.;可有可無

好處

1.相當于另一種形式的構造器，可以做初始化的操作

2.如果多個構造器中都有重復的語句，可以抽取到代碼塊中。

快速入門

package com.demo.codeblock_;
public class codeblock01 {
    public static void main(String[] args) {
        movie m01=new movie("環太平洋");
        movie m02=new movie("荒野大飛",66);
        movie m03=new movie("無暇赴死",55,"老K");
    }
}
class movie{
    private String name;
    private double price;
    private String director;
    {
        System.out.println("電影屏幕打開。。。");
        System.out.println("廣告開始。。。");
        System.out.println("電影開始。。。");
    }
    //三個構造器重載
    public movie(String name) {
//        System.out.println("電影屏幕打開。。。");
//        System.out.println("廣告開始。。。");
//        System.out.println("電影開始。。。");
        System.out.println("構造器movie(String name)被調用。。。");
        this.name = name;
    }
    public movie(String name, double price) {
        //        System.out.println("電影屏幕打開。。。");
//        System.out.println("廣告開始。。。");
//        System.out.println("電影開始。。。");
        System.out.println("構造器movie(String name， double price)被調用。。。");
        this.name = name;
        this.price = price;
    }
    public movie(String name, double price, String director) {
        //        System.out.println("電影屏幕打開。。。");
//        System.out.println("廣告開始。。。");
//        System.out.println("電影開始。。。");
        System.out.println("構造器movie(String name, double price, String director)被調用。。。");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

2.代碼塊細節

代碼塊使用注意事項和細節討論

1）static代碼塊也叫靜態代碼塊，作用就是對類進行初始化，而且它隨著類的加載而執行，并且只會執行一次。如果是普通代碼塊，每創建一個對象，就執行。

2）類什么時候被加載[重要!]

①創建對象實例時(new)

②創建子類對象實例，父類也會被加載

③使用類的靜態成員時(靜態屬性，靜態方法)

案例演示：A 類 extends B類的靜態塊

3）普通的代碼塊，在創建對象實例時，會被隱式的調用。 被創建一次，就會調用一次。 如果只是使用類的靜態成員時，普通代碼塊并不會執行。

package com.demo.codeblock_;
public class codeblock02 {
    public static void main(String[] args) {
        //類被加載的情況舉例
        //1.創建對象時new
        //AA aa=new AA();
        //2.創建子類對象實例，父類也會被加載，而且，父類先被加載，子類后被加載
        AA aa01=new AA();
        //3.使用類的靜態成員時
        System.out.println(cat.n);
        DD d1=new DD();
        DD d2=new DD();
    }
}
class DD{
    static {
        System.out.println("DD的靜態代碼被執行1次");
    }
}
class animal{
    static {
        System.out.println("animal的靜態代碼被執行");
    }
}
class cat extends animal{
    public static int n=888;
    //靜態代碼塊
    static {
        System.out.println("cat的靜態代碼塊被執行");
    }
}
class BB {
    static {
        System.out.println("BB的靜態代碼被執行");
    }
}
class AA extends BB{
    static {
        System.out.println("AA的靜態代碼被執行");
    }
}

類的調用順序

創建一個對象時，在一個類調用順序：(重點、難點)

①調用靜態代碼塊和靜態屬性初始化 ( 注意:靜態代碼塊和靜態屬性初始化調用的優先級一樣，如果有多個靜態代碼塊和多個靜態變量初始化，則按他們定義的順序調用）

②調用普通代碼塊和普通屬性的初始化 ( 注意:普通代碼塊和普 通屬性初始化調用的優先級一樣，如果有多個普通代碼塊和多 不普通屬性初始化，則按定義順序調用）

③調用構造方法。

實例

package com.demo.codeblock_;
public class codeblock03 {
    public static void main(String[] args) {
        A a=new A();
    }
}
class A{
    public A(){
        System.out.println("A的無參構造被調用");
    }
    int n2=getn2();
    {//普通代碼塊
        System.out.println("A的普通代碼塊被調用");
    }
    int getn2(){
        System.out.println("getn2被調用");
        return 99;
    }
    private static int n=getn();
    static {
        System.out.println("A的靜態代碼被調用");
    }
    public static int getn(){
        System.out.println("getn被調用");
        return 100;
    }
}

代碼塊細節2

構造器的最前面其實隱含了 super(和調用普通代碼塊，新寫一個類演示靜態相關的代碼塊，屬性初始化，在類加載時，就執行完畢

,因此是優先于構造器和普通代碼塊執行的

class A {
public AO{
super0:
//調用普通代碼塊
_System.out.println("ok");
}
}

實例

package com.demo.codeblock_;
public class codeblock04 {
    public static void main(String[] args) {
        B b=new B();
    }
}
class AA{
    {
        System.out.println("AA的普通代碼塊");
    }
    public AA(){
        //1.super()
        //2.調用本類的普通代碼塊
        System.out.println("AA的構造器被調用");
    }
}
class B extends AA{
    {
        System.out.println("B的普通代碼塊");
    }
    public B(){
        //1.super()
        //2.調用本類的普通代碼塊
        System.out.println("B的構造器被調用");
    }
}

代碼塊細節2

我們看一下創建一個子類對象時(繼承關系)，他們的靜態代碼塊，靜態屬性初 始化，普通代碼塊，普通屬性初始化，構造方法的調用順序如下：

1.父類的靜態代碼塊和靜態屬性(優先級一樣，按定義順序熱行

2.子類的靜態代碼塊和靜態屬性(優先級一樣，按定義順序執行)

3.父類的普通代碼塊和普通屬性初始化(優先級一樣，按定義順序執行)

4.父類的構造方法

5.子類的普通代碼塊和普通屬性初始化(優先級一樣,按定義順序執行)

6.子類的構造方法

7.靜態代碼塊只能直接調用靜態成員(靜態屬性和靜態方法)，普通代碼塊可以調 用任意成員。

實例

package com.demo.codeblock_;
public class codeblock05 {
    public static void main(String[] args) {
        //老師說明
        //(1) 進行類的加載
        //1.1 先加載 父類 A02 1.2 再加載 B02
        //(2) 創建對象
        //2.1 從子類的構造器開始
        //new B02();//對象
        new C02();
    }
}
class A02 { //父類
    private static int n1 = getVal01();
    static {
        System.out.println("A02的一個靜態代碼塊..");//(2)
    }
    {
        System.out.println("A02的第一個普通代碼塊..");//(5)
    }
    public int n3 = getVal02();//普通屬性的初始化
    public static int getVal01() {
        System.out.println("getVal01");//(1)
        return 10;
    }
    public int getVal02() {
        System.out.println("getVal02");//(6)
        return 10;
    }
    public A02() {//構造器
        //隱藏
        //super()
        //普通代碼和普通屬性的初始化......
        System.out.println("A02的構造器");//(7)
    }
}
class C02 {
    private int n1 = 100;
    private static  int n2 = 200;
    private void m1() {
    }
    private static void m2() {
    }
    static {
        //靜態代碼塊，只能調用靜態成員
        //System.out.println(n1);錯誤
        System.out.println(n2);//ok
        //m1();//錯誤
        m2();
    }
    {
        //普通代碼塊，可以使用任意成員
        System.out.println(n1);
        System.out.println(n2);//ok
        m1();
        m2();
    }
}
class B02 extends A02 { //
    private static int n3 = getVal03();
    static {
        System.out.println("B02的一個靜態代碼塊..");//(4)
    }
    public int n5 = getVal04();
    {
        System.out.println("B02的第一個普通代碼塊..");//(9)
    }
    public static int getVal03() {
        System.out.println("getVal03");//(3)
        return 10;
    }
    public int getVal04() {
        System.out.println("getVal04");//(8)
        return 10;
    }
    //一定要慢慢的去品..
    public B02() {//構造器
        //隱藏了
        //super()
        //普通代碼塊和普通屬性的初始化...
        System.out.println("B02的構造器");//(10)
        // TODO Auto-generated constructor stub
    }
}

感謝各位的閱讀，以上就是“Java代碼塊的使用細節有哪些”的內容了，經過本文的學習后，相信大家對Java代碼塊的使用細節有哪些這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！