public class Test {    public static void main(String[] args) {//        Parcel1.test();//        Parcel2.test();//        Sequence.test();        DotThis.test();    }}class Parcel1 {    class Contents {        private int i = 11;        public int value() {            return i;        }    }    class Destination {        private String label;        Destination(String whereTo) {            label = whereTo;        }        String readLabel() {            return label;        }    }    public void ship(String dest) {        Contents c = new Contents();        Destination d = new Destination(dest);        System.out.println(d.readLabel());    }    public static void test() {        Parcel1 p = new Parcel1();        p.ship("A");    }}/*    更典型的情况是：外部类将有一个方法，该方法返回一个指向内部类的引用。    截止到目前，内部类都是有方案被更换的 */class Parcel2 {    class Contents {        private int i = 11;        public int value() {            return i;        }    }    class Destination {        private String label;        Destination(String whereTo) {            label = whereTo;        }        String readLabel() {            return label;        }    }    public Destination to(String s) {        return new Destination(s);    }    public Contents contents() {        return new Contents();    }    public void ship(String dest) {        //上一个实验中，这儿是手动new出来的        Contents c = contents();        Destination d = to(dest);        System.out.println(d.readLabel());    }    public static void test() {        Parcel2 p = new Parcel2();        p.ship("B");        Parcel2 p2 = new Parcel2();        Parcel2.Destination d = p2.to("C");        Parcel2.Contents c = p2.contents();    }}/*    当生成一个内部类的对象时，此对象与制造它的外围对象之间就有了一种联系，所以它能访问    其他外围对象的所有成员，而不需要任何特殊条件。此外，内部类还拥有其外部类的所有元素    的访问权。    我突然想到了一件事，实现Iterable接口的iterator()方法时，我们就返回的是一个内部    类。一直不理解这个内部类设计的好处，现在发现自己一直在用它。 *//*    当某个外部类的对象创建了一个内部类对象时，此内部类对象必定会秘密的捕获一个指向那个    外部类的引用。内部类对象只能在与其外围类的对象相关联的情况下才能被创建（在内部类是    非static类时）。 */interface Selector {    boolean end();    Object current();    void next();}class Sequence {    private Object[] items;    private int next = 0;    public Sequence(int size) {        items = new Object[size];    }    public void add(Object x) {        if (next < items.length) {            items[next]=x;            next++;        }    }    private class SequenceSelector implements Selector {        private int i = 0;        @Override        public boolean end() {            /*                书中的逻辑：return i == items.length;                我觉得不太严谨，又没有说，一定要把items装满，除非你想取到空元素                我的逻辑：                    return i >= next;             */            return i >= next;        }        @Override        public Object current() {            if (i < next) {                return items[i];            }            return null;        }        @Override        public void next() {            i++;        }    }    private Selector selector() {        return new SequenceSelector();    }    public static void test() {        Sequence sequence = new Sequence(100);        for (int i = 0; i < 10; i++) {            sequence.add(Integer.toString(i));        }        Selector selector = sequence.selector();        while (!selector.end()) {            System.out.println(selector.current()+" ");            selector.next();        }    }}/*    需求：        如果你在内部类中需要生成对外部类的对象的引用，可以使用外部类的名字后面紧跟圆点和        this。 */class DotThis {    void f() {        System.out.println("DotThis.f()");    }    public class Inner {        public DotThis outer() {            return DotThis.this;        }    }    public Inner inner() {        return new Inner();    }    public static void test() {        DotThis outter = new DotThis();        DotThis.Inner inner = outter.inner();        inner.outer().f();    }}/*    需求：        有时，你可能想要告知某些其他对象，去创建某个内部类的对象。要实现这个目的，你必须        在new表达式中提供对其他外部类对象的引用，这就需要.new语法。            ——怎么告知？        我感觉这就是一个，创建内部类对象的语法        想要直接创建内部类的对象，不能去引用外部内的名字，而必须使用外部类的对象来创建该        内部类的对象，就像在上面的程序中所看到的那样。 */class DotNew {    public class Inner {    }    public static void test() {        DotNew dn = new DotNew();        /*            这种编码果然创建不了内部类的对象，编译器报错说：DotNew.this cannot 关联到            一个静态的上下文。联系上文说的，创建一个内部类时是需要捕捉一个外围内的引用的            这种方式得不到外围类的引用， 所以无法完成创建。            DotNew.Inner di = new DotNew.Inner();         */        DotNew.Inner di = dn.new Inner();    }}class Parcel3 {    class Contents {        private int i = 11;        public int value() {            return i;        }    }    class Destination {        private String label;        Destination(String whereTo) {            label = whereTo;        }        String readLabel() {            return label;        }    }    public static void test() {        Parcel3 p = new Parcel3();        Parcel3.Contents c = p.new Contents();        Parcel3.Destination d = p.new Destination("D");    }}