内部类和嵌套类

匿名类的作用主要在于实现多继承、闭包，回调。生成的.class形式为outer$inner.class

以下是多继承的例子。

class A {}
class B {}

class P1 extends A{
	class C extends B{
		//...
	}
}

内部类和嵌套类区别

普通内部类通过引用实例与外部建立联系，所以普通内部类不能有static的变量活方法。

static在编译分配空间，而内部类依赖于外部类的实例。

接口内部类

接口中的任类何都自动是public和static。因为类是static的，只是将嵌套类置于接口的命名空间内，

这并不违反接口的规则。

内部类继承

内部类必须有实例，内部类的构造器必须链接到指向外围类对象的引用，所以在继承内部类时那个指向外围类对象的“秘密的”引用必须被初始化，而在导出类（子类）中不再存在可连接的默认对象，要解决这个问题，必须使用特殊的语法来明确说明他们之间的关联：

public class TEST {
	public static void main(String[] args){
		Outer o = new Outer();
		SubInner si = new SubInner(o);
		si.func();
	}
}

class Outer{
	class Inner{
		void func(){
			System.out.println("Outer.Inner.func");
		}
	}
}

class SubInner extends Outer.Inner{
	SubInner(Outer o){ //内部类的导出类（子类）的构造函数必须是外围类的引用，并且在构造器中要调用外围构造器.super方法。
		o.super();
	}
}

内部类.this和.new

在创建内部类的时候，必须先创建外部类的对象，然后以outobject.new Inner()的形式来创建。如此也解决了内部类的作用域问题。

如果是嵌套类，即Inner是Static的，则创建方法就不一样，不需要外部类的对象。Outer.Inner i = new Outer.Inner();

class OuterClass
{
	int data = 3;
	
	class InnerClass
	{
		void func()
		{
			//访问外围类的成员
			System.out.println("InnerClass.func "+ "data:" + data);
		}
	}
	
	InnerClass getInnerClass()
	{
		return new InnerClass();
	}
	
	OuterClass getSelf()
	{
		return OuterClass.this;
	}
}

static class StaticOuterClass
{
	static class InnerClass
	{
	}
}
public class NewTest
{
	public static void main(String[] arg)
	{
		
		OuterClass t = new OuterClass();
		//通过OuterClass.this来返回当前实例对象
		t.getSelf().getInnerClass().func();
		
		//创建内部类不可以直接通过new OuterClass.InnerClass
		//必须使用外部类的实例，通过.new语法来实现
		OuterClass.InnerClass nt = t.new InnerClass();
		nt.func();
	}
}

<完>