_
普通内部类
静态内部类
局部内部类
匿名内部类
内部类
内部类是定义在另一个类中的类，定义内部类会起到的作用有以下三点：
1、内部类方法访问该类定义所在的作用域中的数据，包括私有的数据。
2、内部类可以对同一个包中的其他类隐藏起来
3、当想定义一个回调函数且不想写大量代码，使用匿名（anonymous）内部类会更加便捷。
下面用简单的内部类例子说明内部类的使用方式。
class OuterClass {
private int outId = 0;
private String outName = "out";
public void outerShow() {
System.out.println("OuterClass");
System.out.println(outId + ":" + outName);
}
public class InnerClass {
private String inName="inner";
public void InnerShow() {
System.out.println("InnerClass");
System.out.println(outName + ":"+ this.inName);
}
}
}
public class InnerClassDemo {
public static void main(String[] args) {
OuterClass out = new OuterClass();
OuterClass.InnerClass in = out. new InnerClass ();
in.InnerShow();
}
}
通过代码可以发现，
1、内部类也可以用访问修饰进行控制（private public protected）
2、若内部类的是公开的 (public) ，可以直接在其它地方创建该类的实例。前提是该内部类的外部类的对象必须已经存在。代码如下：OuterClass.InnerClass in = out. new InnerClass ();
3、内部类也可以使用 this 进行属性调用
4、内部类既可以访问自己的数据域，也可以访问创建它的外围类对象的数据域。
这是因为，内部类的对象总有一个隐式引用，指向它的外部类对象。如图：
这个引用在内部类的定义中是不可见的,现在我们将外围类对象的引用称为 outer。于是 InnerShow 方法将等价干下列形式形式：
public void InnerShow() {
System.out.println("InnerClass");
System.out.println(outer.outName + ":"+ outer.inName);
}
外部类的引用在构造器中设置。编译器修改了所有的内部类的构造器，添加一个外部类引用的参数。因为 InnerClass 类没有定义构造器，所以编译器为这个类生成了一个默认的构造器，其代码如下所示：
public InnerClass(OuterClass out){
outer=out
}
备注：outer 不是Java 的关键宇。只是用它说明内部类中的机制。
内部类的特殊语法规则
在上面，已经讲述了内部类有一个外部类的引用 outer。事实上，使用外部类引用的正规语法还要复杂一些。
表达式 ： OuterClass.this. ——表示外部类引用。
例如，可以像下面这样编写 InnerClass 内部类的 InnerShow 方法
public void InnerShow() {
System.out.println("InnerClass");
System.out.println(OuterClass.this.outName + ":"+ OuterClass.this.inName);
}
通常 this 限定词是多余的。不过，可以通过这种方式区分内部类与外部类属性名相同情况时，内部类的调用问题。
重点：内部类中声明的静态属性必须是 final。原因很简单，我们希望一个静态域只有一个实例，不过对于每个外部对像，会分别有一个单独的内部类实例。如果这个不是 final ，它可能就不是唯一的。
内部类不可以定义 static 方法。
静态内部类
关键字 static 中提到 static 可以修饰成员变量、方法、代码块，其他它还可以修饰内部类，使用static修饰的内部类我们称之为静态内部类，也称之为嵌套内部类。
静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：
1、 它的创建是不需要依赖于外围类的。
2、 它不能使用任何外围类的非static成员变量和方法。
局部内部类
局部类不能用 public 或 private 访问说明符进行声明，它的作用域被限定在声明这个局部类的块中。
局部类有一个优势，即对外部世界可以完全地隐藏起来。即使 OuterClass 类中的其他代码也不能访问它。除 outShow 方法外没有任何方法知道 AnonymousClass 类的存在。
public void outerShow() {
System.out.println("OuterClass");
System.out.println(outId + ":" + outName);
int age=123;
class AnonymousClass{
private void show(){
System.out.println(age);
}
}
new AnonymousClass().show();
}
匿名内部类
匿名内部类的常用方式，实现函数的回调。
public abstract class Bird {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract int fly();
}
public class Test {
public void test(Bird bird){
System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
}
public static void main(String[] args) {
Test test = new Test();
test.test(new Bird() {
public int fly() {
return 10000;
}
public String getName() {
return "大雁";
}
});
}
}
------------------
Output：
大雁能够飞 10000米
在使用匿名内部类的过程中，我们需要注意如下几点：
1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
匿名内部类初始化
经常使用构造器来完成某个实例的初始化工作的，但是匿名内部类是没有构造器的！对此，我们可以使用构造代码块进行初始化工作。 演示代码如下：
interface InnerClass{
public String getName();
public int getAge();
}
public class OuterClass {
//java 8之前需要 final int age,final String name
public InnerClass getInnerClass(int age,String name){
return new InnerClass() {
int age_ ;
String name_;
//构造代码块完成初始化工作
{
if(0 < age && age < 200){
age_ = age;
name_ = name;
}
}
public String getName() {
return name_;
}
public int getAge() {
return age_;
}
};
}
public static void main(String[] args) {
OuterClass out = new OuterClass();
InnerClass inner_1 = out.getInnerClass(201, "chenssy");
System.out.println(inner_1.getName());
InnerClass inner_2 = out.getInnerClass(23, "chenssy");
System.out.println(inner_2.getName());
}
}
备注：在Java SE 8 之前，必须把局部类和匿名内部类访问的局部变量声明为 final 。