代码块/属性及方法/构造器/继承关系 优先级

 总览

优先级:父静(代码块/属性/方法)>子静(代码块/属性/方法)>父普(代码块/属性/方法)>父构造器>子普代码块(代码块/属性/方法)>子构造器

 基本原理1

 

 代码实现1

public class Demo {
    public static void main(String[] args) {
        A a1=new A();//(1)A中静态代码块被调用(A类首次加载) (2)A中普通代码块被调用
        System.out.println("------------------");
        A a2=new A();//A中普通代码块被调用
        System.out.println("------------------");
        B b=new B();//(1)B中静态代码块被调用(B类首次加载) (2)A中普通代码块被调用 (3)B中普通代码块被调用
        System.out.println("------------------");
        System.out.println(A.age);//888
    }
}

class A{
    public static int age=888;
    static {
    System.out.println("A中静态代码块被调用");
    }

    {
        System.out.println("A中普通代码块被调用");
    }
}

class B extends A{
    static {
        System.out.println("B中静态代码块被调用");
    }

    {
        System.out.println("B中普通代码块被调用");
    }
}

运行结果1 

A中静态代码块被调用
A中普通代码块被调用
------------------
A中普通代码块被调用
------------------
B中静态代码块被调用
A中普通代码块被调用
B中普通代码块被调用
------------------
888

Process finished with exit code 0

基本原理2

代码实现2

public class Demo {
    public static void main(String[] args) {
        A a = new A();
    //(1)getN1被静态属性n1调用... (2)A中静态代码块被调用
    //(3)A中普通代码块被调用 (4)getN2被非静态属性n2调用...(5)A的无参构造器被调用
    }
}

class A {
    //静态属性/静态代码块 >优先级> 非静态属性/普通代码块 >优先级> 构造器

    //静态属性初始化的优先级和静态代码块一样,按照先后顺序来调用
    public static int n1 = getN1();

    static {//静态代码块
        System.out.println("A中静态代码块被调用");
    }

    //非静态属性初始化的优先级和普通代码块一样,也按照先后顺序来调用
    {//普通代码块
        System.out.println("A中普通代码块被调用");
    }

    public int n2 = getN2();

    public static int getN1() {
        System.out.println("getN1被静态属性n1调用...");
        return 100;
    }

    public static int getN2() {
        System.out.println("getN2被非静态属性n2调用...");
        return 200;
    }
    //构造器

    public A() {
        System.out.println("A的无参构造器被调用");
    }
}

运行结果2

getN1被静态属性n1调用...
A中静态代码块被调用
A中普通代码块被调用
getN2被非静态属性n2调用...
A的无参构造器被调用

Process finished with exit code 0

父子静态属性/代码块 >父普通代码/静态属性》父构造器

基本原理3

 

代码实现3

public class Demo {
    public static void main(String[] args) {
        B b = new B();
        //(1)A类的静态代码块被调用(2)B类的静态代码块被调用 父静>优先级>子静
        //(3)A类的普通代码块被调用(4)A类的构造器被调用...
        //(5)B类的普通代码块被调用(6)B类的构造器被调用...
        //优先级:父静(代码块/属性/方法)>子静(代码块/属性/方法)>父普(代码块/属性/方法)>父构造器>子普代码块(代码块/属性/方法)>子构造器
    }
}

class A {
    static {
        System.out.println("A类的静态代码块被调用");
    }

    {
        System.out.println("A类的普通代码块被调用");
    }

    public A() {
        //(1)super();
        //(2)调用本类的普通代码块
        System.out.println("A类的构造器被调用...");
    }
}

class B extends A {
    static {
        System.out.println("B类的静态代码块被调用");
    }

    {
        System.out.println("B类的普通代码块被调用");
    }

    public B() {
        //(1)super();
        //(2)调用本类的普通代码块
        System.out.println("B类的构造器被调用...");
    }
}

运行结果3

A类的静态代码块被调用
B类的静态代码块被调用
A类的普通代码块被调用
A类的构造器被调用...
B类的普通代码块被调用
B类的构造器被调用...

Process finished with exit code 0

基本原理4

IDEA提示