Java 内部类（成员内部类、静态内部类、局部内部类、匿名内部类）

概念

如果一个类定义在另一个类的内部，这个类就是内部类，当一个类的内部，包含一个完整的事物，且这个事物没有必要单独设计，就可以把这个事物设计成内部类。

内部类的四种形式

成员内部类

就是类中的一个普通成员

Outer.Inner in = new Outer().new Inner(); // 先把外部类new出来才能new内部类

public class Outer {//外部类
    private int age = 99;
    public static String a;
    public class Inner{//内部类
        private String name;
        private int age = 88;
        public static String school;//jdk 16才开始支持定义静态
       public void test(){
           System.out.println(age);//访问当前内部类所在的外部类成员
           System.out.println(a);

           int age = 66;
           System.out.println(age);
           System.out.println(this.age);//访问当前内部类所在的外部类成员
           System.out.println(Outer.this.age);//通过外部类.this 拿取外部类对象变量信息

       }
        public String getName() {
            return name;
        }

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

静态内部类

Outer.Inner in = new Outer.Inner();

public class Outer {
    private int age;
    public static String school;
    public static class Inner{
        // 静态内部类
        private String name;
        public static int a;
        public void test(){
            System.out.println(school);//可以直接访问外部类的静态成员
            //不能直接访问外部类的实例对象，System.out.println(age);

        }

        public String getName() {
            return name;
        }

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

有static修饰 的内部类，属于外部类自己独有

内部类可以访问外部类的静态成员变量可以访问，但不能访问实例成员

局部内部类

局部内部类定义在方法中，代码块中，构造器等执行器中

public class OuterClass {  
    public void someMethod() {  
        final int outerVariable = 10; // 可以被局部内部类访问的外部变量  
  
        class LocalInnerClass {  
            void print() {  
                System.out.println("Local inner class accessing outer variable: " + outerVariable);  
            }  
        }  
  
        LocalInnerClass localInner = new LocalInnerClass();  
        localInner.print(); // 输出：Local inner class accessing outer variable: 10  
    }  
  
    public static void main(String[] args) {  
        OuterClass outer = new OuterClass();  
        outer.someMethod(); // 调用包含局部内部类定义的方法  
    }  
}

匿名内部类（重点）

使用时需被动去用，核心是简化代码，就是一种特殊的局部内部类，所谓匿名就是程序员不需要为这个类声明名字

public class Test {
    public static void main(String[] args) {
        // 1.把这个匿名内部类编译成一个子类，然后立即创建一个子类对象出来。
        Animal a = new Animal(){
            public void cry(){
                System.out.println("喵喵喵~~");
            }
        };
        a.cry();
    }
}

abstract class Animal{
    public abstract void cry();

匿名内部类在开发中应用场景，通常作为一个参数传输给方法

匿名内部类的书写格式

new 类或接口（参数值）{
类体}

 Animal a = new Animal(){//new对象
            public void cry(){//重写方法
                System.out.println("喵喵喵~~");
            }
        };
        a.cry();
    }
}



Swimming A =  new Swimming(){//new接口
            @Override
            public void swim() {
                System.out.println("狗游泳不错");

            }
        };
       go(A);
interface Swimming{
    void swim();
}

设计一个方法，可以接收Swimming接口的一切实现类对象进来参加游泳比赛
go(new Swimming(){
            @Override
            public void swim() {
                System.out.println("狗游泳不错");

            }
        });


public static  void go(Swimming s){//声明一个对象s获取接口所有方法
    System.out.println("开始————————————————");
    s.swim();
}
}

匿名内部类的特点

匿名内部类本质是一个子类，并会立即创建出一个子类对象