只想把基础打好-Java内部类

内部类的类型

普通内部类（非静态）

public class Outer {
    class Inner{}
}

实际例子：

public interface Iterator<T> {
    boolean hasNext();
    T next();
}

public class MyList<T> {
   private Object[] list;
   private int size;
   private int currentSize;

   public MyList(int size){
       list=new Object[size];
       this.size=size;
   }
   public void add(T element){
       if(currentSize<size){
           list[currentSize++]=element;
       }else{
           //抛出异常
       }
   }
   public void remove(){
       if(currentSize>0){
           list[--currentSize]=null;
       }else{
           //抛出异常
       }
   }
   Iterator interator(){
       return new Itr<T>();
   }

class Itr<T> implements Iterator<T>{
    int cursor;       // index of next element to return

    @Override
    public boolean hasNext() {
        return cursor<currentSize;
    }

    @Override
    public T next() {
        if(hasNext()){
          //  lastRet++;
            int i=cursor;
            cursor++;
            return  (T)list[i];

        }

        return null;
    }
}
}

测试代码

  public static void main(String[] args){
        MyList<String> list=new MyList<>(10);
        list.add("today");
        list.add("is");
        list.add("week");
        list.add("?");
        Iterator iterator=list.interator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }

运行结果：

today
is
week
?

这是一个典型的迭代器模式。从上面例子可以看出，内部可以访问外围类的成员变量，当然也可以访问成员方法，因为生成内部类的对象的时候就与制造它的外围类对象就有了联系，内部类有外围类的所有元素的访问权。这是怎么做到的呢？

  protected void test(){
        Outer outer=new Outer();
       // Outer.Inner inner=new Outer().new Inner();
        Outer.Inner inner=outer.new Inner();
        inner.getI();
    }

    class Outer{
        int i=10;
        class Inner{
            public void getI(){
                System.out.println("outer class i="+i);
            }
        }
    }

从上面看出得到一个内部实例的例子，创建一个内部类实例的时候必须要得到一个外围类的实例，然后再按照outer.new Inner()来得到一个内部类对象。拥有外部类对象之前是不可能创建内部类实例的（除非是静态内部类，稍后说）。当通过外围类对象创建内部类实例的时候，秘密捕获了这个指向外围类的对象，当在内部类访问外围类的成员的就是用的这个对象调用外围的对象。幸运的是，编辑器帮你处理了这些细节。

public void getI(){
        //完整调用语句
               System.out.println("outer class i="+Outer.this.i);
           }

在java中比较常见的是集合类中使用迭代器。

局部内部类

public class Outer {
    public void test(){
        class Inner{}
        new Inner();
    }
  //  class Inner{}
}

可以在任意的方法或作用域定义内部类。我们可以创建一个类来辅助解决方案，而又不想这个类是共用的。如上，Inner定义在test方法中，所以在test方法外不能直接访问Inner类。

 class Outer{
        public IInner getInner(){
            class  Inner implements IInner{

                @Override
                public void innerPrint() {
                    System.out.println("innerclass in innerPrint");
                }
            }
            return new Inner();
        }

    }
interface IInner{
        void innerPrint();
}

return 语句中用了向上转型，当使用此方法时得到一个基类对象的引用就可以很好的隐藏实现细节，通过这种方式可以完全阻止任何任何依赖于类型的编码。也不是意味着getInner方法执行结束了之后Inner就不可用了。你可以在同一个子目录下的任意类使用Inner进行类标识，这并不会有命名冲突。

匿名内部类

将上面例子修改下

 class Outer{
        public IInner getInner(){
            return new IInner() {
                @Override
                public void innerPrint() {
                    System.out.println("innerclass in innerPrint");
                }
            };
        }

匿名内部类就是没有名字的类，自动向上转型为基类，在匿名内部类使用了默认的构造器来生成对象，那如果你的基类需要一个有参数的构造器怎么办呢？

public class Parcle {
    public Wrapping wrapping(int x){
        return new Wrapping(x){
            public  int value(){
                return super.value()*47;
            }
        };
    }
}

public class Wrapping {
    private int i;
    public Wrapping(int x){
        i=x;
    }
    public int value(){
        return i;
    }
}

只需要地传递合适的参数给基类的构造器即可，这里是将x给new Wrapping(x),尽管Wrapping只是一个具有实现的普通类，但它还是被其导出类当作公共"接口"来使用。匿名内部类与正规的继承相比有些受限，因为匿名内部类即可以扩展类，也可以实现接口，但是不能两者兼备。而且如果实现接口也只能实现一个接口。
就像在android里面给View添加点击事件监听都是实现一个匿名内部类，如果在一个方法中定义，而想访问方法里的局部变量，那么由于作用域的特性必需在局部变量前加上final，使其成为常量。

静态内部类

如果不需要内部类与外围类之间有联系，那么可以将内部类声明为static。这样内部类的创建不需要依赖于外部类，因此静态内部类可能访问外围类的静态成员。它没有一个指向外围类的引用。静态内部类与非静态内部类还有一个区别，普通内部类的字段和方法，只能放在类的外部层次上，所以普通的内部类不能有static和static 字段，也不能包含静态内部类，但是静态内部类可以。

接口内部的类

正常情况下，不能在接口 内部放置任何代码，但静态内部类可以作为接口的一部份，放到接口中的任何类都是public和static的。如果你想要创建某此公共代码，使得它们可以被某个接口的所有不同实现所共用，那么使用接口内部的嵌套类会很方便。要做测试的话可以在每个类中都写一个main()方法，用来测试这个类。这样做有一个缺点，那就是必须带着那些已编译过的额外代码。那我们就可以用嵌套类来放置测试代码。

public class TestBed{
public void f(){
System.out.println("f()");
}
public static class Tester{
public static void main(String[] args){
TestBed t=new TestBed();
t.f();
}
}
}

这生成了一个独立的类TestBed$Tester,不想在发布的产品中包含它，在将产品打包前可以简单地删除TestBed$Tester.class

说说内部类的其它特性

多重嵌套内部类访问外部类的成员

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

class MNA{
private void f(){}
class A{
private void g(){}
public class B{
void h(){
f();
g();
}
}
}
}

闭包

闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。通过这个定义，可以看到非静态内部类是面向对象的闭包，因为它不仅包含外围类对象的信息，还自动拥有一个指向此外围类对象的引用，在此作用域内，内部类有权操作所有的成员，包括private成员。

内部类的继承

因为非静态内部类的构造器必须连接到指向其外围类的引用，所以在继承内部类的时候情况会有些复杂。问题在于指向外围类对象的“秘密的”引用必须被初始化，而在导出类中不再存在可连接的默认对象。要解决这个问题，必须使用特殊的语法来明确说清楚它们之间的关联：

class WithInner{
class Inner{}}

public class InheritInner extends WithInner.Inner{
InheritInner(WithInner wi){
wi.super();
}
public static void main(String[] args){
WithInner wi=new WithInner();
InheritInner ii=new InheritInner(wi);
}
}

可以看到InheritInner只继承自内部类，而不是外围类，但是当要生成一个构造器时，默认的构造器并不算好，而且不能只是传递一个指向外围类的引用 。此外，必须在构造器中使用如下语法：

wi.super();

内部类可以被覆盖吗

public class Egg {
    private Yolk y;
    protected class Yolk{
        public Yolk(){
            System.out.println("Egg.Yolk()");
        }
    }
    public Egg(){
        System.out.println("New Egg()");
        y=new Yolk();
    }
}

public class BigEgg extends Egg {
    public class Yolk{
        public Yolk(){
            System.out.println("BigEgg.Yolk()");
        }
    }
    public static void main(String[] args){
        new BigEgg();
    }
}

运行结果

New Egg()
Egg.Yolk()

这个例子说明，当继承了某个外围类的时候，内部类并没有发生什么特别神奇的变化。这两个内部类是完全独立的个体，各自在自己的命名空间里。当然，明确地继承某个内部类也是可以的。

内部类标识符

由于每个类都会产生一个.class文件，其中包含了如何创建该类型的对象的全部信息，当然内部类也会产生一个.class文件，这些类文件 的命名有严格的规则，外围类的名字加上$再加上内部类的名字，如果是匿名内部类则是外围类名加$加上数字。