内部类一 ：内部类对象依赖外部类对象

 在一个类的内部定义一个类（没有被static关键字修饰），这个类内部的类就是内部类。外部类的权限只有默认访问权限或者包访问权限。

如果有别的访问权限修饰符，会报如下的编译器错误：

Illegal modifier for the class Test; only public, abstract & final are permitted

而内部类 可以被public protected private三个修饰符修饰的

如果这个内部类被static 关键字修饰了，那么称之为 嵌套类

内部类可以访问外部类的实例成员和实例方法

package chapter10;

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

package chapter10;

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;

        @Override
        public boolean end() {
            return i == items.length;
        }

        @Override
        public Object current() {
            //在内部类中可以直接访问外部类的对象，
            return items[i];
        }

        @Override
        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.print(selector.current()+" ");
            selector.next();
        }
        
    }

}

当某个外围类的对象撞见一个内部类对象时，此内部类对象必定会秘密地捕获一个指向外部类的对象的引用。然后用这个捕获的引用来访问外围类的成员。捕获外围类引用的细节都由编译器来操作。内部类的对象只能在与其外围类的对象相关联的情况下才能被创建。构建内部类对象时，需要一个指向外围类对象的引用，如果编译器访问不到这个引用就会报错。

必须创建外部类对象之后才能创建内部类

package chapter10;

public class DotNew {
    public class Inner{
        
    }
    
    public static void main(String[] args) {
        DotNew dn=new DotNew();
        
        DotNew.Inner dni=dn.new Inner();//通过.new关键字创建内部类对象
    }
}

在拥有外部类对象之前时不可能创建内部类对象的，因为内部类对象会暗暗地连接到创建它的外部类对象上。但是如果创建的是嵌套类（静态内部类），那么嵌套类的对象不需要引用外部类对象的引用