《java编程思想》——内部类

内部类

能够将一个类的定义放在另外一个类定义内部，这就是内部类。

 

建立内部类

//建立内部类且在外部类的一个方法返回一个指向内部类的引用
public class Parcel2 {
    //内部类Contents
    class Contents {
        private int i = 11;

        public int value() {
            return i;
        }
    }
    //内部类Destination
    class Destination {
        private String label;

        public Destination(String whereTO) {
            this.label = whereTO;
        }

        String readLabel() {
            return label;
        }
    }
    //返回指向内部类的引用
    public Destination whereTo(String s){
        return  new Destination(s);
    }
    //返回指向内部类的引用
    public Contents contents(){
       return new Contents();
    }

    public void ship(String desc) {
        //Contents内部类实例
        Contents c = contents();
        //Destination内部类实例
        Destination d = whereTo(desc);
        System.out.println(d.readLabel());
    }

    public static void main(String[] args) {
        Parcel2 p = new Parcel2();
        p.ship("Tasmania");

        Parcel2 q = new Parcel2();
        //若是想从外部类的非静态方法以外的任意位置建立某个内部类的
        //对象,那么就必须像下面的例子指明这个对象的类型:OuterClassName.InnerClassName
        Parcel2.Contents c = q.contents();
        Parcel2.Destination d = q.whereTo("from");
        System.out.println(d.readLabel());
    }
}

链接到外部类

//迭代器
public interface Selector {
    boolean end();

    Object current();

    void next();
}

public class Sequence {
    //items和next为外部类
    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;
        }
    }

    private class SequenceSelector implements Selector {
        private int i = 0;

        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));
        }
        Selector selector = sequence.selector();
        while (!selector.end()){
            System.out.println(selector.current() + "");
            selector.next();
        }
    }
}

内部类拥有对其外部类全部成员的访问权(就好像本身拥有这些成员同样),如何作到呢?
    当某个外部类的对象建立了一个内部类对象时,此内部类对象一定会秘密地捕获一个指向那个外围类对象的引用,而后当访问此外部类成员的时,就用那个引用选择外围类的成员.

使用.this与.new

内部类与向上转型

在方法和做用域内的内部类

匿名内部类

嵌套类

接口内部类

为何须要内部类

内部类的继承

局部内部类

内部类能够被覆盖吗？