【Java面向对象】10 Java内部类 成员内部类、局部内部类、匿名内部类、静态内部类

内部类

内部类是定义在一个类中的类

• 使用场景
  • 内部类方法可以访问该类定义所在作用域中的数据，包括私有数据
  • 内部类可以对一个包的其他类隐藏
  • 当要定义一个回调函数又不想实现很多代码时，可以使用匿名内部类。

成员内部类

public class InnerClassDemo1 {
    private boolean flag;

    public void outerAction() {
        // 外部类可以使用OuterClass.InnerClass来引用内部类
        // 创建内部类实例可以使用outerObject.new InnerClass();
        InnerClassDemo1.InnerClass1 innerClass1 = this.new InnerClass1();
        innerClass1.action();
    }

    // 内部类可以私有，常规类只能default或者public
    private class InnerClass1 {
        // 内部类声明的所有静态域都必须是final的，不能有静态方法
        private static final String s = "a";

//        private InnerClassDemo1 outer;
//
//        public InnerClass1(InnerClassDemo1 outer) {
//            this.outer = outer;
//        }

        public void action() {
//            if (outer.flag) {
            // 可以访问外部类成员变量
            // 相当于编译器添加了outer.flag，并且在构造中定义了outer且赋值
            // 也可以使用OuterClass.this表示外部类引用
            InnerClassDemo1 outer = InnerClassDemo1.this;
            if (!flag) {
                System.out.println("action invoke");
            }
        }
    }

    public static void main(String[] args) {
        InnerClassDemo1 innerClassDemo1 = new InnerClassDemo1();
        InnerClass1 innerClass1 = innerClassDemo1.new InnerClass1();
        innerClass1.action();
    }
}

• 内部类对象由外部类对象构造
• 内部类可以访问外部类成员变量，私有成员也可以访问
• 内部类可以私有，常规类只能default或者public
• 表示外部类引用OuterClass.this
• 表示内部类引用OuterClass.InnerClass
• 创建内部类实例outerObject.new InnerClass()
• 内部类声明的所有静态域都必须是final的，不能有静态方法

局部内部类

public class InnerClassDemo2 {
    private boolean flag;

    public void a() {
        // 局部内部类不能使用public或者private，它的作用范围仅在这个方法内部
        class InnerClass2 {
            public void action() {
                if (flag) {
                    System.out.println("inner");
                }
            }
        }
    }
}

匿名内部类

• 基本格式

new SuperType(construction paramters) {
    inner class methods and data
}

• 代码

public class InnerClassDemo3 {
    public static void main(String[] args) {
        // 匿名内部类
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("run");
            }
        };

        // lambda表达式写法
        Runnable task2 = () -> System.out.println("run");
    }
}

• 双括号初始化

List<Integer> list = new ArrayList<>();
list.add(1);

// 匿名 
// 双括号初始化，利用内部类语法初始化数据
ArrayList<Integer> list2 = new ArrayList<Integer>() {{
    add(1);
}};

静态内部类

• 把一个类隐藏到另外一个类中，内部类也无需引用外部类对象，可以将内部类声明为static
• 一个方法同时返回最大值和最小值，如果不返回数组，那么就需要对象进行封装，那么就需要一个类封装属性做返回值，这个类只为当前外部类服务，也不需要访问外部类成员。

public class InnerClassDemo4 {

    static class InnerClass4 {
        private int min;
        private int max;

        public InnerClass4(int min, int max) {
            this.min = min;
            this.max = max;
        }

        public int getMin() {
            return min;
        }

        public void setMin(int min) {
            this.min = min;
        }

        public int getMax() {
            return max;
        }

        public void setMax(int max) {
            this.max = max;
        }

        @Override
        public String toString() {
            return "InnerClass4{" +
                    "min=" + min +
                    ", max=" + max +
                    '}';
        }
    }

    // 获取最大值和最小值
    public static InnerClass4 getMinMax(int[] arr) {
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int i : arr) {
            min = Math.min(min, i);
            max = Math.max(max, i);
        }
        return new InnerClass4(min, max);
    }

    public static void main(String[] args) {
        InnerClass4 minMax = InnerClassDemo4.getMinMax(new int[]{1, 2, 3, 4});
        System.out.println(minMax); // InnerClass4{min=1, max=4}
    }
}