父类和子类的代码
package test;
public class Parent {
static {
System.out.println("父类静态块.");
}
public Parent() {
System.out.println("父类构造函数: 0 参数.");
}
public Parent(String str) {
System.out.println("父类构造函数: 1 参数."+str);
}
}
class Son extends Parent{
static {
System.out.println("子类静态块.");
}
public Son() {
System.out.println("子类构造函数: 0 参数.");
}
public Son(String str) {
System.out.println("子类构造函数: 1 参数."+ str);
}
}
main函数
public static void main(String[] args) {
System.out.println("Parent parent0 = new Son() 的输出结果:");
Parent parent0 = new Son();
System.out.println("\n\nSon son0 = new Son() 的输出结果:");
Son son0 = new Son();
System.out.println("\n\nParent parent = new Son(\"一个参数的向上转型\") 的输出结果:");
Parent parent1 = new Son("一个参数的向上转型");
System.out.println("\n\nSon son = new Son(\"一个参数的没有转型\") 的输出结果:");
Son son = new Son("一个参数的没有转型");
System.out.println("\n\nParent parent = new Parent(\"一个父类的实例\")");
Parent parent2 = new Parent("一个父类的实例");
}
输出结果
Parent parent0 = new Son() 的输出结果:
父类静态块.
子类静态块.
父类构造函数: 0 参数.
子类构造函数: 0 参数.
Son son0 = new Son() 的输出结果:
父类静态块.
子类静态块.
父类构造函数: 0 参数.
子类构造函数: 0 参数.
Parent parent = new Son("一个参数的向上转型") 的输出结果:
父类静态块.
子类静态块.
父类构造函数: 0 参数.
子类构造函数: 1 参数.一个参数的向上转型
Son son = new Son("一个参数的没有转型") 的输出结果:
父类静态块.
子类静态块.
父类构造函数: 0 参数.
子类构造函数: 1 参数.一个参数的没有转型
Parent parent = new Parent("一个父类的实例")
父类静态块.
父类构造函数: 1 参数.一个父类的实例
总结
用一句话来描述: 除了直接new父类的情况,都会遵循以下规则:
父类静态块->子类静态块->父类无参构造器->子类构造器(有参数则调用对应的有参构造器)
PS:以上的输出结果是分个得出来的, 如果一起运行,那么只会在第一种情况下输出:
父类静态块.
子类静态块.
这是因为JVM保证被static修饰的代码块或者变量在一次编译中只执行一次