《Java编程思想》——内部类，随笔

内部类：定义在另一个类内部的类

代码隐藏机制，远不止如此，可与外围类通信

基本语法：

内部类中通过.This返回当前外部类引用，通过.new生成一个新内部类对象

public class Outer {
    private String info;
    Outer(String info) { this.info = info; }

    class Inner {
        public String getOuterInfo() {  return info; }
        public Outer getOuter() { return Outer.this; }
    }

    public Inner getInner() { return new Inner(); }

    public static void main(String[] args) {
        Outer outer = new Outer("outer");
        Outer.Inner inner = outer.new Inner();
        Outer outer1 = inner.getOuter();
        Outer.Inner inner1 = outer1.getInner();
        System.out.println(outer == outer1);    //true
        System.out.println(inner == inner1);    //false
    }
}

内部类与向上转型：

        当将内部类向上转型为其基类，尤其是转型为一个接口的时候，内部类就有了用武之地。（从实现了某个接口的对象，得到此接口的引用，与向上转型为这个对象的基类，
实质上效果是一样的）这是因为此内部类——某个接口的实现——能够完全不可见，并且不可用。所得到的只是指向基类或接口的引用，所以能够很方便地隐藏实现细节。

class Parcel4 {
    private class PContents implements Contents {
        private int i = 11;
        public int value() { return i; }
    }

    protected class PDestination implements Destination {
        private String label;
        private PDestination(String whereTo) {  label = whereTo;  }
        public String readLabel() { return label;  }
    }

    public Destination destination(String s) { return new PDestination(s); }
    public Contents contents() { return new PContents(); }
}

public class TestParcel {
    public static void main(String[] args) {
        Parcel4 p = new Parcel4();
        Contents c = p.contents();
        Destination d = p.destination("Tasmania");
    }
}

为什么需要内部类：

每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。

内部类可以有效的实现多重继承，内部类允许继承多个非接口类型（类或抽象类）