内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为 内部类 ，类B则称为 外部类。 

内部类的声明理由：

当一个事物A的内部，有一部分需要一个完整的结构B进行描述，而这个内部结构B只为外部事物A提供服务，并不会在其他地方用到，那么整个内部的完整结构B最好使用内部类。

遵循 高内聚、低耦合 的面向对象开发原则。

举例： Thread类内部声明了State类，表示线程的生命周期。

　　    HashMap类中声明了Node类，表示封装的key和Value

分类：(参考变量的分类)

> 成员内部类：直接声明在外部类的里面

　　> 使用static修饰的： 静态的成员内部类

　　> 不使用static修饰的：非静态的成员内部类

> 局部内部类：声明在方法内、构造器内、代码块内的内部类

　　> 匿名的局部内部类

　　> 非匿名的局部内部类

class Person{ // 外部类
    // 静态的成员内部类
    static  class Dog{

    }

    // 非静态的成员内部类
    class Bird{

    }

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

        }
    }

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

        }
    }

    {
        // 局部内部类
        class InnerClass1{
            
        }
    }
}

成员内部类的理解

> 从类的角度看：

　　- 内部可以声明属性、方法、构造器、代码块、内部类等结构

　　- 此内部类可以声明父类，可以实现接口

　　- 可以使用final修饰

　　- 可以使用abstract修饰

> 从外部类的成员的角度看：

　　- 在内部可以调用外部类的结构。比如：属性、方法等

　　- 除了使用public、缺省权限修饰之外，还可以用private、protected修饰

　　- 可以使用static修饰

创建成员内部类的实例

public class OuterClassTest {
    public static void main(String[] args) {
        //1.创建Person的静态的成员内部类的实例
        Person.Dog dog = new Person.Dog();
        dog.eat();
        //2.创建Person的非静态的成员内部类的实例
//    Person.Bird bird = new Person.Bird();  错误写法
        Person p1 = new Person();
        Person.Bird bird = p1.new Bird();
        bird.eat();

    }
}

class Person{ // 外部类
    // 静态的成员内部类
    static  class Dog{
        public void eat(){
            System.out.println("吃骨头！");
        }
    }

    // 非静态的成员内部类
    class Bird{
        public void eat(){
            System.out.println("鸟吃虫！");
        }
    }
}

在成员内部类中调用外部类的结构

public class OuterClassTest {
    public static void main(String[] args) {
        //1.创建Person的静态的成员内部类的实例
        Person.Dog dog = new Person.Dog();
        dog.eat();
        //2.创建Person的非静态的成员内部类的实例
//    Person.Bird bird = new Person.Bird();  错误写法
        Person p1 = new Person();
        Person.Bird bird = p1.new Bird();
        bird.eat();
        bird.show("黄鹂");
        bird.show1();
    }
}

class Person{ // 外部类
    String name = "Tom";
    int age = 20;
    // 静态的成员内部类
    static  class Dog{
        public void eat(){
            System.out.println("吃骨头！");
        }
    }

    // 非静态的成员内部类
    class Bird{
        String name = "啄木鸟";
        public void eat(){
            System.out.println("鸟吃虫！");
        }
        public void show(String name){
            System.out.println("age = " + age);  // 20
            System.out.println("name = " +name);  // 黄鹂  show 方法的形参
            System.out.println("name = " + this.name);  // 啄木鸟 (谁调用这个方法就是谁)
            System.out.println("name = " + Person.this.name);  // Tom
        }
        public void show1 (){
            eat();  // 鸟吃虫！
            this.eat();  // 鸟吃虫！
            Person.this.eat();  // 人吃饭！
        }
    }
    public void eat(){
        System.out.println("人吃饭！");
    }
}

局部内部类的使用

public class OuterClassTest {
    // 说明：局部内部类的使用
    public void method1(){
        // 局部内部类
        class A{
            // 可以声明属性、方法等
        }
    }

    //开发中的场景
    public Comparable getInstance(){  //返回一个实现了Comparable的对象
        // 提供了实现Comparable接口的类
        // 方式1： 提供了接口的实现类的匿名对象
        class MyComparable implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        return  new MyComparable();
    }

    public Comparable getInstance1(){
        // 方式2：提供了接口的匿名实现类的对象
        Comparable c = new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
        return c;
    }

    public Comparable getInstance2(){
        // 方式3：提供了接口的匿名实现类的匿名对象
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }

}