java?内部类分类

 

2012-07-09 22:20阅读：

内部类分类
摘自百度百科，实例进行了测试，上传以备查阅。
一、内部类的特点：
（1）内部类仍然是一个独立的类，在编译后内部类会被编译成独立的.class 文件，但是前面以外部类类名+$符号。
（2）内部类不能用普通的方式访问。内部类是外部类的一个成员，可以自由地访问类的成员变量，无论是否private的。
（3）内部类声明成静态的，就不能随便访问外部类的成员变量，仍然只能访问外部类的静态成员变量。
二、内部类的分类
１、成员内部类
class Outer{//外部类
　　class Inner{}//内部类
}
//编译后生成两个文件：Outer.class和Outer$Inner.class
２、静态嵌套类
静态内部类中可以定义静态或者非静态的成员。
从技术上讲，静态嵌套类不属于内部类。因为内部类与外部类共享一种特殊关系，更确切地说是对实例的共享关系。而静态嵌套类则没有
上述关系。它只是位置在另一个类的内部，因此也被称为顶级嵌套类。
静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它。静态嵌套类不能访问外部类的成员和方法。
class Outer{
　static class Inner{}//静态内部类
}
class Test {
　public static void main(String[] args){
　　Outer.Inner n = new Outer.Inner();
　}
}
３、方法内部类
class Outer {
public void doSomething() {
final int a = 10;
class Inner {
public void seeOuter() {
System.out.println(a);// 使用方法变量只能是final的。
}
}
Inner in = new I

加载中...

内容加载失败，点击此处重试

加载全文

nner();
in.seeOuter();
}
public static void main(String[] args) {
Outer out = new Outer();
out.doSomething();
}
}
(1)方法内部类只能在定义该内部类的方法内实例化，不能在此方法外对其实例化。
(2)方法内部类对象不能使用该内部类所在方法的非final变量。因为方法变量位于栈上，只存在于该方法的生命期内。而方法内部类对象
在方法结束后仍可能存在于堆中。例如，对它的引用被传递到其他某些代码，产存储在一个成员变量中。
４、匿名内部类
匿名内部类就是没有名字的内部类，使用该类必须满足下列条件：
(1)只用到类的一个实例
(2)类在定义后马上用到
(3)类非常小（推荐4行代码以下）
(4)给类命名并不会导致你的代码更容易理解
使用匿名内部类的约束原则：
(1)匿名内部类不能有构造方法。
(2)匿名内部类不能定义任何静态成员、方法和类。
(3)匿名内部类不能是public、protected、private、static的。
(4)只能创建匿名内部类的一个实例。
(5)一个匿名内部类一定在new的后面，用其隐含实现一个接口或实现一个类。
(6)因匿名内部类为局部内部类，所局部内部类的所有限制对其生效。
A、继承式的匿名内部类
class Car {
public void drive() {
System.out.println('Driving a car!');
}
public static void main(String[] args) {
Car car = new Car() {
public void drive() {
System.out.println('Driving anther car!');
}
};
car.drive();
}
}
结果输出了：Driving another car! Car引用变量不是引用Car对象，而是Car匿名子类的对象。
B、接口式的匿名内部类。 　　
interface Vehicle {
public void drive();
}
public class Test {
public static void main(String[] args) {
Vehicle v = new Vehicle() {
public void drive() {
System.out.println('Driving a car!');
}
};
v.drive();
}
}
上面的代码很怪，好像是在实例化一个接口。
事实并非如此，接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。
C、参数式的匿名内部类。
class Bar {
void doStuff(Foo f) {
f.foo();//在方法中调用参数式匿名内部类
}
}
interface Foo {void foo();}
public class Test {
public void go() {
Bar b = new Bar();
b.doStuff(new Foo() {
public void foo() {
System.out.println('foofy');
}
});
}
public static void main(String[] args){
Test t = new Test();
t.go();
}