继承问题

Question

1．子类无条件地继承父类不含参数的构造函数。
2．子类必须通过super关键字调用父类的构造函数。
3．子类无法继承父类的构造函数。
请帮忙看看哪个正确，错误！谢谢！！！

Answer 1

1在Java语言中正确！
2，3错误
父类
public class PClass { public PClass() {
System.out.println("PClass instanced");
}
}
子类：
public class CClazz extends PClass {
private String titleName;
public CClazz() {
System.out.println("CClazz instanced...");
}

public CClazz(String name) {
this();
titleName = name;
}

public void printTitle() {
System.out.println(titleName);
}

public static void main(String[] args)
{
CClazz cc = new CClazz();
cc.printTitle();
CClazz cc1 = new CClazz("test");
cc1.printTitle();
}
}
测试结果：
PClass instanced
CClazz instanced...
null
PClass instanced
CClazz instanced...
test

Answer 2

1错误，2,3正确
子类不能继承父类的构造方法。子类如果想继承父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示，并且super语句必须是构造方法中的第一句。

Answer 3

1是错误的，如果父类有带参数的构造函数，没有无参的构造，就不存在继承无参数的
2也是错误的，因为无参数的情况下，父类的构造函数被隐性地调用了，并不需要显示调super

Answer 4

“1．子类无条件地继承父类不含参数的构造函数。”构造函数不是被“继承”的，而是被层层调用的。
子类的构造函数必须调用父类的某个构造函数，这个调用一直延伸到 Object 类的无参构造函数。
“2．子类必须通过super关键字调用父类的构造函数。”子类必须调用父类的构造函数，但不一定非要写出 super(...);
用 super 来调用父类构造函数必须放在子类构造函数的第一句。
没有用 super 显式调用的时候，第一句有一个默认的隐藏的调用 super();
“3．子类无法继承父类的构造函数。”就“继承”的定义来说，这句话挑不出什么错误。

Answer 5

super关键字是调用父类方法的不是构造方法  所以3是对的

Answer 6

请问父类的构造方法System.out都在什么情况下输出呢，请高手指教下

Answer 7

1，2是错的，3是正确的，子类不能继承但可以调用父类的构造方法，如果不显式调用会自动调用没有参数的构造方法，所以不一定非要用super显式调用

Answer 8

子类不会获得父类的构造函数(即子类不能继承父类的构造器),但是子类构造器里可以调用父类构造器中的初始化代码，而且不管我们有没有使用super来调用(注意:这里是“调用”，不是"继承")父类的构造器，子类构造器都会调用构造器一次(隐式或显式调用)
显式调用父类构造器:
class Parent{
private String name;
private int age;

public Parent(String name, int age){
setName(name);
setAge(age);
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
class Child extends Parent{
private String school;
public Child(String name, int age, String school){
//用super关键字显式调用父类构造器
super(name, age);
this.school = school;
}
public void setSchool(String name){
this.school = school;
}
public String getSchool(){
return school;
}
}
public class InheritDemo{
public static void main(String[] args){
Child ch = new Child("zhou", 21, "MIT");
System.out.println("name = " + ch.getName() + "\n" + "age = " + ch.getAge() + "\n" + "school = " + ch.getSchool());
}
}
输出结果:name = zhou
age = 21
school = MIT
下面是隐式调用父类的构造器:
class SuperClass{
public SuperClass(){
//初始化内容
System.out.println("do something in superclass.....");
}
}
class SubClass extends SuperClass{
public SubClass(){
System.out.println("do something in subclass....");
}
}
public class Inherit{
public static void main(String[] args){
SubClass sc = new SubClass();
}
}
执行结果：do something in superclass...
do something in subclass....从输出结果可以看出来，在子类构造器中并没有显式调用父类的构造器,但是父类构造器中的内容仍然被打印出来，说明系统会在执行子类构造器之前，隐式调用父类的构造器。而且父类的构造器总会在子类构造器之前执行.
所以相对来说,3是正确的，1、2是错误的。

Answer 9

3是正确的
1．子类无条件地继承父类不含参数的构造函数。
2．子类必须通过super关键字调用父类的构造函数。
3．子类无法继承父类的构造函数。

Answer 10

受教了，一开始我个人认为是第二个正确的，看了解析后恍然大悟！我误解了子类调用父类的构造方法就必须使用super关键字，其实在子类进行new的时候就会默认你调用父类中无参数的构造方法！

Answer 11

java允许用“new 构造方法()”调用构造方法，所以2是错的，1和3没法用程序验证但是让我选的话我选3是对的