内部类之Java学习笔记

创建内部类

可以将一个类的定义放在另一个类的内部，这就是内部类。如下所示：

// 迭代器接口
interface Selector {
    boolean end();
    Object current();
    void next();
}

// 使用迭代器现实数组的遍历
public 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;
        }
    }
    
    // 定义私有的内部类
    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) {
        int count = 10;
        Sequence sequence = new Sequence(count);
        for (int i = 0; i < count; i++){
            sequence.add(i);
        }
        
        // 使用外围类的引用获取内部类
        Selector selector = sequence.selector();
        
        while(!selector.end()){
            System.out.print(selector.current() + "  ");
            selector.next();
        }
    }
}

1. 内部类可以访问外围类的方法和属性，就像自己拥有它们的似的；
2. 构建内部类对象时需要一个指向外围类对象的引用；
3. private内部类给类的设计者提供了一种途径，通过这种方式可以完全阻止任何依赖于类型的编码，并且完全隐藏了实现的细节；

从多层嵌套类中访问外部类的成员

一个内部类被嵌套多少层并不重要---它能透明地访问所有它所嵌入的外围类的所有员，如下所示

public class MultiNestingAccess {
    class MNA{
        private void f(){}
        class A{
            private void g(){}
            public class B{
                
                // 访问所有它所嵌入的外围类的所有员
                void h() {
                    g();
                    f();
                }
            }
        }
    }
    
    public static void main(String[] args) {
        MultiNestingAccess multi = new MultiNestingAccess();
        
        // 创建各层内部类对象
        MNA mna = multi.new MNA();
        MNA.A mnaa = mna.new A();
        MNA.A.B mnaab = mnaa.new B();
        mnaab.h();
    }
}

1. MNA.A.B可以访问所有它所嵌入的外围类的所有员，从而有效的现实了“多重继承”