day06

续内部类

10.8 为什么需要内部类

1. 每个内部类都能独立地继承自一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响.
2. 内部类可以继承多个具体的或抽象的类的能力.从这个角度看,内部类使得多重继承的继承解决方案变得完整.接口解决了部分问题,而内部类有效地实现了"多重继承".也就是说,内部类允许继承多个非接口类型(译注:类或抽象类)

class D{}//具体类
abstract class E{}//抽象类
class Z extends D{
    E makeE(){
        return new E(){};
    }
}
public class MultiImplementation {
    static void takesD(D d){}
    static void takesE(E e){}
    public static void main(String[] args){
        Z z = new Z();
        takesD(z);
        takesE(z.makeE());
    }
}

1. 如果不需要解决"多重继承"问题,那么自然可以用别的方式编码,而不需要使用内部类.但如果使用内部类,还可以获得其他一些特性:
   1. 内部类可以有多个实例,每个实例都有自己的状态信息,并且与其外围类对象的信息相互独立.
   2. 再单个外围类中,可以让多个内部类以不同的方式实现同一个接口,或继承同一个类.
   3. 创建内部类对象的时刻并不依赖与外围类对象的创建
   4. 内部类并没有令人迷惑的"is - a"关系;他就是一个独立的实体

//分析程序的时候要分开来看先看Callee1然后看Callee2的运行
interface Incrementable{
    void increment();
}
class Calleel implements Incrementable{
    private int i =0;
    @Override
    public void increment() {
        i++;
        print(i);
    }
}
class MyIncrement{
    public void increment(){
        print("Other operatortion");
    }
    static void f(MyIncrement mi){
        mi.increment();
    }
}
//if your class must implement increment() in
//some other way ,you must use an inner class
//上面的注释很重要,就是如果你想要使用interface Increment中的increment方法只能用内部类因为继承中的MyIncrement中已经有了一个increment方法
class Callee2 extends MyIncrement{
    private int i = 0;
    public void increment(){
        super.increment();
        i++;
        print(i);
    }
    private class Closure implements Incrementable{
        public void increment(){
            //Specify outer-class method. therwise
            //you'd get an infinite recursion
            Callee2.this.increment();//用外部类来调用方法
        }
    }
    Incrementable getCallbackReference(){
        return new Closure();
    }
}
//Caller的构造器需要一个Incrementable的引用作为参数,然后在以后的某个时刻,Caller对象可以使用此引用回调Callee类
//回调的价值在于它的灵活性--可以在运行时动态地解决需要调用什么方法.
class Caller{
    private Incrementable callbackReference;
    Caller(Incrementable cbh){callbackReference = cbh;}
    void go(){callbackReference.increment();}
}
public class Callbacks {
    public static void main(String[] args) {
        Calleel c1 = new Calleel();
        Callee2 c2 = new Callee2();
        MyIncrement.f(c2);
        Caller caller1 = new Caller(c1);
        Caller caller2 = new Caller(c2.getCallbackReference());
        caller1.go();
        caller1.go();
        caller2.go();
        caller2.go();
    }
}

1. P208有一个设计模式内部类的设计可以研究一下

10.9内部类的继承

1. 语法: enclosingClassReference.super()

class WithInner{
    class Inner{}
}
public class InheritInner extends WithInner.Inner{
    //! InheritInner(){} //Won't complile
    InheritInner(WithInner wi){
        wi.super();
    }

    public static void main(String[] args) {
        WithInner wi = new WithInner();
        InheritInner ii = new InheritInner(wi);
    }
}

10.10内部类可以被覆盖吗

1. 下面程序解释现在BigEgg2.Yolk通过extends Egg2.Yolk明确的继承此内部类,并覆盖了其中的方法.insertYolk()方法允许BigEgg2将它自己的Yolk对象向上转型为Egg2中的引用y.
2. 使用当g()调用y.f()时,覆盖后的新版的f()被执行.第二次调用Egg2.Yolk(),结果好似BigEgg2.Yolk的构造器调用了其基类的构造器.

//看得我贼蒙圈等下我debug调试一下
//1.进入main方法
//2.找到public BigEgg2()构造方法
//3.找到public Egg2()构造方法
//4.初始化private Yolk y = new Yolk();此时Yolk=null
//5.找到public Yolk()构造方法
//6.输出print("Egg2.Yolk()");
//7.此时创建Yolk对象private Yolk y = new Yolk();
//8.输出print("New Egg2()");
//9.回到public BigEgg2()运行 insertYolk(new Yolk());
//10.找到 public Yolk()再找到父类Yolk并输出print("Egg2.Yolk()");
//再输出 print("BigEgg2.Yolk()");
//11.运行insertYolk(Yolk yy)方法并为y赋值yy
//12.运行e2.g();找到 public void g()
//13.运行y.f()运行子类中的新f()
//14.输出 print("BigEgg2.Yolk()");
class Egg2{
    protected class Yolk{
        public Yolk(){
            print("Egg2.Yolk()");
        }
        public void f(){
            print("Egg2.Yolk.f()");
        }
    }
    private Yolk y = new Yolk();
    public Egg2(){
        print("New Egg2()");
    }
    public void insertYolk(Yolk yy){
        y = yy;
    }
    public void g(){
        y.f();
    }
}
public class BigEgg2 extends Egg2{
    public class Yolk extends Egg2.Yolk{
        public Yolk(){
            print("BigEgg2.Yolk()");
        }
        public void f(){
            print("BigEgg2.Yolk()");
        }
    }
    public BigEgg2(){
        insertYolk(new Yolk());
    }

    public static void main(String[] args) {
        Egg2 e2 = new BigEgg2();
        e2.g();
    }
}

1. 当继承了某个外围类的时候,内部类并没有发生什么特别神奇的变化.这两个内部类是完全独立地两个实体,各自在自己的命名空间内.当然明确地继承某个内部类也是可以的.

10.11局部内部类

1. 使用局部内部类而不是使用匿名内部类的唯一理由就是,我们需要一个已命名的构造器,或者需要重载构造器,而匿名内部类只能用于实例初始化.
2. 局部内部类访问外部类方法的局部变量,这个局部变量必须是有效final--->将这个变量变成常量,存储到常量池中,保证声明周期延长.