JAVA内部类

JAVA内部类

在java的类中，不仅仅可以定义变量和方法，还可以定义类，定义在类中的类被叫做内部类

静态内部类

定义为静态的内部类被称作静态内部类

public class Out {


    private static int a;
    private int b;

    private int method(int c) {
        return c;
    }

    private static int method1(int c) {
        return c;
    }

    public static class Inner {
        
        int a = 1;
        static int b = 2;

        private String name;

        public inner(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
        
        public void run() {
            // 调用外部类静态变量，可以调用
            System.out.println(a);
            // 调用外部类成员变量，不可以调用
//            System.out.println(b);
            // 调用外部类成员方法,不可以调用
//            System.out.println(method(1));
            // 调用外部类的静态方法，不可以调用
            System.out.println(method1(1));
        }
    }
}

1. 静态内部类可以调用外部类的所有静态的变量和方法，包括private
2. 静态内部类和普通类一样，可以定义成员变量、静态变量、构造器成员方法
3. 如果其他类想要调用静态内部类需要使用 “外部类.静态内部类”的方式。例如：Out.Inner inner = new Out.Inner();
4. 在java的hashMap中就定义了一个静态内部类Entry。hashMap维护Entry用来存放元素，Entry对使用者是透明的，这种内部类和外部类依赖密切的可以使用静态内部类

成员内部类

定义在类中的非静态类就是成员内部类

public class Out1 {

    private static int a;
    private int b;

    private int method(int c) {
        return c;
    }

    private static int method1(int c) {
        return c;
    }

    public class inner {

        int a = 1;
        // 静态变量，不可以定义
//        static int b = 2;
        private String name;

        public inner(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void run() {
            // 调用外部类静态变量，可以调用
            System.out.println(a);
            // 调用外部类成员变量，可以调用
            System.out.println(b);
            // 调用外部类成员方法,可以调用
            System.out.println(method(1));
            // 调用外部类的静态方法，可以调用
            System.out.println(method1(1));
        }
    }
    
}

成员内部类不可以定义静态方法和静态变量，因为成员内部类本身是非静态的，类的初始化先初始化静态成员，如果允许成员内部类定义静态变量，会引发歧义

局部内部类

如果一个类只在某一个方法中使用可以考虑使用局部内部类

public class Out3 {
     
    int a;
    
    public void test(int b) {
        int c;
        class inner {
            public void run() {
                System.out.println(b);
            }
        }
    }
}

匿名内部类

匿名内部类指没有名的内部类，需要继承一个类或者实现一个接口，使用new生成一个对象的引用

public abstract class Bird {

    private String name;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract int fly();

}

class Test {
    public void test(Bird bird) {
        System.out.println(bird.getName() + " fly " + bird.fly() + "meter");
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.test(new Bird() {
            @Override
            public int fly() {
                return 999;
            }

            public String getName() {
                return "b";
            }
        });
    }
}

输出结果为：

b fly 999meter