1.繼承中，當new出子類，父類的構造器會先被調用，接着才是子類。

Execise5

package reuse;

public class Exercise05 extends A {
    private B b = new B();
    public static void main(String[] args) {
        new Exercise05(); //output A B
    }
}

class A{
    A(){
        System.out.println("A");
    }
}

class B{
    B(){
        System.out.println("B");
    }
}

2.如果父類是有參的，那麼調用父類的構造器時需要使用super(variable)。

Exercise8

package reuse;


class X{
    X(int i){
        System.out.println("X");
    }
}

public class Exercise08 extends X{
    Exercise08(int j){
        super(1);
        System.out.println("with arg");
    }
    Exercise08(){
        super(2);
        System.out.println("with no arg");
    }
    public static void main(String[] args) {
        new Exercise08(1);
        new Exercise08();
    }
}

Exercise9

public class Exercise09 extends Root {
    Exercise09(){
        System.out.println("Exercise09");
        Component1 c1 = new Component1();
        Component2 c2 = new Component2();
        Component3 c3 = new Component3();
    }
    public static void main(String[] args) {
        new Exercise09();
    }
}

class Component1{
    Component1(){
        System.out.println("Component1");
    }
}

class Component2{
    Component2(){
        System.out.println("Component2");
    }
}

class Component3{
    Component3(){
        System.out.println("Component3");
    }
}

class Root{
    Root(){
        System.out.println("Root");
        Component1 c1 = new Component1();
        Component2 c2 = new Component2();
        Component3 c3 = new Component3();
    }
}

3.清除對象的順序應該與創建對象的順序相反。

4.在java中，如果父類有多個重載的方法，在子類中重新定義這個方法相當於繼承了這些重載方法，並不會消失。

可以使用@override來檢查是否重寫正確。

package c05;

public class Exercise13 extends A{
    @Override void g(String a) { 
        System.out.println("g(String)");
    }
    public static void main(String[] args) {
        Exercise13 e = new Exercise13();
        e.g(1);
        e.g('c');
        e.g(1.0f);
        e.g("a"); //output:The method g(String) of type Exercise13 must override or implement a supertype method
    }
}

class A{
    void g(int i) {
        System.out.println("g(i)");
    }
        
    void g(char i) {
        System.out.println("g(j)");
    }
    void g(float i) {
        System.out.println("g(k)");
    }
}

5.protected方法僅包內的繼承子類可用。

package c05;

public class Exercise15 extends G {
    public void change(int set) {
        set(set);
    }
    public String toString() {
        return super.toString();
    }
    public static void main(String[] args) {
        Exercise15 e = new Exercise15();
        System.out.println(e);
        e.change(1);
        System.out.println(e);
    }
}

class G{
    private int i;
    protected void set(int j) {
        i = j;
    }
    public G() {
        System.out.println("A");
    }
    public String toString() {
        return "A set to" + i;
    }
}

6.upcasting 

Exercise16

package c05;

public class Frog extends Amphibian{
    public static void main(String[] args) {
        Frog a = new Frog();
        Amphibian.jump(a);
    }
}

class Amphibian{
    static void jump(Amphibian a) {
        System.out.println("Amphibian works");
    }
}

7.fina 關鍵字。對基本數據類型來説，final相當於常數。final static相當於這一片存儲空間無法被改變。引用前加static説明此引用無法指向另一個對象。如果final的數據在數據成員區域未初始化，則在構造器裏必須執行初始化。也能為參數列表賦值為final，同樣的，賦值為final的參數就不能改變了。
8.final和private,overriding只有在方法時是父類的接口的時候才會發生。如果方法時private，那麼此方法不屬於類的接口，只是隱藏在類中的代碼。如果你在子類中“override”這個方法（實際並沒有），你只是新建了一個同名的方法。

9.final類，即無法繼承。

10.首先，載入class文件，其次由父類開始一級一級往下初始化static。接着創造對象，所有基本數據都被初始化，所有對象句柄初始化為null，基類的構造器啓動，實例變量按照語句順序執行，最後就是剩餘的部分執行。