class SuperClass { private int n; SuperClass(){ System.out.println("SuperClass()"); } SuperClass(int n) { System.out.println("SuperClass(int n)"); this.n = n; } } // SubClass 类继承 class SubClass extends SuperClass{ private int n; SubClass(){ // 自动调用父类的无参数构造器 System.out.println("SubClass"); } public SubClass(int n){ super(300); // 调用父类中带有参数的构造器 System.out.println("SubClass(int n):"+n); this.n = n; } } // SubClass2 类继承 class SubClass2 extends SuperClass{ private int n; SubClass2(){ super(300); // 调用父类中带有参数的构造器 System.out.println("SubClass2"); } public SubClass2(int n){ // 自动调用父类的无参数构造器 System.out.println("SubClass2(int n):"+n); this.n = n; } } public class TestSuperSub{ public static void main (String args[]){ System.out.println("------SubClass 类继承------"); SubClass sc1 = new SubClass(); SubClass sc2 = new SubClass(100); System.out.println("------SubClass2 类继承------"); SubClass2 sc3 = new SubClass2(); SubClass2 sc4 = new SubClass2(200); } }

这段代码演示了Java中的继承和构造器的调用顺序。

其中，`SuperClass`是一个父类，有两个构造器，一个无参数构造器和一个带有一个参数的构造器。`SubClass`和`SubClass2`是两个子类，它们分别继承`SuperClass`。

在`SubClass`和`SubClass2`的构造器中，分别调用了`super()`方法来调用父类的构造器。

当创建`SubClass`对象时，会先自动调用父类的无参数构造器，然后再调用子类的无参数构造器。当创建`SubClass`对象时，会先调用父类的带有一个参数的构造器，然后再调用子类的带有一个参数的构造器。

因此，运行这段代码的结果如下：

------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 类继承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200

可以看到，当创建`SubClass`对象时，先输出了`SuperClass()`，然后输出了`SubClass`。当创建`SubClass2`对象时，先输出了`SuperClass(int n)`，然后输出了`SubClass2`。

相关问题

class SuperClass{ String name; public SuperClass(String s)/{ name =s; System. out.println(s)； public void method(){ System. out.println("superclass!"); } }

这是一个 Java 代码段，其中定义了一个名为 SuperClass 的类，它有一个字符串类型的属性 name 和一个构造函数，构造函数的参数为字符串类型 s，构造函数会将 s 赋值给属性 name 并输出 s。此外，SuperClass 还有一个名为 method 的方法，它会输出 "superclass!"。

import java.io.*; public class abc{ public static void main(String args[]){ SubSubClass x=new SubSubClass(1,2,3); x.show();} class SuperClass{ int a,b: SuperClass(int aa,int bb) {a=aa: b=bb;} void show(){ System.out.println("a="+a+"\nb="+b);} class SubClass extends SuperClass{ int c; SubClass(int aa,int bb,int cc){ super(aa,bb); c=cc;}} class SubSubClass extends SubClass {int a; SubSubClass(int aa,int bb,int cc) {super(aa,bb,cc); a=aa*bb*cc;} void show(){ System.out.println("a="+a+"b="+b+"c="+c);}}

这是一个 Java 程序，定义了名为 abc 的类。该类包含一个 main 方法和三个内部类：SuperClass、SubClass 和 SubSubClass。

SuperClass 类中定义了两个整型属性 a 和 b，以及一个构造方法 SuperClass(int aa,int bb)，该方法用于初始化 a 和 b 的值。类中还定义了一个 show 方法，用于输出 a 和 b 的值。

SubClass 类继承了 SuperClass 类，并新增了一个整型属性 c，以及一个构造方法 SubClass(int aa,int bb,int cc)，该方法用于初始化 a、b 和 c 的值。

SubSubClass 类继承了 SubClass 类，并新增了一个整型属性 a，以及一个构造方法 SubSubClass(int aa,int bb,int cc)，该方法用于初始化 a、b、c 的值，并计算 a 的值。

SubSubClass 类中还重写了 show 方法，输出 a、b、c 的值。

在 main 方法中，程序创建了一个 SubSubClass 类的对象 x，并传入参数 1、2、3。接着，程序调用 x 的 show 方法，输出结果为 "a=6 b=2 c=3"。

需要注意的是，该程序中存在一些语法错误：1、SuperClass 类中的 b 属性赋值应该为 b=bb;，即冒号应该改为等号；2、在 SubSubClass 类中，类定义的右括号应该放在 show 方法的右括号之后。