public class Test {
    public static void main(String[] args) {
//        InheritInner.test();
//        EggTest.test();
        LocalInnerClass.test();
    }
}

/*
    內部類的繼承：
        問題在於，那個指向外圍類對象的“秘密的”引用必須被初始化，而在導出類中
        不再勛在可鏈接的默認對象。要解決這個問題，必須使用特殊的語法來明確的
        說清楚它們之間的關聯。
 
 
*/

/*
    這個語法，好像有點復雜，不知道為什麽會有在外部繼承一個內部類的需求

    這幾行代碼的關系，理不清，就當做是一種語法給記下來吧
 */
class WithInner {
    class Inner{}
}
class InheritInner extends WithInner.Inner {
    InheritInner(WithInner withInner) {
        withInner.super();
    }

    public static void test() {
        WithInner wi 
 
= new WithInner();
        InheritInner ii = new InheritInner(wi);
    }
}

/*
    內部類會不會被覆蓋
 */

class Egg{
    private Yolk yolk;
    protected class Yolk {
        public Yolk() {
            System.out.println("Egg.Yolk()");
        }
    }

    public Egg() {
        System.out.println(
 
"new Egg()");
        yolk = new Yolk();
    }
}
class BigEgg extends Egg {
    public class Yolk {
        public Yolk() {
            System.out.println("BigEgg.Yolk()");
        }
    }

    //加行代碼，測試一下
    public BigEgg() {
        new Yolk();
    }
}

class Egg2 {
    protected class Yolk {
        public Yolk() {
            System.out.println("Egg2.Yolk()");
        }
        public void f() {
            System.out.println("Egg2.Yolk.f()");
        }
    }
    //這兒進行了改動
    private Yolk yolk = new Yolk();
    public Egg2(){
        System.out.println("New Egg2()");
    }

    public void insertYolk(Yolk yolk) {
        this.yolk = yolk;
    }

    public void g() {
        yolk.f();
    }
}
class BigEgg2 extends Egg2 {
    public class Yolk extends Egg2.Yolk {
        public Yolk() {
            System.out.println("BigEgg2.Yolk()");
        }
        public void f(){
            System.out.println("BigEgg2.Yolk.f()");
        }
    }

    public BigEgg2() {
        insertYolk(new Yolk());
    }
}

class EggTest {
    public static void test() {
        //我感覺這個案例沒有任何懸念
//        new BigEgg();
//        new BigEgg();

        /*
            分析下這一行代碼執行了哪些步驟：
                1.調用BigEgg2()，系統先構造父類對象；
                2.父類對象中，成員變量的值yolk先於構造函數，調用Yolk構造
                    輸出New Egg2.Yolk()
                3.調用Egg2的構造函數
                    輸出New Egg2()
                4.調用BigEgg2的構造，在構造中調用Yolk的構造，此時的Yolk是BigEgg2中定義的
                5.構造BigEgg2.Yolk前，先構造父類對象Egg2.Yolk
                    輸出New Egg2.Yolk()
                    輸出New BigEgg.Yolk()
         */
        Egg2 e2 = new BigEgg2();
        e2.g();
    }
}

/*
    局部內部類
        具備內部類不能有訪問說明符（static、private等）
        使用局部內部類而不使用匿名內部類的兩個理由：
            1.需要一個已命名的構造器
            2.需要不知一個該內部類對象
 */
interface Counter{ int next();}
class LocalInnerClass {

    private int count = 0;

    Counter getCounter(final String name) {
        class LocalCounter implements Counter {
            {
                System.out.println("LocalCounter()");
            }
            @Override
            public int next() {
//                System.out.println(name);
                return count++;
            }
        }
        return new LocalCounter();
    }

    Counter getCounter2(final String name) {
        return new Counter() {
            {
                System.out.println("Counter()");
            }
            @Override
            public int next() {
//                System.out.println(name);
                return count++;
            }
        };
    }

    public static void test() {
        LocalInnerClass lic = new LocalInnerClass();

        Counter c1 = lic.getCounter("A");
        Counter c2 = lic.getCounter2("B");

        for (int i = 0; i < 5; i++) {
            System.out.println(c1.next());
        }
        for (int i = 0; i < 5; i++) {
            System.out.println(c2.next());
        }
    }
}

Java編程思想：內部類其他知識點