继承和符合类的构造函数调用顺序_Java面试知识点——初始化执行代码顺序（包含static块和构造块）以及类方法和实例方法...-CSDN博客

本文链接：https://blog.csdn.net/weixin_33211213/article/details/113364506

在 java 的多态调用中，new 的是哪一个类就是调用的哪个类的方法。该说法是否正确？

答案：不正确

例子：


public class Father { 
    public void say(){ 
        System.out.println("father"); 
    } 
    public static void action(){ 
        System.out.println ("爸爸打儿子！"); 
    } 
} 
public class Son extends Father{ 
    public void say() { 
        System.out.println("son"); 
    }
   public static void action(){ 
        System.out.println ("打打！"); 
    }
    public static void main(String[] args) { 
        Father f=new Son(); 
        f.say(); 
        f.action(); 
    } 
}

输出：

son

爸爸打儿子！

当调用 say 方法执行的是 Son 的方法，也就是重写的 say 方法

而当调用 action 方法时，执行的是 father 的方法。

普通方法，运用的是动态单分配，是根据 new 的类型确定对象，从而确定调用的方法；

静态方法，运用的是静态多分派，即根据静态类型确定对象，因此不是根据 new 的类型确定调用的方法

一、

（1）在初次 new 一个 Child 类对象时，发现其有父类，则先加载 Parent 类，再加载 Child 类。

（2）加载 Parent 类：

初始化 Parent 类的 static 属性，赋默认值；

执行 Parent 类的 static 初始化块；

（3）加载 Child 类：

初始化 Child 类的 static 属性，赋默认值；

执行 Child 类的 static 初始化块；

（4）创建 Parent 类对象：

初始化 Parent 类的非 static 属性，赋默认值；

执行 Parent 类的 instance 初始化块；

执行 Parent 类的构造方法；

（5）创建 Child 类对象：

初始化 Child 类的非 static 属性，赋默认值；

执行 Child 类的 instance 初始化块；

执行 Child 类的构造方法；

后面再创建 Child 类对象时，就按照顺序执行（4）（5）两步。

static{}//静态块

{}//构造块

静态块在一个程序里面只执行一次；

而构造块是，只要建立一个对象，构造代码块都会执行一次。

静态块优先于主方法的执行，静态块优先于构造快，然后是构造方法的执行，而且只执行一次！

类方法：使用 static 修饰（静态方法），属于整个类的，不是属于某个实例的，只能处理 static 域或调用 static 方法；

实例方法：属于对象的方法，由对象来调用。

当类的字节码文件加载到内存中时，类的实例方法并没有被分配入口地址，只有当该类的对象创建以后，实例方法才分配了入口地址。

当类的字节码文件加载到内存，类方法的入口地址就会分配完成，所以类方法不仅可以被该类的对象调用，也可以直接通过类名完成调用。类方法的入口地址只有程序退出时消失。

class A {
	public A() {
		System.out.println("class A");
	}


	{ System.out.println("I'm A class"); }//构造块


	static { System.out.println("class A static"); }//static块
}


public class B extends A {
	public B() {
		System.out.println("class B");
	}


	{ System.out.println("I'm B class"); }


	static { System.out.println("class B static"); }


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


	}
}

执行结果：

class A static

class B static

I’m A class

class A

I’m B class

class B

一个类在初始化的时候，按照：父类静态初始化块 -> 子类静态初始化块 -> 父类初始化块 -> 父类构造器 -> 子类初始化块 -> 子类构造器，这样的顺序初始化的。当该子类已经加载过之后再次实例化子类对象时，执行：父类初始化块 -> 父类构造器 -> 子类初始化块 -> 子类构造器。

二、

class Base{
    public Base(String s){
        System.out.print("B");
    }
}
public class Derived extends Base{
    public Derived (String s) {
        System.out.print("D");
    }
    public static void main(String[] args){
        new Derived("C");
    }
}

上述代码编译报错

子类构造方法在调用时必须先调用父类的，由于父类没有无参构造，必须在子类中显式调用，修改子类构造方法如下即可：


public Derived(String s){
        super(s);
        System.out.print("D");
    }

解释：在调用子类构造器之前，会先调用父类构造器，当子类构造器中没有使用 “super (参数或无参数)” 指定调用父类构造器时，是默认调用父类的无参构造器，如果父类中包含有参构造器，却没有无参构造器，则在子类构造器中一定要使用 “super (参数)” 指定调用父类的有参构造器，不然就会报错。

三、

public class Demo {
    class Super {
        int flag = 1;


        Super() {
            test();
        }


        void test() {
            System.out.println("Super.test() flag=" + flag);
        }
    }


    class Sub extends Super {
        Sub(int i) {
            flag = i;
            System.out.println("Sub.Sub()flag=" + flag);
        }


        void test() {
            System.out.println("Sub.test()flag=" + flag);
        }
    }


    public static void main(String[] args) {
        new Demo().new Sub(5);
    }
}

//执行结果

Sub.test()flag=1

Sub.Sub()flag=5

在继承中代码的执行顺序为：

1. 父类静态对象，父类静态代码块

2. 子类静态对象，子类静态代码块

3. 父类非静态对象，父类非静态代码块

4. 父类构造函数

5. 子类非静态对象，子类非静态代码块

6. 子类构造函数

父类先初始化了 int flag = 1，然后执行父类的构造函数 Super（），父类构造函数中执行的 test（）方法，因子类是重写了 test（）方法的，因此父类构造函数中的 test（）方法实际执行的是子类的 test（）方法(这里要特别说明的是flag是子类从父类继承来的，因为父类的flag是默认修饰符也就是包访问权限)，所以输出为 Sub.test () flag=1，接着执行子类构造函数 Sub(5) 将 flag 赋值为 5，因此输出结果 Sub.Sub () flag=5。

四、

public class Base
{
    private String baseName = "base";
    public Base()
    {
        callName();
    }
 
    public void callName()
    {
        System. out. println(baseName);
    }
 
    static class Sub extends Base
    {
        private String baseName = "sub";
        public void callName()
        {
            System. out. println (baseName) ;
        }
    }
    public static void main(String[] args)
    {
        Base b = new Sub();
    }
}
//输出为null

首先，需要明白类的加载顺序。

(1) 父类静态代码块 (包括静态初始化块，静态属性，但不包括静态方法)

(2) 子类静态代码块 (包括静态初始化块，静态属性，但不包括静态方法 )

(3) 父类非静态代码块 ( 包括非静态初始化块，非静态属性 )

(4) 父类构造函数

(5) 子类非静态代码块 ( 包括非静态初始化块，非静态属性 )

(6) 子类构造函数

其中：类中静态块按照声明顺序执行，并且 (1) 和 (2) 不需要调用 new 类实例的时候就执行了 (意思就是在类加载到方法区的时候执行的)

其次，需要理解子类覆盖父类方法的问题，也就是方法重写实现多态问题。

Base b = new Sub(); 它为多态的一种表现形式，声明是 Base, 实现是 Sub 类，理解为 b 编译时表现为 Base 类特性，运行时表现为 Sub 类特性。

当子类覆盖了父类的方法后，意思是父类的方法已经被重写，题中父类初始化调用的方法为子类实现的方法，子类实现的方法中调用的 baseName 为子类中的私有属性。

由 1. 可知，此时只执行到步骤 4., 子类非静态代码块和初始化步骤还没有到，子类中的 baseName 还没有被初始化。所以此时 baseName 为空。所以为 null。