内部类:
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();//在其他类中创建内部类实例
}
}
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());
}
}
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();
}
}
输出:
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);
}
}
否则出错:从内部类中访问局部变量 dest;需要被声明为最终类型
3. 匿名内部类的一些限制: 只能实现一个接口或继承一个类
嵌套类:
1. 内部类为static修饰时为嵌套类。
2. 创建嵌套类不需要外围对象。
3. 不能从嵌套类中访问非静态外围对象。
4. 普通内部类不能含有static数据和字段,也不能有嵌套类。但嵌套类能包含所有这些东西。
最后说说内部类的作用:
1. 实现多重继承
2. 回调的实现
3. 框架控制...
参考:thinking in java
都抄了写浅显的东西,有很多都没有理解的很好,也不敢写啊。希望以后能看得更深入。