Java初始化规则都不懂，搞什么开发！

qc1iu 发布于2019-08-19 10:43 / 2976人阅读

摘要：静态块代码初始化其实，整个静态代码块可以看作是一个静态成员。和普通的非静态成员初始化一样，它的执行也发生在构造器调用之前，并且每当创建对象之前都会调用。口继承中涉及的初始化大的原则是没有父类，就没子类。

这个教程，咱们来对Java中设计到的初始化规则，或者说初始化顺序，来做一下汇总，这里我基本上把Java中，默认初始化，静态成员初始化，非静态成员初始化，静态代码块，非静态代码块，以及继承中所涉及到的初始化，都涵盖全了。希望你看到这个教程，能有所收获。(๑´ڡ`๑)

默认初始化

在Java中，一个类的数据成员（成员变量）如果没有指定初始化，那么Java会对其执行默认初始化。
基本类型初始化默认值为0，boolean为false，字符串或者对象引用初始化为null。这部分比较简单，看下面这个小列子，相信你应该能直接看出来最后运行的结果。(<_<)

public class InitialValues {
    boolean t;
    char c;
    short s;
    int i;
    long l;
    float f;
    double d;
    String str;
    InitialValues reference;

    void printInitialValues() {
        System.out.printf("%-10s %-5s
", "boolean:", t);
        System.out.printf("%-10s %-5s
", "char:", c);
        System.out.printf("%-10s %-5s
", "short:", s);
        System.out.printf("%-10s %-5s
", "int:", i);
        System.out.printf("%-10s %-5s
", "long:", l);
        System.out.printf("%-10s %-5s
", "float:", f);
        System.out.printf("%-10s %-5s
", "double:", d);
        System.out.printf("%-10s %-5s
", "String:", str);
        System.out.printf("%-10s %-5s
", "reference:", reference);
    }

    public static void main(String[] args) {
        InitialValues iv = new InitialValues();
        iv.printInitialValues();
    }
}

// Output
----------------
boolean:   false
char:           
short:     0    
int:       0    
long:      0    
float:     0.0  
double:    0.0  
String:    null
reference: null

非静态成员初始化顺序

在一个类中，非静态成员的初始化，发生在任何方法（包括构造器）被调用之前。并且它们定义的顺序，决定了初始化的顺序。来看下面这个小程序，这里的类，我都用的通用的无实际意义的类，这样能让咱们把注意力放在代码逻辑上。这个小程序，我给你提点要求：你捋一下代码的逻辑，看看能不能直接写出来最后的运行结果。完了把你写的结果和我后面给你的答案对比一下，看看能不能搞对。最后你自己最好能敲敲程序运行一下。( •̀⊿•́)ง

class XXX {
    XXX(String s){ System.out.println("XXX > " + s); }
}

class AAA {
    XXX x001 = new XXX("001");
    AAA() {
        System.out.println("AAA");
        XXX x004 = new XXX("004");
    }
    XXX x002 = new XXX("002");
    void fff() { System.out.println("fffffffff"); }
    XXX xxx003 = new XXX("003");
}

public class Initialization {
    public static void main(String[] args) {
        AAA aaa = new AAA();
        aaa.fff();
    }
}

// Output
---------
XXX > 001
XXX > 002
XXX > 003
AAA
XXX > 004
fffffffff

静态成员初始化及对象的创建过程

以名为YYY的类举例：

当该类的静态方法（包括main()和构造器，构造器实际上也是静态方法）或者静态成员被调用或访问时，Java虚拟机将载入类所对应的YYY.class文件，并创建其Class类对象，然后该类所有的静态成员将执行初始化。并且静态成员初始化只执行这一次。

静态初始化完成后，该类就做好了创建对象的准备。当调用new YYY()创建对象的时候，首先在堆内存上为YYY对象分配空间，然后执行默认初始化（基本类型初始化为0，引用类型初始化为null）。

之后，按照非静态成员定义顺序，进行指定初始化。

最后执行构造器，完成对象的创建。

还是和上面同样的要求，先捋代码逻辑，再手写结果。 (｀･ω･´)ゞ

class XXX {
    XXX(String s){ System.out.println("XXX > " + s); }
    void xox(String s){ System.out.println("xox : " + s); }
}

class AAA {
    XXX x001 = new XXX("001");
    static XXX x002 = new XXX("002");
    AAA() {
        System.out.println("AAA");
        x002.xox("002");
    }
    void aaa() { System.out.println("aaa"); }
}

class BBB {
    static XXX x003 = new XXX("003");
    XXX x004 = new XXX("004");
    BBB(){
        System.out.println("BBB");
        x004.xox("004");
    }
    void bbb(){System.out.println("bbb");}
}

public class Initialization {
    public static void main(String[] args) {
        System.out.println("*********");
        new AAA();
        System.out.println("=========");
        new BBB();
        a002.aaa();
        b002.bbb();
    }

    AAA a001 = new AAA();
    static AAA a002 = new AAA();
    static AAA a003= new AAA();
    BBB b001 = new BBB();
    static BBB b002 = new BBB();
    static BBB b003 = new BBB();
}

// Output
---------
XXX > 002
XXX > 001
AAA
xox : 002
XXX > 001
AAA
xox : 002
XXX > 003
XXX > 004
BBB
xox : 004
XXX > 004
BBB
xox : 004
*********
XXX > 001
AAA
xox : 002
=========
XXX > 004
BBB
xox : 004
aaa
bbb

静态块代码初始化

其实，整个static { 静态代码块 } 可以看作是一个静态成员。当一个类需要执行静态初始化时，该类中的静态成员初始化和静态代码块，会按照先后定义的顺序执行。当然，这个流程也是就执行这一次。ღ⊙□⊙╱ 还是老要求......

class XXX {
    XXX(String s){ System.out.println("XXX > " + s); }
}

class AAA {
    XXX x001 = new XXX("001");
    static XXX x002 = new XXX("002");
    static XXX x003, x004;
    static {
        System.out.println("*********");
        x003 = new XXX("003");
        x004 = new XXX("004");
        XXX x005 = new XXX("005");
        System.out.println("=========");
        /**System.out.println(x006);*/
    }
    static XXX x006 = new XXX("006");
    XXX x007 = new XXX("007");
    AAA() { System.out.println("AAA"); }
}

public class Initialization {
    static AAA aaa = new AAA();
    public static void main(String[] args) {
        new AAA();
    }
}

// Output
---------
XXX > 002
*********
XXX > 003
XXX > 004
XXX > 005
=========
XXX > 006
XXX > 001
XXX > 007
AAA
XXX > 001
XXX > 007
AAA

假如把上面/**System.out.println(x006);*/注释掉的代码解除注释，再运行程序，会发生什么情况？

非静态代码块初始化

{ 非静态代码块 }，可以看作一个非静态成员。涉及非静态初始化，也会执行它。和普通的非静态成员初始化一样，它的执行也发生在构造器调用之前，并且每当创建对象之前都会调用。
稍微修改下上面的例子，把静态代码块前面的static关键字去掉，并把里面的注释行释放，并添加一行打印语句，如下，对比两个例子输出结果。(=•̀口•́=)

class XXX {
    XXX(String s){ System.out.println("XXX > " + s); }
}

class AAA {
    XXX x001 = new XXX("001");
    static XXX x002 = new XXX("002");
    static XXX x003, x004;
    {
        System.out.println("*********");
        x003 = new XXX("003");
        x004 = new XXX("004");
        XXX x005 = new XXX("005");
        System.out.println("=========");
        System.out.println(x006);
        System.out.println(x001);
    }
    static XXX x006 = new XXX("006");
    XXX x007 = new XXX("007");
    AAA() { System.out.println("AAA"); }
}

public class Initialization {
    static AAA aaa = new AAA();
    public static void main(String[] args) {
        new AAA();
    }
}

// Output
-------------
XXX > 002
XXX > 006
XXX > 001
*********
XXX > 003
XXX > 004
XXX > 005
=========
XXX@1540e19d
XXX@677327b6
XXX > 007
AAA
XXX > 001
*********
XXX > 003
XXX > 004
XXX > 005
=========
XXX@1540e19d
XXX@14ae5a5
XXX > 007
AAA

继承中涉及的初始化

大的原则是：没有父类，就没子类。初始化，当然要先初始化父类，再初始化子类。
继承中如果同时涉及到静态初始化和非静态初始化。初始化的执行流程分两步走：
（1）先执行静态初始化。且先静态初始化父类，然后再静态初始化子类。（这一步同样就执行一次）
（2）父类执行非静态初始化，然后调用构造方法。接着子类执行非静态初始化，然后调用构造方法。接着下一个子类......以此类推到最后一个子类。 (•̀ω•́ 」∠)

class XXX {
    XXX(String s){ System.out.println("XXX > " + s); }
}

class AAA {
    XXX x001 = new XXX("001");
    static XXX x002 = new XXX("002");
    AAA() {
        System.out.println("AAA");
    }
    {
        System.out.println("*********");
        XXX x003 = new XXX("003");
    }
    static XXX x004;
    static {
        System.out.println("=========");
        x004 = new XXX("004");
    }
    static XXX x005 = fff("005");
    static XXX fff(String s) {
        System.out.println("fffffffff");
        return new XXX(s);
    }
}

class BBB extends AAA {
    static XXX x006 = new XXX("006");
    XXX x007= new XXX("007");
    {
        System.out.println("+++++++++");
        XXX x008 = new XXX("008");
    }
    static XXX x009;
    static {
        System.out.println("$$$$$$$$$");
        x009 = new XXX("009");
    }
    BBB(){
        System.out.println("BBB");
    }
    static XXX x010 = fff("010");
}

public class Initialization {
    public static void main(String[] args) {
        new BBB();
        new BBB();
    }
}

// Output
---------
XXX > 002
=========
XXX > 004
fffffffff
XXX > 005
XXX > 006
$$$$$$$$$
XXX > 009
fffffffff
XXX > 010
XXX > 001
*********
XXX > 003
AAA
XXX > 007
+++++++++
XXX > 008
BBB
XXX > 001
*********
XXX > 003
AAA
XXX > 007
+++++++++
XXX > 008
BBB

拓展一下，假如把上面的父类AAA改为抽象类，运行结果还一样吗？自己求证一下吧。
好，暂时先写这么多，希望多多少少帮到了你点什么，后面我想到有需要补充的，我再更新帖子吧。✿✿ヽ(ﾟ▽ﾟ)ノ✿

============================================================================

有条件的小伙伴，可以给打赏点儿支持下，给我些鼓励继续写下去。 (๑´ㅂ`๑́)و✧

GPU云服务器云服务器新手搞开发搞什么看不懂云服务器是什么意思 java用什么开发

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/76368.html

【好好面试】学完Aop,连动态代理的原理都不懂？

摘要：总结动态代理的相关原理已经讲解完毕，接下来让我们回答以下几个思考题。【干货点】此处是【好好面试】系列文的第12篇文章。文章目标主要是通过原理剖析的方式解答Aop动态代理的面试热点问题，通过一步步提出问题和了解原理的方式，我们可以记得更深更牢，进而解决被面试官卡住喉咙的情况。问题如下 SpringBoot默认代理类型是什么为什么不用静态代理 JDK动态代理原理 CGLIB动态代理...

Keven 2019-08-19 10:19 评论0 收藏0
大学一年之后竟如此。。。开学前的挣扎

摘要：后来知道有了院赛，学长说刷院和杭电就可，我就一直刷院，到最后比赛前院的前五十道基本做完，杭电也弄了十来道，就这样草草参加比赛了。博客主页: https://b...

MartinDai 2021-09-06 15:02 评论0 收藏0
感觉奇怪的地方，必有玄机

摘要：微信在上一个大版本中将公众号内容的展示更改为信息流模式。克制的努力在本人看来，微信的产品思维真得堪称楷模。你可以仿照微信来搞一个公众号，但如果不懂这些底层的逻辑，即便是输了都不知道输在哪里。微信在上一个大版本中将公众号内容的展示更改为信息流模式。刚开始还有些不习惯，也不明白为什么要这样做。在使用了一段时间之后，慢慢也就习惯了。但在使用的某一瞬间，潜意识中有一个疑惑：同样是推文，为什么...

helloworldcoding 2019-08-16 18:37 评论0 收藏0
从 ++[[]][+[]]+[+[]]==10? 深入浅出弱类型 JS 的隐式转换

摘要：与此相对，强类型语言的类型之间不一定有隐式转换。三为什么是弱类型弱类型相对于强类型来说类型检查更不严格，比如说允许变量类型的隐式转换，允许强制类型转换等等。在中，加性运算符有大量的特殊行为。从++[[]][+[]]+[+[]]==10?深入浅出弱类型JS的隐式转换本文纯属原创? 如有雷同? 纯属抄袭? 不甚荣幸! 欢迎转载！原文收录在【我的GitHub博客】，觉得本文写的不算烂的...

miya 2019-08-20 14:46 评论0 收藏0