JAVA 类成员初始化这一篇就够了

       在我们实际开发中,定义一个类是实在不能再平常的事,面向对象编程的理念是“一切皆是对象”,没有什么是对象不能盘的,那么我们是否真的知道类中成员初始化顺序呢?看完这篇文章你将对类成员初始化有个完整全面的认识。

一、无父类

package com.example.test;

public class Dog {

    public Dog(){
        System.out.println("Dog new instance");
    }

    //静态块
    static {
        System.out.println("Dog static blog");
    }
   
    //非静态块

    {
        System.out.println("Dog blog");
    }

}

输出结果:

Dog static blog
Dog blog
Dog new instance

是否跟你想的一样呢?所以总结一下:创建一个类的对象时,先初始化静态块,然后初始化非静态块,最后调用类的构造函数。如果类中有静态变量和非静态变量,那初始化顺序又是怎样呢?

package com.example.test;

public class Dog {
    static Cat cat1 = new Cat(1);

    public Dog(){
        System.out.println("Dog new instance");
    }

    static {
        System.out.println("Dog static blog");
    }

    {
        System.out.println("Dog blog");
    }
    Cat cat = new Cat(2);
}

输出结果:

new cat instance:1
Dog static blog
Dog blog
new cat instance:2
Dog new instance

输出结果跟你预想的是否又一致呢?类中成员初始化顺序还跟定义顺序有关,也许你早知道,别喷,我只是在扫盲。那是下面这种情况呢?

package com.example.test;

public class Dog {
    public static int value = 1;

    public Dog(){
        System.out.println("Dog new instance");
    }

    static {
        System.out.println("Dog static blog");
    }

    {
        System.out.println("Dog blog");
    }
    
    public static void testDog(){

    }
}

这里特别说一下调用方式为

public static void main(String[] args){
        Dog.testDog();
    }

输出结果:

Dog static blog

惊不惊喜,意不意外,说好的按上面顺序初始化的呢?一定是调用方式不对,没错,说对了,只有创建这个对象时,才会像我们最上面说的那样输出。

       如果在类中创建该类的实例又会咋样呢?我们继续往下:

package com.example.test;

public class Dog {
    public static Dog dog = new Dog();

    public static void testDog(){

    }

    public Dog(){
        System.out.println("Dog new instance");
    }

    static {
        System.out.println("Dog static blog");
    }

    {
        System.out.println("Dog blog");
    }
}




package com.example.test;

public class Application {

    public static void main(String[] args){
        Dog.testDog();
    }
}

输出结果:

Dog blog
Dog new instance
Dog static blog

纳尼!!!说好的先初始化静态模块呢?前面我们说过,类成员初始化与定义顺序有关,所以调用testDog静态方法会首先调用new Dog()创建类实例,前面也提到过创建类实例会初始化非静态成员,所以进入非静态模块,然后再进入构造函数,即输出:

Dog blog
Dog new instance

而按照类的初始化顺序和定义顺序,初始化完静态变量dog之后要初始化静态模块,所以要输出“Dog static blog”,于是输出结果就是:

Dog blog
Dog new instance
Dog static blog

二、有父类  

    下面我们再来看一下存在父类的情况,这种情况我们的输出又会是怎样呢?一起看看下面的实例:

package com.example.practice.test;

public class Dog {

    public Dog(){
        System.out.println("Dog new instance");
    }

    static {
        System.out.println("Dog static blog");
    }

    {
        System.out.println("Dog blog");
    }

}




package com.example.practice.test;

public class AlaskanDog extends Dog {

    public AlaskanDog(){
        System.out.println("AlaskanDog new instance");
    }

    static {
        System.out.println("AlaskanDog static blog");
    }

    {
        System.out.println("AlaskanDog blog");
    }
}

在应用启动程序中创建子类实例,输出结果:

Dog static blog
AlaskanDog static blog
Dog blog
Dog new instance
AlaskanDog blog
AlaskanDog new instance

我们都知道,初始化子类先要初始化父类,而类成员初始化是先初始化静态成员,所以先初始化父类静态模块,然后再是子类静态模块,注意这时候还没有调用new创建对象调用构造函数,初始化完静态模块后再调用new创建对象,而类中又有非静态成员,所以先初始化非静态成员然后再调构造函数,于是输出顺序就如上面输出。下面我们再来看一下终极实例:

package com.example.practice.test;

public class Dog {

    public Dog(){
        System.out.println("Dog new instance");
    }

    static {
        System.out.println("Dog static blog");
    }

    {
        System.out.println("Dog blog");
    }

}




package com.example.practice.test;

public class AlaskanDog extends Dog {
    private static AlaskanDog alaskanDog =  new AlaskanDog();

    private AlaskanDog(){
        System.out.println("AlaskanDog new instance");
    }

    public static AlaskanDog getInstance(){
        return new AlaskanDog();
    }

    static {
        System.out.println("AlaskanDog static blog");
    }

    {
        System.out.println("AlaskanDog blog");
    }

}



package com.example.practice.test;


public class PracticeTest {
    public static void main(String[] args){
        AlaskanDog.getInstance();
    }
}

输出结果:

Dog static blog
Dog blog
Dog new instance
AlaskanDog blog
AlaskanDog new instance
AlaskanDog static blog
Dog blog
Dog new instance
AlaskanDog blog
AlaskanDog new instance

从上面我们知道,类成员初始化跟定义顺序有关,所以AlaskanDog.getInstance()调用之后会先调用private static AlaskanDog alaskanDog = new AlaskanDog()创建对象,而创建子类会先初始化父类,所以会输出:

Dog static blog
Dog blog
Dog new instance

执行父类初始化之后执行子类对象初始化,所以就有如下输出:

AlaskanDog blog
AlaskanDog new instance

执行完private static AlaskanDog alaskanDog = new AlaskanDog()之后就要执行静态模块初始化了,因为跟先后顺序有关,所以接着就有如下输出:

AlaskanDog static blog

执行完静态模块初始化之后,再进入我们的类成员方法的调用,而我们方法内部是创建一个子类实例,所以再初始化父类和子类,而我们知道,静态变量在我们整个类域内只有一个存在,所以不会再进行初始化,所以输出如下:

Dog blog
Dog new instance
AlaskanDog blog
AlaskanDog new instance

拼接在一起就是我们程序运行输出那样。所以我们做一下总结:

1.父类初始化在子类之前;

2.静态成员初始化在非静态成员之前;

3.类成员初始化与定义顺序有关,先定义先初始化;

4.类静态成员变量在类域只有一份存在,不会重复初始化;

 

以上是这次分享,如有不正之处,请指教!

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值