Java 内部类

内部类是定义在其他类内部的类，内部类所在的类称为宿主类。

通过内部类的定义，可以把一些相关的类放在一起。

由于内部类只能被他的宿主类使用，所以通过内部类的使用可以很好的控制类的可见性。

内部类分为两大类：静态内部类和非静态内部类。

非静态内部类可以调用宿主类的所有变量和方法。

静态内部类是用 static 修饰的，静态内部类不能直接访问其宿主类中非静态的成员，必须通过对象来访问，但是可以直接访问宿主类中静态的成员。

对于宿主类访问内部类的成员变量，静态内部类的静态变量可以直接用 “类名.变量名” 来调用，对于静态内部类的非静态变量则要生成他的对象，利用对象来访问。非静态内部类中不包含静态变量，所以必须用非静态内部类的对象来访问。

多少个类就会生成多少个 class 文件，例如：Tiger 类编译会生成三个 .class 文件，Tiger.class   Tiger$Inside.class   Tiger$Run.class

public class Tiger {
    String name = "tiger";
    static int age = 15;
    
    void testRun() {
        // 宿主类通过对象访问非静态内部类
        Run r = new Run();
        // 宿主类通过对象访问静态内部类中非静态成员
        Inside in = new Inside();
        r.run();
        in.eat();
        // 宿主类可以直接用"类名.变量名"来调用静态内部类的静态变量
        System.out.println(Inside.food);
    }
    
    void breath() {
        System.out.println("老虎用肺呼吸");
    }
    
    static void sleep() {
        System.out.println("sleeping");
    }
    // 非静态内部类
    class Run {
        void run() {
            // 非静态内部类可以调用宿主类中的变量和方法
            System.out.println(name);
            System.out.println(age);
            breath();
            sleep();
            System.out.println("running");
        }
    }
    // 静态内部类
    static class Inside {
        static String food = "beef";
        void eat() {
            // 静态内部类必须通过对象来调用宿主类的非静态的变量和方法
            Tiger t = new Tiger();
            System.out.println(t.name);
            t.breath();
            // 静态内部类可以调用宿主类中静态的变量和方法
            System.out.println(age);
            sleep();
            System.out.println("running");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Tiger tiger = new Tiger();
        tiger.testRun();
    }
} 

内部类的对象的创建对于静态内部类和非静态内部类也不相同。

public class Test {
    public static void main(String[] args) {
        Tiger tiger = new Tiger();
//        tiger.testRun();
        
        // 创建非静态内部类对象
        Tiger.Run t1 = new Tiger().new Run();
        // 创建静态内部类对象
        Tiger.Inside t2 = new Tiger.Inside();
        
        t1.run();
        t2.eat();
    }
}

 局部内部类

内部类不仅可以在类中定义，也可以在方法中定义，当定义在方法中时，叫做局部内部类。

public class Test {
    void in() {
        class InTest {
            // 构造方法
            public InTest() {
                System.out.println("局部内部类测试");
            }
        }
        // 调用构造方法
        new InTest();
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        test.in();
    }
}

匿名内部类

匿名内部类就是没有类名的内部类。匿名内部类省去了类的名字，直接构造对象，利用它可以很方便地在需要的时候构造一些只是当前需要的对象。

public class Test {    
    class Study
    {
        int n;
        // 构造方法
        public Study(int i) {
            n=i;
        }
    }
    
    Study getStudy() {
        return new Study(5) {
            int n = 5;
        };
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        System.out.println(test.getStudy().n);
    }
}