考虑下下面代码输出结果
public class test3 {
public static void main(String[] args) {
new Child("mike");
}
}
class People {
String name;
public People() {
System.out.print(1);
}
public People(String name) {
System.out.print(2);
this.name = name;
}
}
class Child extends People {
People father;
public Child(String name) {
System.out.print(3);
this.name = name;
father = new People(name + ":F");
}
public Child() {
System.out.print(4);
}
}
答案在最后
下面是一个延伸题
public class Dervied extends Base {
private String name = "dervied";
public Dervied() {
tellName();
printName();
}
public void tellName() {
System.out.println("Dervied tell name: " + name);
}
public void printName() {
System.out.println("Dervied print name: " + name);
}
public static void main(String[] args){
new Dervied();
}
}
class Base {
private String name = "base";
public Base() {
tellName();
printName();
}
public void tellName() {
System.out.println("Base tell name: " + name);
}
public void printName() {
System.out.println("Base print name: " + name);
}
}
第一题答案: 132
解析:考察的又是父类与子类的构造函数调用次序。在Java中,子类的构造过程中必须调用其父类的构造函数,是因为有继承关系存在时,子类要把父类的内容继承下来。但如果父类有多个构造函数时,该如何选择调用呢?
第一个规则:子类的构造过程中,必须调用其父类的构造方法。一个类,如果我们不写构造方法,那么编译器会帮我们加上一个默认的构造方法(就是没有参数的构造方法),但是如果你自己写了构造方法,那么编译器就不会给你添加了,所以有时候当你new一个子类对象的时候,肯定调用了子类的构造方法,但是如果在子类构造方法中我们并没有显示的调用基类的构造方法,如:super(); 这样就会调用父类没有参数的构造方法。
第二个规则:如果子类的构造方法中既没有显示的调用基类构造方法,而基类中又没有无参的构造方法,则编译出错,所以,通常我们需要显示的:super(参数列表),来调用父类有参数的构造函数,此时无参的构造函数就不会被调用。
总之,一句话:子类没有显示调用父类构造函数,不管子类构造函数是否带参数都默认调用父类无参的构造函数,若父类没有则编译出错。
第二题:
Dervied tell name: null
Dervied print name: null
Dervied tell name: dervied
Dervied print name: dervied
解析:
在第一题的基础上,
子类的构造过程中必须调用其父类的构造函数,因为有继承关系存在时,先父后子;
其次:子类可以访问父类的非私有成员变量和非私有方法,但是父类不可以访问子类的一切
第二部分(个人验证过的)
子父类中的构造函数的特点:
1.在子类构造对象时,发现,访问子类构造函数时,父类构造函数也运行了。
原因是:在子类的构造函数中第一行有一语句。 super();
类似于this(); this();调用的是本类的构造函数
2.supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。如果不放在子类构造函数的第一行, super();就会报错。
3.同时子类构造函数中如果使用this调用了本类构造函数时,那么super就没有了,因为super和this都只能定义第一行,所以只能有一个。但是可以保证的是,子类中肯定会有其他的构造函数访问父类的构造函数。
4.子类构造函数默认调用的是父类中的空参数构造函数,如果需要调用父类中带参数的构造函数,可以在子类构造函数中定义。如:super(6);
public class JichengTest {
private String value1;
private String value2;
public String value3;
public JichengTest(){
System.out.println("I am just parent");
}
}
public class ChildTest extends JichengTest {
public ChildTest(){
//super();
System.out.println("I am just ChildTest");
}
public ChildTest(int num){
this();
System.out.println("I am just ChildTest and have a num");
}
public static void main(String[] args) {
ChildTest test = new ChildTest();
System.out.println(" -----");
ChildTest test2 = new ChildTest(2);
System.out.println("main end");
}
}
结果为:
I am just parent
I am just ChildTest
-----
I am just parentI am just ChildTest
I am just ChildTest and have a num
main end
5.java:当父类无无参构造函数并且有其他构造函数时,子类不能调用默认构造函数
class Parent{
public Parent(int b) {
}
public void getA()
{
System.out.println("getA");
}
}
class Child extends Parent{
public Child() {
super();//编译不通过
}
public void getA() {
System.out.println("sadf");
}
}
public class Test{
public static void main(String[] args) {
Parent aParent=new Child();
}
}
结合:子类没有显示调用父类构造函数,不管子类构造函数是否带参数都默认调用父类无参的构造函数,若父类没有则编译出错。以及当父类无无参构造函数并且有其他构造函数时,子类不能调用默认构造函数。
出现了下面的问题:
java中只要调用子类的构造函数就要调用父类无参数的构造函数吗?若父类中不存在无参数构造函数会出错吗?
答:Java中只要调用子类的构造函数就一定会调用父类的构造函数,这是毋庸置疑的!有时我们并没有在父类中写有参和无参的构造方法,但是这样我们在定义子类对象时调用子类构造函数时,其实也调用父类的构造函数,这是系统自动为我们添加的“public Pen(){}”。但是如果我们在父类中已经自己定义了有参的构造方法,却没有定义无参的构造方法,那么此时系统是不会为我们自动添加无参的构造方法的,此时程序结果就会提醒你父类没有无参的构造方法,程序就会报错。
class Pen {
public Pen(){}
public Pen(String newColor, double newLength, double newPrice){
.............................;
.............................;
}
}
class Pencile extends Pen{
public static int count=0;
public Pencile(){
count++;
}
public int GetCount(){
return count;
}
public class Test {
public static void main(String[] args){
Pencile A=new Pencile();
Pencile B=new Pencile();
System.out.println( "共创建了"+A.GetCount()+"个实例!" );
}
}
这段代码的结果应该是:共创建了2个实例!,这个结果是不难想象的,但是如果这段代码我们把“public Pen(){}”这段无参的构造函数注释掉的话,那么这个程序就会出现问题了。但是如果我们不但注释掉“public Pen(){}”,同样的我们也注释掉“
public Pen(String newColor, double newLength, double newPrice){}”这样的有参数的构造函数,那么这个程序又能执行了,而且输出同样的结果。正好说明了上面的结论。
参考链接有:https://blog.csdn.net/xiayizhanqihang/article/details/55808059
https://www.cnblogs.com/weihao950903/p/5310845.html