java 内部类

内部类：将一个类定义到另一个类内部。内部类是一种代码隐藏机制，并且内部类对象了解外围类，并能够与之通信。（内部类不是组合？？（暂时不知道如何解释））

package com.slowalker.inner;

public class Parcel1 {
    class Contents{
        public Contents() {
            System.out.println("Contents gener");
        }
        
        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 main(String[] args) {
        Parcel1 p = new Parcel1();
        p.ship("Tasmania");
    }
}

上例中定义了一个Parcel1的外部类，其中定义了两个内部类，在使用内部类时，就是正常的访问机制，一个内部类对象调用内部类方法。

package com.slowalker.inner;

public class Parcel2 {
    class Contents{
        public 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 main(String[] args) {
        Parcel2 p = new Parcel2();
        p.ship("Tasmania");
        Parcel2.Contents c =  p.new Contents();
        Parcel2.Contents d = new Parcel2().new Contents(); //创建内部类对象，必须通过外部类引用
        int a = c.value();
        System.out.println(a);
        System.out.println(c.value());
    }
}

如果我们需要使用内部类对象，则必须通过外部类的对象去引用。内部类所包含的方法，必须通过内部类调用。

在内部类中，可以访问外部类的方法和域

package com.slowalker.inner;

interface Selector{
    boolean end();
    Object current();
    void next();
}


public class Sequence {
    private Object[] items;
    private int next;
    
    public Sequence(int size) {
        items = new Object[size];
    }
    
    public void add(Object x) {
        if (next < items.length) {
            items[next++] = x;
        }
    }
    
    private class SequenceSelector implements Selector{  //实现了接口的内部类
        private int i = 0;
        
        //items是外部类的成员，内部类可以直接使用
        public boolean end() {return i == items.length;}
        public Object current() {return items[i];}
        public void next() {if (i < items.length) i++;}
        
    }
    
    public Selector selector() {
        return new SequenceSelector();
    }
    
    public static void main(String[] args) {
        
        //外部类对象创建用来修改外部类成员
        Sequence sequence = new Sequence(10);
        for(int i = 0; i < 10; i++) {
            sequence.add(Integer.toString(i));
        }
        
        //内部类创建用来迭代外部类
        Sequence.SequenceSelector selector = sequence.new SequenceSelector();
        
        while(!selector.end()) {
            System.out.println(selector.current() + " ");
            selector.next();
        }
    }
}

当某个外部类创建了一个内部类对象时，内部类对象会捕获一个指向该外部类的引用。内部类可以通过该引用使用该外部类对象的成员。

如果在内部类需要引用创建该内部类对象的外部类对象可以使用  外部类类名+".this".

package com.slowalker.inner;

public class DotThis {
    void f() {System.out.println("DotThis.f()");}
    
    public class Inner{
        
        public DotThis outner() {
            return DotThis.this;
        }
    }
    
    public Inner inner() {
        return new Inner();
    }
    
    public static void main(String[] args) {
        DotThis dt = new DotThis();
        DotThis.Inner i = dt.inner();
        i.outner().f();
    }
}