Java内部类

内部类

被定义在另一个类的内部，所以称为内部类（Nested Class）。

Inner Class

静态内部类的创建
        外部类.内部类 变量名 = new 外部类.内部类();
    非静态内部类的创建
        外部类.内部类 变量名 = new 外部类().new 内部类();

如果一个类定义在另一个类的内部，这个类就是Inner Class：

class Outer {
    class Inner {
        // 定义了一个Inner Class
    }
}

Outer是一个普通类，而Inner是一个Inner Class，它与普通类有个最大的不同，就是Inner Class的实例不能单独存在，必须依附于一个Outer Class的实例

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer("Nested"); // 实例化一个Outer
        Outer.Inner inner = outer.new Inner(); // 实例化一个Inner
        inner.hello();
    }
}

class Outer {
    private String name;

    Outer(String name) {
        this.name = name;
    }

    class Inner {
        void hello() {
            System.out.println("Hello, " + Outer.this.name);
        }
    }
}

要实例化一个Inner，我们必须首先创建一个Outer的实例，然后，调用Outer实例的new来创建Inner实例：

Outer.Inner inner = outer.new Inner();

这是因为Inner Class除了有一个this指向它自己，还隐含地持有一个Outer Class实例，可以用Outer.this访问这个实例。所以，实例化一个Inner Class不能脱离Outer实例。

Inner Class和普通Class相比，除了能引用Outer实例外，还有一个额外的“特权”，就是可以修改Outer Class的private字段，因为Inner Class的作用域在Outer Class内部，所以能访问Outer Class的private字段和方法。

所谓的内部类 其实就是某一个类的成员(实例 静态)而已

静态内部类（Static Nested Class）

定义在外部类的内部，使用static修饰，类比静态方法，静态内部类不需要外部类对象产生就能使用，不能访问外部类的成员域，但能访问静态域

1.静态内部类和静态方法一样，只能访问外部的静态成员变量和方法，不能访问非静态的成员变量和方法

2.静态内部类可以单独初始化

public class Outer {
	
	public static Inner {
	
	}
	
}

静态内部类的创建语法：

1.外部类内部：与成员内部类一样

2.外部类外部：Static InnerClass.Inner inner = new Static InnerClass.Inner();

静态的内容是随着类的加载而存在的（静态方法区） 实例成员是随着对象的创建而存在的
如果内部类中需要定义静态成员，那么该内部类也必须是静态的

匿名类（Anonymous Class）

不需要在Outer Class中明确地定义这个Class，而是在方法内部，通过匿名类（Anonymous Class）来定义

Runnable r = new Runnable() {
    // 实现必要的抽象方法...
};

class Outer {
    private String name;

    Outer(String name) {
        this.name = name;
    }

    void asyncHello() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello, " + Outer.this.name);
            }
        };
        new Thread(r).start();
    }

在方法内部实例化了一个Runnable。Runnable本身是接口，接口是不能实例化的，所以这里实际上是定义了一个实现了Runnable接口的匿名类，并且通过new实例化该匿名类，然后转型为Runnable。

匿名类和Inner Class一样，可以访问Outer Class的private字段和方法。之所以我们要定义匿名类，是因为在这里我们通常不关心类名，比直接定义Inner Class可以少写很多代码。