1.子类无构造函数,超类无构造函数,创建的无参数的对象:
编译通过。
1 class A 2 { 3 4 } 5 6 class B extends A 7 { 8 9 } 10 public class Testeeer 11 { 12 public static void main(String [] args) 13 { 14 B b_01=new B(); 15 } 16 }
2.子类有无参数构造函数,超类无构造函数,创建的无参数的对象:
运行结果:
调用了B的无参构造函数
1 class A 2 { 3 4 } 5 class B extends A 6 { 7 public B() 8 { 9 System.out.println("调用了B的无参构造函数"); 10 } 11 } 12 13 public class Testeeer 14 { 15 public static void main(String [] args) 16 { 17 B b_01=new B(); 18 19 } 20 }
3.子类无构造函数,超类有无参数构造函数,创建的无参数的对象:
运行结果:
调用了A的无参构造函数
1 class A 2 { 3 public A() 4 { 5 System.out.println("调用了A的无参构造函数"); 6 } 7 } 8 class B extends A 9 { 10 11 } 12 13 public class Testeeer 14 { 15 public static void main(String [] args) 16 { 17 B b_01=new B(); 18 19 } 20 }
4.子类有无参数构造函数,超类有无参数构造函数,创建的无参数的对象:
运行结果:
调用了A的无参构造函数
调用了B的无参构造函数
1 class A 2 { 3 public A() 4 { 5 System.out.println("调用了A的无参构造函数"); 6 } 7 } 8 class B extends A 9 { 10 public B() 11 { 12 System.out.println("调用了B的无参构造函数"); 13 } 14 } 15 16 public class Testeeer 17 { 18 public static void main(String [] args) 19 { 20 B b_01=new B(); 21 22 } 23 }
5.子类无构造函数,超类无构造函数,创建的有参数的对象:
编译不成功:
1 class A 2 { 3 4 } 5 6 class B extends A 7 { 8 9 } 10 11 public class Testeeer 12 { 13 public static void main(String [] args) 14 { 15 16 B b_02=new B("你好"); 17 } 18 }
6.子类有无参数构造函数,超类无构造函数,创建的有参数的对象:
编译不成功:
1 class A 2 { 3 4 } 5 6 class B extends A 7 { 8 public B() 9 { 10 System.out.println("调用了B的无参构造函数"); 11 } 12 } 13 14 public class Testeeer 15 { 16 public static void main(String [] args) 17 { 18 19 B b_02=new B("你好"); 20 } 21 }
7.子类无构造函数,超类有无参数构造函数,创建的有参数的对象:
编译不成功:
1 class A 2 { 3 public A() 4 { 5 System.out.println("调用了A的无参构造函数"); 6 } 7 } 8 9 class B extends A 10 { 11 12 } 13 14 public class Testeeer 15 { 16 public static void main(String [] args) 17 { 18 19 B b_02=new B("你好"); 20 } 21 }
8.子类有无参数构造函数,超类有无参数构造函数,创建的有参数的对象:
编译不成功:
1 class A 2 { 3 public A() 4 { 5 System.out.println("调用了A的无参构造函数"); 6 } 7 } 8 9 class B extends A 10 { 11 public B() 12 { 13 System.out.println("调用了B的无参构造函数"); 14 } 15 } 16 17 public class Testeeer 18 { 19 public static void main(String [] args) 20 { 21 22 B b_02=new B("你好"); 23 } 24 }
9.子类有有参数构造函数,超类无构造函数,创建的有参数的对象:
编译成功;
运行结果:
1 class A 2 { 3 4 } 5 class B extends A 6 { 7 8 public B(String mess) 9 { 10 System.out.println("调用了B的有参构造函数 "+ 11 "参数内容为:"+mess); 12 } 13 14 } 15 16 public class Testeeer 17 { 18 public static void main(String [] args) 19 { 20 B b_02=new B("你好"); 21 } 22 }
10.子类有有参数构造函数,超类有有参数构造函数,创建的有参数的对象:
编译失败:
1 class A 2 { 3 public A(String mess) 4 { 5 System.out.println("调用了A的有参构造函数 "+ 6 "参数内容为:"+mess); 7 } 8 } 9 class B extends A 10 { 11 12 public B(String mess) 13 { 14 System.out.println("调用了B的有参构造函数 "+ 15 "参数内容为:"+mess); 16 } 17 18 } 19 20 public class Testeeer 21 { 22 public static void main(String [] args) 23 { 24 B b_02=new B("你好"); 25 } 26 }
11.子类有有参数构造函数(首行定义super),超类有有参数构造函数,创建的有参数的对象:
编译成功;
运行结果:
1 class A 2 { 3 public A(String mess) 4 { 5 System.out.println("调用了A的有参构造函数 "+ 6 "参数内容为:"+mess); 7 } 8 } 9 class B extends A 10 { 11 12 public B(String mess) 13 { 14 super(mess); 15 System.out.println("调用了B的有参构造函数 "+ 16 "参数内容为:"+mess); 17 } 18 19 } 20 21 public class Testeeer 22 { 23 public static void main(String [] args) 24 { 25 B b_02=new B("你好"); 26 } 27 }
12.子类有有参数构造函数,超类有有参数构造函数和无参数的构造函数,创建的有参数的对象:
编译成功;
运行结果:
1 class A 2 { 3 public A(String mess) 4 { 5 System.out.println("调用了A的有参构造函数 "+ 6 "参数内容为:"+mess); 7 } 8 public A() 9 { 10 System.out.println("调用了A的无参构造函数"); 11 } 12 } 13 class B extends A 14 { 15 16 public B(String mess) 17 { 18 19 System.out.println("调用了B的有参构造函数 "+ 20 "参数内容为:"+mess); 21 } 22 23 } 24 25 public class Testeeer 26 { 27 public static void main(String [] args) 28 { 29 B b_02=new B("你好"); 30 } 31 }
13.子类有有参数构造函数,超类默认无构造函数,创建的有参数的对象:
编译成功;
运行结果:
1 class A 2 { 3 4 } 5 class B extends A 6 { 7 8 public B(String mess) 9 { 10 11 System.out.println("调用了B的有参构造函数 "+ 12 "参数内容为:"+mess); 13 } 14 15 } 16 17 public class Testeeer 18 { 19 public static void main(String [] args) 20 { 21 B b_02=new B("你好"); 22 } 23 }
1.一旦你在超类或者子类中定义了有参数的构造函数,那么子类和超类中系统默认提供的无参构造函数将不复存在。
2.在子类的构造函数构造前,一定要完成超类的构造函数构造的过程。(那么依据这样的惯性行为,主程序入口处创建的对象的两种类型(有参数或者无参数)将会直接决定子类所调用的构造函数类型(与对象的类型相同)(有参数或者无参数),但是在完成子类构造函数前,先要去完成超类的构造函数。)
2.1如果是无参数的对象创建:
2.1.1超类:默认 子类:无参构造函数 运行:超类默认,子类无参构造
2.1.2超类:无参构造函数 子类:默认 运行:超类无参构造函数,子类默认
2.1.3超类:默认 子类:默认 运行:超类默认,子类默认
2.1.4超类:无参构造函数 子类:无参构造函数 运行:超类无参构造函数,子类无参构造函数
2.2如果是有参数的对象创建:
2.2.1超类:有参构造数 子类:有参构造函数{定义中首行super(形参)} 运行:超类有参构造数,子类有参构造函数
2.2.2超类:默认 子类:有参构造函数 运行:超类默认,子类有参构造函数
2.2.3超类:无参构造数 子类:有参构造函数 运行:超类无参构造数,子类有参构造函数
2.2.4超类:有参构造和无参构造 子类:有参构造函数 运行:无参构造,子类有参构造函数
2.2.5超类:有参构造和无参构造 子类:有参构造函数{定义中首行super(形参)} 运行:超类有参构造,子类有参构造函数