内部类

把类定义在另一个类的内部，该类就被称为内部类。
内部类的作用：

1. 内部类可以很好的实现隐藏。一般的非内部类，是不允许有 private 与protected权限的，但内部类可以
2. 内部类拥有外围类的所有元素的访问权限
3. 可是实现多重继承，当外部类继承了一个父类，内部类可以再次继承一个父类，一定程度上弥补了java单继承的缺点
4. 可以避免修改接口而实现同一个类中两种同名方法的调用。

成员内部类

成员内部类等同于成员变量
特点：

1. 成员内部类中不能有静态属性声明
2. 成员内部类可以访问外部类的所有属性，包括静态属性
3. 编译后的类名为 外部类类名$内部类类名

如：

public class _01_OuterClass {
	private static String s1 = "A";
    private String s2 = "B";

    //private public protected都可以使用
    //编译后的类名为 外部类类名$内部类类名
    //_01_OuterClass$InnerClass
    class InnerClss{
        //不能有静态声明
        /*static int x = 2;
        public static m1(){

        }*/

        //可以访问外部类的所有属性
        public void m2(){
            System.out.println(s1);
            System.out.println(s2);
        }

    }
    public static void main(String[] args) {

        //创建外部类对象
        _01_OuterClass outerClass = new _01_OuterClass();
        //通过外部类对象去创建成员内部类的对象
        InnerClss innerClss = outerClass.new InnerClss();
        innerClss.m2();
    }
}

静态内部类

静态内部类等同于静态变量
特点：

1. 静态内部类中，不能直接访问成员数据，需要有对象才行
2. . 静态内部类中可以声明所有东西
3. 编译后的类名为 外部类类名$内部类类名

如：

public class _02_OuterClass {
    private static String s1 = "A";
    private String s2 = "B";

    static int i = 2;

    private static class InnerClass {
        public static void m1() {
            System.out.println(s1);
            //不能直接访问成员属性
            //System.out.println(s2);   报错

            _02_OuterClass outerClass = new _02_OuterClass();
            System.out.println(outerClass.s2);
        }

        public void m2() {
            System.out.println(s1);
            //不能直接访问成员属性
            //静态内部类中的成员方法也不能访问成员变量
            //System.out.println(s2);   报错
        }
    }

    public static void main(String[] args) {
        //使用     外部类.内部类.静态方法调用
        InnerClass.m1();

        //访问当前类的静态属性的时候，类名可以省略
        InnerClass.m1();

        //创建内部类对象
        InnerClass innerClass = new InnerClass();
        InnerClass innerClass1 = new InnerClass();

    }
}

局部内部类

局部内部类等同于局部变量
注意事项：
java1.8以前局部内部类在访问外部方法中的局部变量的时候需要加final修饰，java1.8以后就不需要再final添加了
特点：

1. 局部内部类中，不能有静态声明
2. 如果是成员方法中的局部内部类，可以访问外部类中的所有属性
3. 如果是静态方法中的内部类，不可以直接访问外部类的成员属性，需要对象来调用
4. 编译后的类名为 外部类类名$内部类类名

如：

public class _03_OuterClass {
    private static String s1 = "A";
    private String s2 = "B";

    public static void main(String[] args) {
        //调用成员方法中的内部类
        _03_OuterClass outerClass = new _03_OuterClass();
        outerClass.m1();
        //调用静态方法中的内部类
        m2();
    }
    //成员方法
    //成员方法中的内部类，可以访问外部类中的所有属性
    public void m1() {
        int i = 10;
        //局部内部类不能使用权限修饰符，并且不可以有静态声明
        class InnerClass {
            /*public static void m3(){}*/
            public void m4() {
                System.out.println(s1);
                System.out.println(s2);
                //i默认加final，i的值不能再次更改
                System.out.println(i);
            }
        }
        //局部内部类只能在当前方法中调用
        InnerClass innerClass = new InnerClass();
        innerClass.m4();
    }

    public static void m2() {
        int i = 2;
        //局部内部类不能使用权限修饰符，并且不可以有静态声明
        class InnerClass {
            //public static void m3();
            public void m4() {
                System.out.println(s1);
                //静态方法中的内部类，不能直接访问成员变量，需要创建对象调用
                _03_OuterClass outerClass = new _03_OuterClass();
                System.out.println(outerClass.s2);
                //i默认加final，i的值不能再次更改
                System.out.println(i);
            }
        }
    }
}

匿名内部类

1. 如果方法的形参定义的是一个接口，就需要传递实现接口的类对象，或者传递一个匿名的实现类。
2. 这个类没有名字，不能复用。
3. 没有名字的类，就没有办法创建对象，但是在传入匿名内部类的时候，会自动创建对象，并且只创建依次
4. 命名方式：第一个默认叫$1，第二个默认叫$2，依次类推。完整名字再为外部类类名$1，依次类推。

如：

public class _04_OuterClass {
    public static void main(String[] args) {
        ICustomerService cs = new CustomerServiceImpl();
        m1(cs);
        m1(new ICustomerService() {
            @Override
            public void logout() {
                System.out.println("已退出登录" + this);
            }
        });

        m2(new A() {
            // 等于是创建了一个A的子类,并覆写了m3方法
            public void m3() {
                System.out.println("sssssss");
                super.m3();
            }
        });
    }

    public static void m1(ICustomerService cs) {
        cs.logout();
    }

    public static void m2(A a) {
        a.m3();
    }
}

interface ICustomerService {
    public void logout();
}


class CustomerServiceImpl implements ICustomerService {

    @Override
    public void logout() {
        System.out.println("已退出登录");
    }
}

class A {
    public void m3() {
        System.out.println("===");
    }
}