java 内部类 匿名内部类 嵌套类

内部类：

1. 在类的内部，内部类与普通类没有区别。

2. 内部类可以访问其任何外部类成员。

3. 生成外部类对象引用： 外部类名字.this

    在其他类中创建内部类实例： 外部类实例名字.new+内部构造函数

[java] view plain copy print ?

1. public class DotThis {  
2.     void f() { System.out.println("DotThis.f()"); }  
3.     public class Inner {  
4.         public DotThis outer() {  
5.             return DotThis.this;//生成外部类对象引用   
6.         }  
7.     }  
8.     public Inner inner() { return new Inner(); }  
9.     public static void main(String[] args) {  
10.         DotThis dt = new DotThis();  
11.         DotThis.Inner dti = dt.inner();  
12.         dti.outer().f();  
13.     }  
14. }  
15.   
16. public class DotNew {  
17.     public static void main(String[] args) {  
18.         DotThis dt = new DotThis();  
19.         DotThis.Inner dti = dt.new Inner();//在其他类中创建内部类实例   
20.     }  
21. }  

public class DotThis {
	void f() { System.out.println("DotThis.f()"); }
	public class Inner {
		public DotThis outer() {
			return DotThis.this;//生成外部类对象引用
		}
	}
	public Inner inner() { return new Inner(); }
	public static void main(String[] args) {
		DotThis dt = new DotThis();
		DotThis.Inner dti = dt.inner();
		dti.outer().f();
	}
}

public class DotNew {
	public static void main(String[] args) {
		DotThis dt = new DotThis();
		DotThis.Inner dti = dt.new Inner();//在其他类中创建内部类实例
	}
}

4. 可以在任意方法或作用域定义内部类。

匿名内部类：

1.   定义：

[java] view plain copy print ?

1. public class Parcel7 {  
2.     public Contents contents() {  
3.         return new Contents() {//定义匿名内部类   
4.             private int i = 11;  
5.             public int value() { return i; }  
6.         };  
7.     }  
8.     public static void main(String[] args) {  
9.         Parcel7 p = new Parcel7();  
10.         Contents c = p.contents();  
11.         System.out.println(c.value());  
12.     }  
13. }  

public class Parcel7 {
    public Contents 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();
        System.out.println(c.value());
    }
}

2. 匿名内部类的继承：

[java] view plain copy print ?

1. abstract class Base { //基准类   
2.     public Base(int i) {//构造函数，抽象类的构造函数和普通类的构造函数功能一样   
3.         System.out.println("Base constructor,i =" + i);  
4.     }  
5.     public abstract void f();  
6. }  
7. public class AnonymousConstructor {  
8.     public static Base getBase(int i) {  
9.         return new Base(i) {//会调用基类构造函数   
10.             {System.out.println("Inside instance initializer");}//由于是类的定义，必须声明为块，不然报错   
11.             public void f() {  
12.                 System.out.println("In anonymous f()");  
13.             }  
14.         };  
15.     }  
16.     public static void main(String[] args) {  
17.         Base base = getBase(12);  
18.         base.f();  
19.     }  
20. }  

abstract class Base { //基准类
    public Base(int i) {//构造函数，抽象类的构造函数和普通类的构造函数功能一样
        System.out.println("Base constructor,i =" + i);
    }
    public abstract void f();
}
public class AnonymousConstructor {
    public static Base getBase(int i) {
        return new Base(i) {//会调用基类构造函数
            {System.out.println("Inside instance initializer");}//由于是类的定义，必须声明为块，不然报错
            public void f() {
                System.out.println("In anonymous f()");
            }
        };
    }
    public static void main(String[] args) {
        Base base = getBase(12);
        base.f();
    }
}

输出：

[java] view plain copy print ?

1. Base constructor,i =12  //先调用基类构造函数   
2. Inside instance initializer  
3. In anonymous f()  

Base constructor,i =12  //先调用基类构造函数
Inside instance initializer
In anonymous f()

注：在匿名内部类中使用外部定义的对象，要求其参数引用为final类型。如下

[java] view plain copy print ?

1. public class Parcel10 {  
2.     public Destination destination(final String dest, final float price) {  
3.         return new Destination() {  
4.             private int cost;  
5.             {  
6.                 cost = Math.round(price);       //price为final   
7.                 if(cost > 100) {  
8.                     System.out.println("Over Budget!");  
9.                 }  
10.             }  
11.             private String label = dest;        //dest 为final   
12.             public String readLabel() { return label; }  
13.         };  
14.     }  
15.     public static void main(String[] args) {  
16.         Parcel10 p = new Parcel10();  
17.         Destination d = p.destination("Tasmania", 101.395F);  
18.     }  
19. }<SPAN style="COLOR: #993300">  
20. </SPAN>  

public class Parcel10 {
    public Destination destination(final String dest, final float price) {
        return new Destination() {
            private int cost;
            {
                cost = Math.round(price);       //price为final
                if(cost > 100) {
                    System.out.println("Over Budget!");
                }
            }
            private String label = dest;        //dest 为final
            public String readLabel() { return label; }
        };
    }
    public static void main(String[] args) {
        Parcel10 p = new Parcel10();
        Destination d = p.destination("Tasmania", 101.395F);
    }
}

否则出错：从内部类中访问局部变量 dest；需要被声明为最终类型

3. 匿名内部类的一些限制： 只能实现一个接口或继承一个类

嵌套类：

1. 内部类为static修饰时为嵌套类。

2. 创建嵌套类不需要外围对象。

3. 不能从嵌套类中访问非静态外围对象。

4. 普通内部类不能含有static数据和字段，也不能有嵌套类。但嵌套类能包含所有这些东西。

最后说说内部类的作用：

1. 实现多重继承

2. 回调的实现

3. 框架控制...

参考：thinking in java

都抄了写浅显的东西，有很多都没有理解的很好，也不敢写啊。希望以后能看得更深入。