java 内部类和静态内部类和匿名内部类的区别

https://blog.csdn.net/Apple_wolf/article/details/118419673

成员内部类：不想被其他类公开使用的类，因为外部类只能定义为public或者缺省。类是属于对象的，所以不能有静态属性
静态内部类：一个类与另一个类关联性比较强，但是又可以不依赖外部类而独立存在。比如HashMap与Node。静态内部类是属于类的，跟普通类使用没什么区别。
局部内部类：局部内部类访问方法中定义的final类型的局部变量，局部类完全对外部隐藏，比较少用
匿名内部类：适用于快速构造对象，lambda表达式等场景

1 内部类

就是定义在另外一个类里面的类。它隐藏在外部类中，封装性更强，不允许除外部类外的其他类访问它；普通内部类作为外部类的成员，它可直接访问外部类的成员。

2 静态内部类

就是定义在另外一个类里面的类。带static 关键字的。


public class OuterClass {
    private String sex;
    public static String name = "chenssy";

    /**
     *静态内部类
     */
    static class InnerClass1{
        /* 在静态内部类中可以存在静态成员 */
        public static String _name1 = "chenssy_static";

        public void display(){
            /*
             * 静态内部类只能访问外围类的静态成员变量和方法
             * 不能访问外围类的非静态成员变量和方法
             */
            System.out.println("OutClass name :" + name);
        }
    }

    /**
     * 内部类
     */
    class InnerClass2{
        /* 非静态内部类中不能存在静态成员 */
        public String _name2 = "chenssy_inner";
        /* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的 */
        public void display(){
            System.out.println("OuterClass name：" + name);
        }
    }

    /**
     * @desc 外围类方法
     * @author chenssy
     * @data 2013-10-25
     * @return void
     */
    public void display(){
        /* 外围类访问静态内部类：内部类. */
        System.out.println(InnerClass1._name1);
        /* 静态内部类 可以直接创建实例不需要依赖于外围类 */
        new InnerClass1().display();

        /* 非静态内部的创建需要依赖于外围类 */
        OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
        /* 方位非静态内部类的成员需要使用非静态内部类的实例 */
        System.out.println(inner2._name2);
        inner2.display();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display();
    }
}

静态内部类和内部类的不同

1.静态内部类可以有静态成员(方法，属性)，而非静态内部类则不能有静态成员(方法，属性)。
2.静态内部类只能访问外部类的静态成员变量和静态方法，而非静态内部类由于持有对外部类的引用（this），可以访问外部类的所用成员

3.对象创建的方式不同

　　静态内部类无需依赖于外部类，它可以独立于外部对象而存在，可以和外部类一样使用创建方式是注意是new 外部类本身.静态内部类()。

*  b.实例化一个静态内部类的方法：
　　　　*  a.不依赖于外部类的实例,直接实例化内部类对象
　　　　*  OutClassTest.InnerStaticClass inner = new OutClassTest.InnerStaticClass();
　　　　*   b.调用内部静态类的方法或静态变量,通过类名直接调用
　　　　*  OutClassTest.InnerStaticClass.static_value
　　　　*  OutClassTest.InnerStaticClass.getMessage()

　　内部类创建对象的时候，不能独立于外部类，必须要先创建外部类的对象，然后再用这个对象来new出内部类的对象创建方式是 是外部类实例.new 内部类()。

　　　　* a.实例化一个非静态的内部类的方法：
　　　　 * a.先生成一个外部类对象实例
　　　　* OutClassTest oc1 = new OutClassTest();
　　　　 * b.通过外部类的对象实例生成内部类对象
　　　　 * OutClassTest.InnerClass no_static_inner = oc1.new InnerClass();

使用内部类的好处：

　　1. 它隐藏在外部类中，封装性更强，不允许除外部类外的其他类访问它；但它可直接访问外部类的成员。

　　2.也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外部类是否已经继承了某个接口。因此，内部类使多重继承的解决方案变得更加完整。

3 匿名内部类适合创建那种只需要一次使用的类。

　　为啥使用匿名内部类：比如：现在有一个接口，规范了某些功能，但是在别的类中突然想使用这个功能，但是又只用一次就行了，如果再创建一个类，实现该接口，然后再调用该类，多麻烦啊！举例：我们创建线程的时候。用匿名内部类创建多线程有两种方式，就和创建一个线程是一样的，一种是继承Thread一种是实现 Runnable接口。就很简单

https://blog.csdn.net/chengqiuming/article/details/91352913

第一种：
new Thread(){
public void run(){
//你想做的事情
};
}.start();

第二种：
new Thread(new Runnable() {
public void run() {
//你想做的事情
};
}) {
}.start();

　　注意：

匿名内部类必须继承一个父类，或实现一个接口，但最多只能继承一个父类，或实现一个接口。
由于匿名内部类不能是抽象类，所以匿名内部类必须实现它的抽象父类或接口里包含的所有抽象方法
匿名内部类不能定义构造器。由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以初始化块，可以通过初始化块来完成构造器需要完成的工作。
在Java 8之前，Java要求被局部内部类、匿名内部类访问的局部变量必须使用final修饰，从Java 8开始这个限制取消了，Java 8更加智能：如果局部变量被匿名内部类访问，那么该局部变量相对于自动使用了final修饰。
·匿名内部类不能定义任何静态成员、方法和类。、
·只能创建匿名内部类的一个实例。
·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
我们知道在一个类里如果有内部类，则编译是会产生多个class文件，一个类class 一个是内部类class（如果有多个内部类就产生多个），匿名内部类也是如此。只是匿名内部类没有类名，系统会给我们自动赋予名字。MyClass$1.class