Java学习之区块

在创建一个对象时，会调用构造方法外还会执行其他区块的语句，例如静态块、构造块。

 

执行顺序——静态块 -- main() -- 构造块 -- 构造方法

静态块在类加载时执行一次，之后便不再执行。可以在对类进行初始化，也可以实例化对象调用方法。但不能使用this、super等关键词，因为此时并没有实例化的对象（除非你实例化一个对象，在调用方法，但还是不能使用this、super）。

当有多个静态块时，按照先后顺序执行。

 

当有子类继承时的执行循序（这里这篇文章写的挺好的，就没再自己写了）

1. 执行父类的静态代码块，并初始化父类静态成员变量
2. 执行子类的静态代码块，并初始化子类静态成员变量
3. 执行父类的构造代码块，执行父类的构造函数，并初始化父类普通成员变量
4. 执行子类的构造代码块， 执行子类的构造函数，并初始化子类普通成员变量

 

父类静态 -- 子类静态 -- 父类构造代码块 -- 父类构造函数 -- 子类构造代码块 -- 子类构造函数

我常忘记子类静态执行的循序！！！

 

--------------20.9.22更新-----------------

如果直接在声明类成员变量时对变量进行了初始化，会先进行初始化再调用构造函数。

class X {
    Y b = new Y();

    X() {
        System.out.print("X");
    }
}

class Y {
    Y() {
        System.out.print("Y");
    }
}

public class Z extends X {
    Y y = new Y();

    Z() {
        System.out.print("Z");
    }

    public static void main(String[] args) {
        new Z();
    }
}

结果：YXYZ

----------------------------------------------

 

对于父类中的的静态内部类只要不实例化内部类并不会执行内部类中的各个区块（即便是实例化了父类的对象也不会执行，除非父类的区块中有内部类的实例化语句）。

 

父类

public class BlockFather {
    String name;

    static class $BlockTest {
        static {
            System.out.println("父类的静态内部类静态块");
        }
        {
            System.out.println("父类的静态内部类构造块");
        }
        public $BlockTest() {
            System.out.println("父类的静态内部类构造方法");
        }
    }

    public BlockFather() {
        super();
        System.out.println("父类构造方法");
    }

    {
        System.out.print("父类构造块1\t\t");
        this.name = "huahua";
    }
    {
        System.out.print("父类构造块2\t\t");
        this.name = "huahua2";
    }
    static {
        System.out.print("父类静态块1\t\t");
//        System.out.println(new BlockFather().name = "静态块实例化对象");
    }
    static {
        System.out.print("父类静态块2\t\t");
    }

    @Override
    public String toString() {
        return "BlockTest [name=" + name + "]";
    }
}

 

子类

public class BlockSon extends BlockFather {

    static class $BlockTestSon extends BlockFather.$BlockTest {
        static {
            System.out.println("子类的静态内部类静态块");
        }
        {
            System.out.println("子类的静态内部类构造块");
        }

        public $BlockTestSon() {
            System.out.println("子类的静态内部类构造方法");
        }
    }

    int age;

    {
        System.out.print("子类构造块\t");
    }
    static {
        System.out.println("子类静态块");
//        {
//            System.out.println("子类静态块内部");
//        }
    }

    public BlockSon() {
        super();
        System.out.println("子类构造方法\t");
    }

    public BlockSon(int age) {
        super();
        this.age = age;
    }
}

 

测试

public class BlockTest {
    public static void main(String[] args) {
        System.out.println("----\tnew BlockFather");
        new BlockFather();

        System.out.println("----\tnew BlockSon");
        new BlockSon();

//        System.out.println("----\tnew BlockFather.$BlockTest");
//        new BlockFather.$BlockTest();

//        System.out.println("----\tBlockFather b = new BlockSon");
//        BlockFather b = new BlockSon();
    }
}

 

 

参考 java构造块与静态块