1.子类无构造函数，超类无构造函数，创建的无参数的对象：
编译通过。
class A
{ } class B extends A
{ }
public class Testeeer
{
public static void main(String [] args)
{
B b_01=new B();
}
}
2.子类有无参数构造函数，超类无构造函数，创建的无参数的对象：
运行结果：
调用了B的无参构造函数
class A
{ }
class B extends A
{
public B()
{
System.out.println("调用了B的无参构造函数");
}
} public class Testeeer
{
public static void main(String [] args)
{
B b_01=new B(); }
}
3.子类无构造函数，超类有无参数构造函数，创建的无参数的对象：
运行结果：
调用了A的无参构造函数
class A
{
public A()
{
System.out.println("调用了A的无参构造函数");
}
}
class B extends A
{ } public class Testeeer
{
public static void main(String [] args)
{
B b_01=new B(); }
}
4.子类有无参数构造函数，超类有无参数构造函数，创建的无参数的对象：
运行结果：
调用了A的无参构造函数
调用了B的无参构造函数
class A
{
public A()
{
System.out.println("调用了A的无参构造函数");
}
}
class B extends A
{
public B()
{
System.out.println("调用了B的无参构造函数");
}
} public class Testeeer
{
public static void main(String [] args)
{
B b_01=new B(); }
}
5.子类无构造函数，超类无构造函数，创建的有参数的对象：
编译不成功：
class A
{ } class B extends A
{ } public class Testeeer
{
public static void main(String [] args)
{ B b_02=new B("你好");
}
}
6.子类有无参数构造函数，超类无构造函数，创建的有参数的对象：
编译不成功：
class A
{ } class B extends A
{
public B()
{
System.out.println("调用了B的无参构造函数");
}
} public class Testeeer
{
public static void main(String [] args)
{ B b_02=new B("你好");
}
}
7.子类无构造函数，超类有无参数构造函数，创建的有参数的对象：
编译不成功：
class A
{
public A()
{
System.out.println("调用了A的无参构造函数");
}
} class B extends A
{ } public class Testeeer
{
public static void main(String [] args)
{ B b_02=new B("你好");
}
}
8.子类有无参数构造函数，超类有无参数构造函数，创建的有参数的对象：
编译不成功：
class A
{
public A()
{
System.out.println("调用了A的无参构造函数");
}
} class B extends A
{
public B()
{
System.out.println("调用了B的无参构造函数");
}
} public class Testeeer
{
public static void main(String [] args)
{ B b_02=new B("你好");
}
}
9.子类有有参数构造函数，超类无构造函数，创建的有参数的对象：
编译成功；
运行结果：
class A
{ }
class B extends A
{ public B(String mess)
{
System.out.println("调用了B的有参构造函数\n"+
"参数内容为："+mess);
} } public class Testeeer
{
public static void main(String [] args)
{
B b_02=new B("你好");
}
}
10.子类有有参数构造函数，超类有有参数构造函数，创建的有参数的对象：
编译失败：
class A
{
public A(String mess)
{
System.out.println("调用了A的有参构造函数\n"+
"参数内容为："+mess);
}
}
class B extends A
{ public B(String mess)
{
System.out.println("调用了B的有参构造函数\n"+
"参数内容为："+mess);
} } public class Testeeer
{
public static void main(String [] args)
{
B b_02=new B("你好");
}
}
11.子类有有参数构造函数（首行定义super），超类有有参数构造函数，创建的有参数的对象：
编译成功；
运行结果：
class A
{
public A(String mess)
{
System.out.println("调用了A的有参构造函数\n"+
"参数内容为："+mess);
}
}
class B extends A
{ public B(String mess)
{
super(mess);
System.out.println("调用了B的有参构造函数\n"+
"参数内容为："+mess);
} } public class Testeeer
{
public static void main(String [] args)
{
B b_02=new B("你好");
}
}
12.子类有有参数构造函数，超类有有参数构造函数和无参数的构造函数，创建的有参数的对象：
编译成功；
运行结果：
class A
{
public A(String mess)
{
System.out.println("调用了A的有参构造函数\n"+
"参数内容为："+mess);
}
public A()
{
System.out.println("调用了A的无参构造函数");
}
}
class B extends A
{ public B(String mess)
{ System.out.println("调用了B的有参构造函数\n"+
"参数内容为："+mess);
} } public class Testeeer
{
public static void main(String [] args)
{
B b_02=new B("你好");
}
}
13.子类有有参数构造函数，超类默认无构造函数，创建的有参数的对象：
编译成功；
运行结果：
class A
{ }
class B extends A
{ public B(String mess)
{ System.out.println("调用了B的有参构造函数\n"+
"参数内容为："+mess);
} } public class Testeeer
{
public static void main(String [] args)
{
B b_02=new B("你好");
}
}
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（形参）} 运行：超类有参构造，子类有参构造函数