内部类

成员内部类

作为其外部类成员的内部类，称为成员内部类。除另有说明外，“内部类”通常是指成员内部类。

与实例的方法和变量一样，内部类与其外围类的实例相关联，并可直接访问该外围类对象的方法和字段。此外，由于内部类与实例相关联，因此不能在非静态内部类中定义任何静态成员（静态类可以）。

public class OuterClass {
    private int outerId = 10;
    private String s = "AA";
    public void out(){
        System.out.println("这是外部类的方法");
    }
    //静态内部类
    static class Inner2{
        public static void method(){
            System.out.println("静态内部类的方法");
        }
    }
    //非静态的内部类
    class InnerClass{
        private int innerId = 11;
        private String s = "BB";
        public void in(){
            System.out.println("这是内部类的方法");
        }

        public void get(){
            in();
            out(); //OuterClass.this.eat()
            //内部类可以获取外部类的私有属性
            System.out.println(outerId);//10
            System.out.println(innerId);//11
            //同名优先获取内部类的属性
            System.out.println(s);//BB
            //获取外部类的同名属性
            System.out.println(OuterClass.this.s);//AA
        }
    }

    public static void main(String[] args) {
        //实例化成员内部类
        OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
        //调用静态内部类的方法
        OuterClass.Inner2.method();

        innerClass.get();

    }
}

总结：

一方面：成员内部类作为外部类成员：可以
- 调用外部类结构
- 可以被static修饰
- 可以被四种不同的权限修饰
另一方面，作为一个类：
- 类内可以定义属性、方法、构造器等
- 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
- 可以被abstarct修饰

局部内部类

写在方法内、代码块内、构造器内的类

class Person{
    public void method(){
        //局部内部类
        class AA{

        }
    }

    {
        //局部内部类
        class BB{

        }
    }

    public Person(){
        //局部内部类
        class CC{

        }
    }
}

public class InnerClassTest1 {
    //返回一个实现了Comparable接口的类的对象
    public Comparable getComparable(){
        //创建一个实现了Comparable接口的类
        class MyComparable implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        return new MyComparable();
    }
}

匿名内部类

匿名类概念：

匿名类可以使你的代码更加简洁 (JDK8之后Lambda更简洁)。
你可以定义一个类的同时对其进行实例化。
它与局部类很相似，不同的是它没有类名，如果某个局部类你只需要使用一次，就可以使用匿名类代替局部类。
匿名类是表达式，而非常规的类

匿名类的使用场景：

一个局部类只需要使用一次的时候
由于匿名类没有类名，那么除了定义它的地方，其他地方无法调用，所以匿名类也可以叫匿名内部类

public class HelloWorldAnonymousClasses {

    /**
     * 包含两个方法的HelloWorld接口
     */
    interface HelloWorld {
        public void greet();
        public void greetSomeone(String someone);
    }

    public void sayHello() {

        // 1、局部类EnglishGreeting实现了HelloWorld接口
        class EnglishGreeting implements HelloWorld {
            String name = "world";
            public void greet() {
                greetSomeone("world");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hello " + name);
            }
        }

        HelloWorld englishGreeting = new EnglishGreeting();

        // 2、匿名类实现HelloWorld接口
        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "tout le monde";
            public void greet() {
                greetSomeone("tout le monde");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Salut " + name);
            }
        };

        // 3、匿名类实现HelloWorld接口
        HelloWorld spanishGreeting = new HelloWorld() {
            String name = "mundo";
            public void greet() {
                greetSomeone("mundo");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hola, " + name);
            }
        };

        englishGreeting.greet();
        frenchGreeting.greetSomeone("Fred");
        spanishGreeting.greet();
    }

    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }
}