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

内部类：

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

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

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

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

[java]
view plaincopyprint?

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();//在其他类中创建内部类实例
  
    }  
}  

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 plaincopyprint?

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());  
    }  
}  

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 plaincopyprint?

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();  
    }  
}  

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 plaincopyprint?

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

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

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

[java]
view plaincopyprint?

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);  
    }  
}<SPAN style="COLOR: #993300">  
</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

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