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

内部类：

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

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

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

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

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.   定义：

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. 匿名内部类的继承：

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

输出：

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

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

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

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

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

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