Java内部类

内部类可以分为三种，成员内部类、静态内部类、局部内部类

###成员内部类
成员内部类是外部类的一个成员，成员内部类可以调用外部类的所有成员。

举例
内部类的test方法，可以调用访问外部类的所有成员，包括成员变量、静态变量、成员方法、静态方法。**因为成员内部类是外部类的一个成员，可以认为是把一些成员变量和成员方法提出来整合为一个类。**内部类调用外部类的成员变量和方法，其实就是成员间互相访问，当然是可以的；内部类调用外部类的静态变量和静态方法也是可以的，因为静态变量和方法是属于类，属于所有成员。

public class OuterClass {
    private int i = 0;
    private static int j = 0;
    
    public class InnerClass{
        int k = 0;
        // 内部类可以访问外部类的成员变量和静态变量
        public void test(){
            i = 100;
            j = 100;
            outerMethod1();
            outerMethod2();
        }
    }

    public void outerMethod1() {
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.k);
        innerClass.test();
    }

    public static void outerMethod2() {
    }
}

####成员内部类的变量和方法不能是static
成员内部类是外部类的成员，和成员方法、成员变量同属一类。所以变量和方法不能是static，因为static属于类。比如普通方法里面定义一个static变量，也是不允许的。

还是刚才的代码，我把方法清空（防止方法内部的语句导致出错），可以看到内部类的static成员和方法都表示出错。

####外部类如何访问内部类
在外部类的非static方法中，可以new一个内部类的对象，然后访问。

综上：成员内部类是外部类的成员，是外部类的变量的一个综合体

###静态内部类
作用只是为了降低包的深度，方便类的使用。静态内部类不依赖于外部的类，只是为了方便管理类结构而定义。在创建静态内部类的时候，不需要外部类对象的引用。

举例
我们定义一个外部类OuterClass2和静态内部类InnerClass，可以看到内部类的成员方法（test方法）可以访问外部类的静态变量和静态方法；外部类的成员方法（outerMethod1方法）可以访问内部类的静态变量和静态方法。外部类在这里相当于包，外部类和静态内部类没有从属关系。静态内部类访问外部类静态成员可以不加外部类名，因为只有一个外部类；外部类访问静态内部类静态成员需要见静态内部类名，因为一个外部类可以有多个静态内部类。

public class OuterClass2 {
    private int i = 0;
    private static int j = 0;

    public static class InnerClass{
        static int k = 0;
		// 内部类可以访问外部类的静态变量和静态方法
        public void test(){
            j = 100;
            outerMethod2();
        }
    }

    public void outerMethod1() {
        InnerClass.k = 0;
    }

    public static void outerMethod2() {
        InnerClass.k = 0;
    }
}

####外部类外访问静态内部类

public class Test {
    public static void main(String[] args) {
        OuterClass2 outerClass2 = new OuterClass2();
        OuterClass2.InnerClass innerClass = new OuterClass2.InnerClass();
    }
}

main第一行可以看到，外部类是一个类；第二行，外部类又相当于一个包。

这就是静态内部类的设计理念，把外部类当做一个包来用，降低包的深度。

####静态内部类可以是private，只允许其外部类访问

静态内部类主要是为了给外部类访问，可以设置为private限制为只对外部类访问；也可以设置为public或者default。而普通的包类就不能是private。

###局部内部类
####定义
在代码块或者方法体内定义的类叫做局部内部类，其作用范围只限于定义的代码块或者方法体中，对外部类不可见。
布局类不能加访问修饰符，因为它不是类的成员

####局部内部类可以访问外部类的成员
如果外部类没有同名的变量，如代码中的j可以直接访问。
如果外部类有同名的变量，如代码test中的i访问的是方法中的i；可以通过外部类名.this.变量名来制定

public class OuterClass3 {
    private int i = 0;
    private int j = 0;

    public void test() {
        int i = 0;
        class InnerClass {
            public InnerClass() {
                
            }
            public void innerTest() {
                System.out.println(i);
                System.out.println(OuterClass3.this.i);

                System.out.println(j);
            }
        }
    }
}

####匿名内部类：特殊的局部内部类

目的
匿名内部类目的是提高了代码的简洁性。有时候我们只需要一次性使用对象，并不需要类的名字和该类创建出的对象名。

特点

1. 匿名内部类中我们只能继承一个类或者实现一个接口。
2. 匿名内部类中是不能自定义构造函数的。
3. 匿名内部类中不能存在任何的静态变量和静态方法。
4. 匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

用法

new 类名（参数列表）|接口（）{  
     //匿名内部类的类体部分  
    }

举例
下面我用三种方式实现了线程并开启

1. 第一种方式代码量最大，A实现Runnable，然后new一个A，放入到Thread中
2. 第二种方式已经实现了匿名内部类，但是new出来的对象有名字，就是b。这样b可以重复利用
3. 第三种方式实现匿名内部类并new了一个匿名对象放入到Thread中，该对象就只能一次性使用。因为后面的程序拿不到该对象的引用。

public class OuterClass4 {
    private int i = 0;

    public static void main(String[] args) {
        // 第一种方式
        A a = new A();
        Thread threadA = new Thread(a);
        threadA.start();

        // 第二种方式
        Runnable b = new Runnable() {
            @Override
            public void run() {

            }
        };
        Thread threadB = new Thread(b);
        threadB.start();

        // 答应b的类名
        System.out.println(b.getClass());

        // 第三种方式
        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {

            }
        });
        threadC.start();
    }
}

class A implements Runnable {
    @Override
    public void run() {

    }
}