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

最新推荐文章于 2024-04-09 00:47:05 发布
最新推荐文章于 2024-04-09 00:47:05 发布
阅读量5.9k 收藏 72
点赞数 17
分类专栏： Java开发 文章标签： Java Java初始化 Java初始化顺序 Java初始化规则 Java开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sufengjun/article/details/79674359
版权
这个教程，咱们来对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\n", "boolean:", t);
        System.out.printf("%-10s %-5s\n", "char:", c);
        System.out.printf("%-10s %-5s\n", "short:", s);
        System.out.printf("%-10s %-5s\n", "int:", i);
        System.out.printf("%-10s %-5s\n", "long:", l);
        System.out.printf("%-10s %-5s\n", "float:", f);
        System.out.printf("%-10s %-5s\n", "double:", d);
        System.out.printf("%-10s %-5s\n", "String:", str);
        System.out.printf("%-10s %-5s\n", "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
(9个$符号，博客有问题，不显示9个$)
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改为抽象类，运行结果还一样吗？自己求证一下吧。
好，暂时先写这么多，希望多多少少帮到了你点什么，后面我想到有需要补充的，我再更新帖子吧。✿✿ヽ(ﾟ▽ﾟ)ノ✿

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

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


imrSteve
关注
  • 17
    点赞
  • 踩
  • 72
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
JAVAnew对象时类的初始化顺序
m0_68044820的博客
03-13 887
new对象时类初始化的顺序： 1.先看有没有继承父类 有父类需要先初始化父类 有实现接口的话不会先初始化它的父接口，这里有问题可以参考下面的链接接口的初始化规则_xiao_meimao的博客-CSDN博客_初始化接口 2.先加载父类的静态成员 方法 属性 和 块 注意此时并不会执行块 属性会是默认初始值 加载后会进行初始化 执行块和属性赋值 按照先后顺序 哪个在前会先执行赋值哪个 publi...
Java 类初始化（详解）
acherie的博客
02-22 2万+
JVM 如何进行类的初始化，实例的初始化，构造器的作用与调用。
Java 初始化
weixin_52364868的博客
04-07 2602
我今天又拾起一个知识点：：： 1.初始化的创建： p = new Person(){{age = 10;name = "张三";}} 这里可以针对没相应构造函数，但又要赋值，注意是双括号！！！！！ 2.初始化分类： 初始化分为两种: 1.实例初始化（Inatance Initializers） 用法是 {语句} 2.静态初始化（static Initializers） 用法是static{语句} 在第一次使用这个类时就要执行 但可以肯定的是：静态初始化总要先于实例初始化执行 今
java 基本数据类型初始值(默认值)
热门推荐
niguang09的专栏
10-12 6万+
    若基本数据类型作为类成员的时候，即使没有进行初始化。java也会给定默认的初始值。默认是如下所示：boolean        falsechar              '/uoooo'(null)byte              (byte)0short             (short)0int                  0long               0Lfloat               0.0fdouble           0.0d     当变量作为作为
【Java】关于Java类初始化的时机
最新发布
qq_53070263的博客
04-09 953
简要分析Java类初始化的时机
java在hashmap初始化时赋初值过程解析
08-25
Java 在 HashMap 初始化时赋初值过程解析 Java 中的 HashMap 是一种常用的数据结构，一般用来做数据字典或者 Hash 查找的容器。在初始化并赋初值时，我们通常使用 `HashMap, Object> map = new HashMap();` 的方式...
Java初始化块及执行过程解析
08-25
静态初始化块也是类的静态成员，仍然需要遵循静态成员不能访问非静态成员的规则，包括不能访问实例变量和实例方法。 在 Java 中，初始化块执行的时候会一直上溯到 java.lang.Object 类，先执行 Object 的初始化块，...
java中hashmap容量的初始化实现
08-25
在《阿里巴巴Java开发手册》中，有一条开发建议是建议我们设置HashMap的初始化容量。这是因为HashMap的扩容机制。当HashMap中的元素个数超过临界值（Threshold）时，HashMap就会自动进行扩容，而扩容操作需要消耗...
Java中static静态变量的初始化完全解析
09-02
Java中的静态变量（static变量）是在类加载时初始化的，而不是在对象创建时。静态变量属于类，而不属于任何特定的对象，因此它们是共享的，所有类实例都可以访问。了解静态变量的初始化顺序对于理解和避免潜在的编程...
java面试题-类的初始化顺序.doc
05-10
我们大家都知道，对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序依次是（静态变量、静态初始化块）>（变量、初始化块）>构造器。我们也可以通过下面的测试代码来验证这一点：
Java中实例初始化是什么？
sunling_sz的专栏
04-03 5525
在这篇文章中，首先用一个例子来说明什么是实例变量的初始化，实例初始化和静态初始化。然后再解释实例初始化是怎样运行的。 1.执行顺序 看看下面的类，你知道哪一个最先被执行？ public class Foo { //instance variable initializer String s = "abc"; //constructor public Foo() {
JAVA学习笔记（2）—— java初始化三个原则
weixin_34032792的博客
06-30 291
1. 初始化原则 （1） 静态对象（变量）优先于非静态对象（变量）初始化，其中静态对象（变量）初始化一次，非静态对象（变量）可能会初始化多次。 （2） 父类优先于子类初始化 （3） 按照成员变量定义顺序初始化，即使变量定义与方法定义中，依然在被调用前初始化。 2. Java初始化顺序 （1） 父类静态变量 （2） 父类静态代码块 （3） 子类静态变量 （4）...
Java类加载机制(初始化顺序)
feigeswjtu的专栏
01-06 2321
之前写过一篇关于Java中普通代码块和static代码块的区别，大致讲解了普通代码块和Static代码的区别，但是并没有讲它们的加载执行顺序，本章就细细的将一下类的加载机制（初始化顺序）。 类生命周期 类的字节码从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证（Verification）、准备(Preparation)、解析(Resoluti
java中变量的初始化_java中的变量初始化问题
weixin_32506761的博客
02-12 3381
java中三种变量1. 类的属性，或者叫值域2. 方法里的局部变量3. 方法的参数对于第一种称为类中的成员变量，Java虚拟机会自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值。以下是各种数据类型的默认值boolean falseint 0float 0.0fdouble 0.0dshort 0byte 0long 0 L所有对象引用类型变量...
java类型 默认初始化值
baidu_23263735的博客
09-24 1230
基本数据类型 byte ：默认初始化值为0 int ：默认初始化值为0 short：默认初始化值为0 long：默认初始化值为0l float:：默认初始化值为0f double:：默认初始化值为0d char：'u0000' boolean：false Integer ：默认初始化值为null String ：默认初始化值为null 像Integer,String这样...
Java初始化
belows的专栏
04-03 418
Java初始化Java保证变量在使用前都已经初始化。 对类的成员变量（静态变量和实例变量），在构建类的实例时，首先都会被初始化为一个默认值（数字型变量（int、byte、short、long、float、double）都会被初始化为0，而boolean则是false，char其ascii码也是0，其他非基本类型的变量则会被初始化为null），当然你也可以在定义变量时直接初始化，然后才是由初始化块和
java_初始化器
weixin_34018169的博客
01-29 98
  1. 执行的顺序 package java20180129_1; public class Demo { // instance variable initializer 实例变量初始化器 String s = "abc"; // constructor 构造器 public Demo() { System.out.p...
java t初始化_[Java] 类的初始化步骤
weixin_39914752的博客
02-27 334
前言类的初始化过程，可在多线程环境下进行的，为了简化，本文介绍的单线程情况下的类初始化步骤。此外，继承情况下的顺序不是本文焦点，本文重点在于一个类的内部字段的初始化顺序。想了解继承情况下的初始化情况，可参看类和接口的初始化步骤 - 继承方面本文介绍的是类的初始化，不涉及实例的初始化。正文类的初始化，包括静态代码块的初始化、静态字段(类的字段)的初始化。类的初始化触发条件：1) T 是一个类，且 ...
java中什么是变量 什么变量初始化
06-13
在Java中，变量是用来存储数据的一种容器。它可以存储不同类型的数据，例如整数、浮点数、布尔值、字符串等等。在Java中，每个变量都有一个类型和一个名称。变量的类型确定了它可以存储的数据类型，而变量的名称则用来标识这个变量。 变量初始化是指在使用变量之前，为变量赋予一个初始值。在Java中，如果变量没有被初始化，则它的值是未定义的，编译器会报错。Java中可以在声明变量的同时对变量进行初始化，也可以在后面的代码中对变量进行初始化。例如： ``` int x = 10; // 在声明变量时对变量进行初始化 double y; // 声明一个变量y y = 3.14; // 在后面的代码中对变量y进行初始化 ``` 需要注意的是，Java中的局部变量必须在使用之前进行初始化，否则编译器会报错。而类变量和实例变量会有默认的初始值，如果没有被显式地初始化，它们的值会被自动设置为0或null。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值