java继承当中都有一些什么样的构造函数规则？

继承当中的构造函数规则
马克-to-win：继承当中的构造函数规则貌似复杂： 记住我给你的以下几条口诀， 你高枕无忧。1）如果你在某类中写了带参构造函数，系统就不会再为你在那类中自动添加无参构造函数了。2）如你没有写无参构造函数，且机器也不会为你自动添加这个无参构造函数时（因为你已经有带参构造函数了），你不可以主动调无参构造函数。3）子类的构造函数中不能人为的写两个super。4）构造函数中要是你人工想写super，super必须为第一句话。构造函数中要是你不写super，机器会为你加无参数super().马克-to-win：5）既然super必须为第一句话，创建子类对象时，构造函数调用次序为，先最低的超类直到最高的子类。
马克- to-win：马克 java社区：防盗版实名手机尾号： 73203。

例1.6.1

class AAAMark_to_win {
    AAAMark_to_win() {
        System.out.println("Inside AAAMark_to_win's constructor.");
    }
    AAAMark_to_win(int j) {
        System.out.println(j);
    }
}
class BBB extends AAAMark_to_win {
    BBB() {
        super(3);
        System.out.println("Inside BBB's constructor.");
    }
    BBB(int i) {
        System.out.println(i);
    }
}
class C extends BBB {
    C(int a) {
/*马克-to-win: super必须是第一句话，彻底不写也行。因为机器会为你自动加。
super must be the first statement. without it, also ok.the result
is exactly the same as right now, because machine will add automatically for you. but if you have it, it must be the first statement.
*/    
//        super();//注意这上下两句，只能保留一个
        super(1);
        System.out.println("Inside C's constructor.");
    }
}

public class Test {
    public static void main(String args[]) {
/*马克-to-win: 这里你不能写成C()，即使不谈继承，也一样。因为你已经有C(int a) {} ，系统不会为你自动添加C() {} 。
 
here you can not write as new C(); even without inheritance,still, you can not write as new C(); because if you have C(int a) {} already, machine will not automatically add C() {} for you.*/
        C c = new C(5);
    }
}

result:

Inside AAAMark_to_win's constructor.
1
Inside C's constructor.

例1.6.2

class AAAMark_to_win {
    AAAMark_to_win() {
        System.out.println("Inside AAAMark_to_win's constructor.");
    }
}
class BBB extends AAAMark_to_win {
    BBB(double g) {
        System.out.println("Inside BBB's constructor.");
    }
}
class C extends BBB {
    C(int a) {
/* 马克-to-win: 假如你没有下列的super(5.9)，系统将报错，因为你没有BBB(){}， 系统也不会自动替你加。if you don't have the following super(5.9), it will report error, because you don't have BBB(){}.*/
        super(5.9);
        System.out.println("Inside C's constructor1.");
    }
}
public class Test {
public static void main(String args[]) {
        C c = new C(5);
    }
}

　

result is:
Inside AAAMark_to_win's constructor.
Inside BBB's constructor.
Inside C's constructor1.

例1.6.2-b:

class AAAMark_to_win {
    AAAMark_to_win() {
        System.out.println("Inside AAAMark_to_win's constructor.");
    }
    AAAMark_to_win(int j) {
        System.out.println(j);
    }
}
class BBB extends AAAMark_to_win {


}
class C extends BBB {
    C(int a) {
/*马克-to-win: super必须是第一句话，彻底不写也行。因为机器会为你自动加。
super must be the first statement. without it, also ok.the result
is exactly the same as right now, because machine will add automatically for you. but if you have it, it must be the first statement.
*/   
    //    super();//注意这上下两句，只能保留一个
        //    super(1);
        System.out.println("Inside C's constructor.");
    }
}

public class Test {
    public static void main(String args[]) {
/*马克-to-win: 这里你不能写成C()，即使不谈继承，也一样。因为你已经有C(int a) {} ，系统不会为你自动添加C() {} 。
 
here you can not write as new C(); even without inheritance,still, you can not write as new C(); because if you have C(int a) {} already, machine will not automatically add C() {} for you.*/
        C c = new C(5);
    }
}


结果：
Inside AAAMark_to_win's constructor.
Inside C's constructor.

例1.6.3

class AAAMark_to_win {
    AAAMark_to_win() {
        System.out.println("Inside A's constructor.");
    }
}
class BBB extends AAAMark_to_win {
    BBB() {
        System.out.println("Inside BBB's constructor.");
    }
}
class C extends BBB {
/* 马克-to-win: 无论C（）整个comment out，还是把C（）里面的内容都去掉，我试过，效果是一样的，AAAMark_to_win和BBB的构造函数都会被调用。 AAAMark_to_win' constructor and BBB's constructor still are called， */
    C() {
        System.out.println("Inside C's constructor.");
    }
}
public class Test {
    public static void main(String args[]) {
        C c = new C();
    }
}

result is:

Inside A's constructor.
Inside BCC's constructor.
Inside C's constructor.