Java编程思想：内部类其他知识点

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());
        }
    }
}