Java的内部类

1、内部类的分类

（1）静态内部类

（2）成员内部类

（3）局部内部类-本地类

（4）匿名内部类

1.1、静态内部类

特点：
1.它可以定义静态和非静态的成员；

2.它仅仅可以访问外部类的静态字段和静态方法。

如何实例化：
Outer.Inner inner = new Outer.Inner();

1.2、成员内部类

特点：
1.除了static final修饰的编译时常量成员外，内部只能定义非静态成员；

2.可以访问外部类所有的成员，包括静态和非静态的；

如何实例化：
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
或者
Outer.Inner inner = new Outer().new Inner();

1.3、局部内部类-本地类

特点：
1.可以定义在一个方法里面或者{}代码块里面。 （是的，你没听错，可以在方法里面定义类）

2.类声明不能使用任何访问修饰符。

3.除了static final修饰的编译时常量成员外，内部只能定义非静态成员。

4.可以访问外部类所有的成员，包括静态和非静态的。

demo：
public class NewEnclosing { 
    {
	    class BlockLocal{ 
    	    void print(){
        	    //....
            }
	    } 
    }
 
    void run() {
        class Local { 
            static final int a=3; // 正确
            static int b=5; // 错误
            static final Object obj=null //错误，非编译时常量
            String c;//正确
            double d;//正确
 
            void run() {
                // method implementation
            }
        }
        Local local = new Local();
        local.run();
    }
 
    @Test
    public void test() {
        NewEnclosing newEnclosing = new NewEnclosing();
        newEnclosing.run();
    }
}

1.4、匿名内部类

特点：
1.匿名类是一次性使用的类，可以用于实现一个接口或者抽象类仅仅临时用一次，不能复用。

2.除了static final修饰的编译时常量成员外，内部只能定义非静态成员。

3.可以访问外部类所有的成员，包括静态和非静态的。

demo：
先定义一个抽象类：
abstract class SimpleAbstractClass {
    abstract void run();
}

然后看如何定义匿名类：
public class AnonymousInnerTest {
     
    @Test
    public void whenRunAnonymousClass_thenCorrect() {
        SimpleAbstractClass simpleAbstractClass = new SimpleAbstractClass() {
            void run() {
                // method implementation
            }
        };
        simpleAbstractClass.run();
    }
}