首页 > 试题广场 >

What will be printed when you

[单选题]

下面代码输出结果是？

class C {
    C() {
        System.out.print("C");
    }
}

class A {
    C c = new C();

    A() {
        this("A");
        System.out.print("A");
    }

    A(String s) {
        System.out.print(s);
    }
}

class Test extends A {
    Test() {
        super("B");
        System.out.print("B");
    }

    public static void main(String[] args) {
        new Test();
    }
}

```
BB
```
```
CBB
```
```
BAB
```
```
None of the above
```

查看答案及解析

推荐

小海豹

初始化过程是这样的：

1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；

2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；

3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法；

4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；

（1）初始化父类的普通成员变量和代码块，执行 C c = new C(); 输出C

（2）super("B"); 表示调用父类的构造方法，不调用父类的无参构造函数，输出B

（3） System.out.print("B");

所以输出CBB

编辑于 2015-02-04 17:46:58 回复(36)

Trenson

选D，因为A类中没有有形参的构造函数，代码有错误。

1、初始化父类的普通成员变量和代码块，执行C c = new C();输出C

2、super("B"); 表示调用父类具有相同形参的构造方法，不调用父类的无参构造函数，而A类中没有此构造函数，这句话错误。此时继续调用A类中的无参构造函数，this(“A”);调用当前类中具有相同形参的构造函数，依然没有，这句话错误。

发表于 2015-01-02 22:36:05 回复(7)

kmust_XiaQing

首先new了一个子类对象，那么就要调用构造方法来初始化该子类对象，但是该类继承自A，所以要先调用父类的构造方法，这里通过super("B")显示的调用了父类的带参构造。执行父类的带参构造前要先对父类中的对象进行初始化，对父类中的c成员进行初始化，调用了C类的无参构造，所以调用顺序为：

先调用C类的无参构造

再调用A类的带参构造

最后调用调用子类的构造

编辑于 2015-08-21 15:34:27 回复(4)

披萨大叔

考察类的加载顺序：

父类静态成员变量、静态块>子类静态成员变量、静态块>父类普通成员变量、非静态块>父类构造函数>子类普通成员变量、非静态块>子类构造函数

这题最大的坑在于，会不会调用父类（A）的无参构造。

因为Test已经显式调用了super("B")，所以会直接调用A的有参构造。

如果删除super("B")，系统才会默认调用父类无参构造，此时答案为：CAAB。

发表于 2016-07-12 10:59:47 回复(4)

guanjian

注意三种情况：

1）输出CAAB

Test() {

super();

System.out.print("B");

}

2）输出CAAB

Test() {

System.out.print("B");

}

3）编译报错

Test() {

System.out.print("B");

super(); //Constructor call must be the first statement in a constructor

}

总结：java为了保证父类F 可以被构造，子类C的构造函数的第一行代码会插插插！！！！入F的构造函数

编辑于 2015-10-02 18:27:33 回复(6)

那天ws

实例化Test时，向上追溯类Test的父类A，加载类A。

类A中实例化了类C，然后找到C类，执行构造方法C(),输出“C”;

由于没有直接实例化A类，所以不执行其构造方法A（）；

回到类Test，执行Test的构造方法Test()，在Test()中通过super("B"),调用了Test父类的带参构造方法A（String s）,输出“B”;

接着向下走，执行System.out.print("B"),输出"B".

所以输出结果是：CBB

//若不对请指教

发表于 2016-03-25 15:18:05 回复(3)

小牛快跑233

1.类初始化阶段，先执行最顶层父类的静态初始化块，然后依次向下，直到执行当前类的静态初始化块

2.对象初始化阶段，先执行最顶层父类的普通初始化块、最顶层父类的构造器 ，然后依次向下，直到执行当前类的初始化块。

3.类初始化完成后，将会一直存在在虚拟机中，再次执行时无须再次进行类初始化。

这道题：

1.对象初始化阶段，执行父类普通成员变量和代码块，C c = new C()，这里输出C

2.然后因为子类调用的是带参数的构造方法，这里输出B

3.最后子类构造方法里输出B ，所以是CBB

编辑于 2016-08-10 20:01:56 回复(0)

~谈情^不说爱

1.首先要明确初始化实例的顺序：父类静态域，子类静态域，父类非静态代码块，父类构造器，子类非静态代码块，子类构造器。整体的顺序应该是这样的。

2.明白顺序之后这个题就已经理解了一半了，还有一半就是对super()和this()的理解。

3.按照题意，首先运行的是第八行的代码，输出C。

4.然后在选择父类构造器上，由于Test()中，已经指定了super("B")，这里的super（）本来就是要去调父类构造器，由于有参数，所以我们应该去调带参数的构造器，因此，我们第二个输出应为B。

5.最后我们输出子类构造器里的System.out.print("B");

6.因此最终答案为CBB

思考：如果缺少super（“B”）；这条语句的话，结果为CAAB，请问这是为什么？这里就考虑到this(),如果能够思考清楚原因，那这道题就算完全弄明白了

这是一道非常有意思的题，建议收藏

编辑于 2019-08-06 18:49:17 回复(0)

gethobby

初始化父类的静态代码块，当然包括静态变量，然后初始化子类的静态变量

初始化父类的非静态代码，包括非静态的变量等；

执行父类的构造函数；

初始化子类的非静态代码

执行子类的构造函数

发表于 2016-03-06 10:00:48 回复(1)

七。小H

这一题的执行顺序是：父类的动态代码块---->父类的构造方法（如果没有在子类中写super()方法，则父类用的是默认的构造方法，如果用了则要执行重载的构造方法）->子类的构造方法。

父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数

发表于 2015-10-08 21:40:46 回复(1)

有担当的可乐在摸鱼

成员变量的初始化在构造函数之前

发表于 2021-12-07 09:35:33 回复(0)

调皮的小蜗牛破防了

初始化过程是这样的：1）首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化； 2）然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化； 3）其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法； 4）最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法。

发表于 2021-10-14 03:55:50 回复(0)

牛客103459723号

对于子类和基类的初始化过程的补充:
1,先执行基类的静态变量初始化和静态代码块
2,执行子类的静态变量初始化和静态代码块
3,执行基类的普通变量初始化和普通代码块,然后这个时候执行到了子类中的构造函数中的第一行,如果没有显示的使用super()来调用基类中的构造函数,那么就隐式的调用基类中的无参构造函数,且无论是否显示的指定构造函数,都必须要放在子类构造函数中的第一行,即:执行普通变量和普通代码块, 然后根据子类构造器的情况来调用超类的构造函数
4, 执行子类的普通变量初始化和普通代码块,然后执行子类构造函数中的剩余部分
对应到本题中的过程:
先执行C c = new C();
执行super("B"),也就是A(String s){ System.out.println(s));
执行Test(){ super("B");System.out.println("B");}中的System.out.println("B")

发表于 2018-07-16 23:48:10 回复(0)

老子信了你滴邪

调用A类的构造方***初始化A类的成员变量。

发表于 2018-04-21 16:11:17 回复(0)

_墙里佳人笑🐾

这样的代码不会报错？？？

main函数是静态的！能调用非静态的函数？？？

我直接复制；连编译都编译不过去！

我想知道你们怎么运行的

发表于 2017-10-12 21:14:55 回复(1)

堆高高

注意：他显示调用父类方法俩，所以不会自己默认调用的

发表于 2022-03-25 14:50:45 回复(0)

笨小孩ovo

这题我想说千万要看清，注意super("B")调用的是父类A的有参构造函数，打印"C"，本题答案"CBB"，选择B选项。选错的集合，哈哈哈哈

编辑于 2022-11-03 09:16:09 回复(2)

牛客你号

本题要考察的细节就是是否执行父类的无参构造方法

因为在已经在子类中显式声明了调用父类的有参构造函数，因此，并不会再调用父类的无参构造函数

发表于 2021-09-20 10:55:23 回复(0)

mercury_mky

初始化过程是这样的： 1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化； 2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化； 3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法； 4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；

发表于 2021-08-22 23:19:00 回复(1)

我好饿_早知道不学Java了

先执行父类的成员变量C c = new C();

再执行有参构造方法A(String s)

发表于 2021-08-19 15:16:51 回复(0)

Chooper7

父子类的构造关系：

子类构造依赖父类构造。先构造父类，后构造子类。

子类默认调用父类无参构造，是隐式的。

子类可以显式调用父类的构造函数。

不写构造函数的类有一个默认的无参构造函数。

初始化：

初始化父类的静态变量和代码块

初始化子类的静态变量和代码块

初始化父类的成员变量，父类构造函数

初始化子类的成员变量，子类构造函数

编辑于 2021-07-19 09:16:41 回复(0)

提交观点

问题信息

Java 迅雷

上传者：策马啸西风

难度：

108条回答 8881收藏 10267浏览

What will be printed when you

问题信息

热门推荐

相关试题