1.什么是内部类？

可以将一个类的定义放在另一个类的定义内部，这就是内部类。

OuterClass oc = new OuterClass();

OuterClass.InnerClass ic = oc.new InnerClass();

2.匿名内部类

　　

public class Parcel7b{
class MyContents implements Contents{
private int i = 11;
public int value() {return i;} 
}
public Contents contents(){return new MyContents;}
public static void main(String[] args){
Parcel7b p = new Parcel7();
Contents c = p.Contents();
} 
}

上述内部类的声明方式如果转化成匿名内部类就是下面这个样子.

　　

public class Parcel7{
public Contests contents(){
return new Contents(){
private int i = 11;
public int value(){return i;}
};
}
public static void main(String[] args){
Parcel7 p = new Parcel7();
Contents c = p.Contents();
} 
}

　　

Thread t = new Thread() {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.print(i + " ");
}
}
};
t.start();

3.静态内部类(嵌套类)

4.为什么要使用内部类

这种属性对于多重继承来说，无疑是一种神器。

不只对于接口，假设你想继承两个或者三个类，外部类只能继承一个，剩下的而就可以交给内部类来实现，因为内部类可以持有外部类的引用，所以可以使用继承到的方法来操作外部类的数据，也就是说实现了多重继承。在《Thinking in Java》中举了一个通过内部类实现继承迭代器的方式。见P192

　　

abstract class InnerAny{
    abstract void out();
}
public class Outer{
    private int i = 0;
    class Inner{
        int i = 8;
        public void out(){
            System.out.println(this.i);
            System.out.println(Outer.this.i);
        }
    }
    static class InnerStaic{
        static int i = 1;
        public InnerStaic(Outer p){           
            i = p.i;
        }
    }
    public InnerAny ia(){
        return new InnerAny(){
            public void out(){
                Outer.this.i++;
                System.out.println(Outer.this.i);
            }
        };
    }
    public static void main(String[] args){
        Outer p = new Outer();
        System.out.println(p.i);
        //普通内部类
        Outer.Inner in = p.new Inner();
        in.out();
        p.i++;
        //静态内部类
        InnerStaic is = new InnerStaic(p);
        System.out.println(is.i);
        p.i++;
        System.out.println(Outer.InnerStaic.i);
        in.out();
        //匿名内部类
        InnerAny ia = p.ia();
        ia.out();
    } 
}