class Guy { public Guy(){ System.out.print("111,"); } } class Cowboy extends Guy { public Cowboy(){ System.out.print("222,"); } } class Wrangler extends Cowboy { public Wrangler(){ System.out.print("333,"); } } public class Greeting2 { public static void main(String[] args) { Guy g1 = new Guy(); Guy g2 = new Cowboy(); Guy g3 = new Wrangler(); } }结果

这段代码定义了三个类`Guy`、`Cowboy`和`Wrangler`，其中`Cowboy`继承自`Guy`，`Wrangler`继承自`Cowboy`。`Guy`类中定义了一个无参构造函数，并输出`111`，`Cowboy`类和`Wrangler`类中也分别定义了无参构造函数，并输出`222`和`333`。

在`main`方法中，分别创建了三个`Guy`类型的变量`g1`、`g2`和`g3`，分别初始化为`new Guy()`、`new Cowboy()`和`new Wrangler()`。由于`Cowboy`是`Guy`的子类，`Wrangler`是`Cowboy`的子类，因此创建子类对象时会先调用父类构造函数，再调用子类构造函数。

对于`g1`，直接创建了`Guy`对象，因此只会调用`Guy`类的构造函数，输出`111`。

对于`g2`，创建了`Cowboy`对象并赋值给`Guy`类型的变量，因此会先调用`Guy`类的构造函数，输出`111`，再调用`Cowboy`类的构造函数，输出`222`。

对于`g3`，创建了`Wrangler`对象并赋值给`Guy`类型的变量，因此会先调用`Guy`类的构造函数，输出`111`，再调用`Cowboy`类的构造函数，输出`222`，最后调用`Wrangler`类的构造函数，输出`333`。

因此，程序的输出结果为`111,111,222,111,222,333,`。

相关问题

结果class Guy{ String greet(){ return "hi "; } } class Cowboy extends Guy{ String greet(){ return "howdy "; } } class Wrangler extends Cowboy{ String greet(){ return "ouch! "; } } class Greetings2 { public static void main (String [] args) { Guy g=new Wrangler(); Guy g2=new Cowboy(); Wrangler w2=new Wrangler(); } }

这段代码是一个 Java 程序，其中定义了 4 个类。`Guy` 类中定义了一个名为 `greet` 的方法，返回 "hi " 的字符串；`Cowboy` 类继承自 `Guy` 类，并重写了 `greet` 方法，返回 "howdy " 的字符串；`Wrangler` 类继承自 `Cowboy` 类，并重写了 `greet` 方法，返回 "ouch! " 的字符串。在 `Greetings2` 类的 `main` 方法中，首先创建了一个 `Wrangler` 类型的对象 `g`，然后将 `g` 赋值给 `Guy` 类型的变量 `g`，这是一个向上转型的过程。由于 `Wrangler` 类继承自 `Cowboy` 类，而 `Cowboy` 类继承自 `Guy` 类，因此 `Wrangler` 类型的对象可以被赋值给 `Guy` 类型的变量。接着，创建了一个 `Cowboy` 类型的对象 `g2`，然后创建了一个 `Wrangler` 类型的对象 `w2`。