Java 内部类

1. 内部类的概述

        内部类是类中的五大成分之一(成员变量、方法、构造器、内部类、代码块)，如果一个类定义在另一个类的内部，这个类就是内部类，类中有的内部类中也都能有

2. 成员内部类

        (1) 成员内部类就是类中的一个普通成员，类似普通的成员变量、成员方法；

        (2) 格式：

                public class 类名{

                        //成员内部类

                        public class 内部类名{

                        }

                }                

        (3)  JDK16之前，成员内部类中不能定义静态成员，JDK16开始就可以定义静态成员了

        (4)  创建对象的格式： 外部类名.内部类名 对象名 = new 外部类(...).new 内部类(...)

        (5) 成员内部类中访问其他成员的特点：

                ① 成员内部类的实例方法中，可以直接访问外部类的实例成员和静态成员

                ② 可以在成员内部类的实例方法中，拿到当前外部类对象，格式：外部类名.this

public class Outer {
    private int x = 1;
    private static String y;


    //成员内部类
    public class Inner {
        //内部类成员变量
        private String inner_name;
        //内部类静态成员变量
        private static String sex;//JDK16开始才支持定义静态成员
        private int x = 2;

        //内部类成员方法
        public void print() {
            System.out.println(x);
            System.out.println(y);

            //重名访问
            int x = 3;
            System.out.println(x);//3
            System.out.println(this.x);//2
            System.out.println(Outer.this.x);//1
        }

        public String getInner_name() {
            return inner_name;
        }

        public void setInner_name(String inner_name) {
            this.inner_name = inner_name;
        }
    }
}


public class Test {

    public static void main(String[] args) {
        //访问成员内部类(先外部.内部)
        Outer.Inner inner = new Outer().new Inner();
        inner.setInner_name("卡莎");
    }

}

3. 静态内部类

        (1) 静态内部类就是用static修饰的内部类，属于外部类自己持有

        (2) 格式：

                public class 类名{

                        //静态内部类

                        public static class 内部类名{

                        }

                }

        (3) 创建对象格式： 外部类名.内部类名 对象名 = new 外部类.内部类(...)

        (4) 静态内部类中访问外部类成员的特点：可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员(静态只能访问静态)     

public class Outer {
    private int age;
    public static String sex;

    //静态内部类
    public static class Inner{
        //成员变量
        private  String name;
        private  static int a;


        //成员方法
        public void print(){
            // System.out.println(age);
            System.out.println(sex);
        }

        public String getName() {
            return name;
        }

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


public class Test {
    public static void main(String[] args) {

        //访问静态内部类
        Outer.Inner inner = new Outer.Inner();
        inner.setName("泰坦");
    }
}

4. 局部内部类

        (1) 局部内部类就是定义在方法中、代码块中、构造器等执行体中的类

         没啥大用，看看就行

public class Test {
    public static void main(String[] args) {

        //访问静态内部类
        Outer.Inner inner = new Outer.Inner();
        inner.setName("泰坦");
    }

    //方法
    public void show(){
        //局部内部类
        class A{}

        abstract class B{

        }

        interface C{
            
        }
    }
}

5. 匿名内部类

        (1) 匿名内部类就是一种特殊的局部内部类；所谓匿名：指的是程序员不需要为这个类声明名字；一般不会主动去用匿名内部类，调一些API时需要用才使用

        (2) 格式：  new 类或接口(参数...){

                                类体(一般是方法重写)

                           }

public class Test {
    public static void main(String[] args) {
        //匿名内部类
//        Animal a = new Dog();
//        a.eat();
        //匿名内部类：把这个内部类编译成一个子类，然后会为创建一个子类对象出来
        Animal a = new Animal() {
            @Override
            public void eat() {
                System.out.println("狗吃狗粮");
            }
        };
        a.eat();//狗吃狗粮
    }
}

abstract class Animal {
    public abstract void eat();
}

        (3) 特点：匿名内部类本质就是一个子类，并且会立即创建一个子类对象。

        (4) 作用：更方便的创建一个子类对象   

        (5) 匿名内部类在开发中的使用场景:通常作为一个参数传输给方法

public class Test2 {
    public static void main(String[] args) {
        //匿名内部类的常见使用场景
        /*Running r1 = new Running(){
            @Override
            public void run() {
                System.out.println("兔子跑到贼快");
            }
        };
        go(r1);
        */

        //通常作为一个参数传输给方法
        go(new Running(){
            @Override
            public void run() {
                System.out.println("兔子跑到贼快");
            }
        });

    }

    //设计一个方法，接收Running接口的一切实现类对象
    public static void go(Running running) {
        System.out.println("跑步比赛开始");
        running.run();
    }
}

//跑 接口
interface Running{
    void run();
}