📂 Java 面向对象编程进阶 - 内部类 - 《Java》

静态内部类
成员内部类
局部内部类
匿名内部类

内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿主）。

public class People{
    // 内部类
    public class Heart{
    }
}

内部类的使用场景、作用：

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计。
内部类通常可以方便访问外部类的成员，包括私有的成员。
内部类提供了更好的封装性，内部类本身就可以用 private protectecd 等修饰，封装性可以做更多控制。

内部类的分类：

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

静态内部类
有 static 修饰，属于外部类本身。它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已。
```
public class Outer{
  // 静态成员内部类
  public static class Inner{
  }
}
```
静态内部类创建对象的格式：外部类名.内部类名对象名 = new 外部类名.内部类构造器;
```
Outer.Inner in = new Outer.Inner();
```
静态内部类的使用场景、特点、访问总结：
如果一个类中包含了一个完整的成分，如汽车类中的发动机类。
特点、使用与普通类是一样的，类有的成分它都有，只是位置在别人里面而已。
可以直接访问外部类的静态成员，不能直接访问外部类的实例成员。
开发中实际上用的还是比较少。

成员内部类
无 static 修饰，属于外部类的对象。
Java 16 之前，成员内部类中不能定义静态成员，Java 16 开始也可以定义静态成员了。

成员内部类创建对象的格式：格式：外部类名.内部类名对象名 = new 外部类构造器.new 内部类构造器();

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

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

class People {
    private int heartbeat = 150;

    public class Heart {
        private int heartbeat = 110;

        public void show() {
            int heartbeat = 78;
            System.out.println(heartbeat); // 78
            System.out.println(this.heartbeat); // 110
            System.out.println(People.this.heartbeat); // 150
        }
    }
}


public class Test {
    public static void main(String[] args) {
        People.Heart heart = new People().new Heart();
        heart.show();
    }
}

局部内部类

鸡肋语法

局部内部类放在方法、代码块、构造器等执行体中。
局部内部类的类文件名为：外部类$N内部类.class。
匿名内部类
本质上是一个没有名字的局部内部类，定义在方法中、代码块中、等。
作用：方便创建子类对象，最终目的为了简化代码编写。 ```java abstract class Animal { public abstract void run(); }

class Cat extends Animal { @Override public void run() { System.out.println(“猫在跑”); } }

// 使用匿名内部类

Animal a = new Animal() { @Override public void run() { System.out.println(“跑”); } };

a. run();

特点总结：

- 匿名内部类是一个没有名字的内部类。
- 匿名内部类写出来就会产生一个匿名内部类的对象。
- 匿名内部类的对象类型相当于是当前 new 的那个的类型的子类类型。
```java
public class Test {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生快乐的自由泳🏊‍");
            }
        };
        go(s);

        System.out.println("--------------");

        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师泳🏊的贼快~~~~~");
            }
        };
        go(s1);

        System.out.println("--------------");

        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("运动员🏊的贼快啊~~~~~");
            }
        });


    }

    /**
       学生 老师 运动员可以一起参加游泳比赛
     */
    public static void go(Swimming s){
        System.out.println("开始。。。");
        s.swim();
        System.out.println("结束。。。");
    }
}


interface Swimming{
    void swim();
}

public static void main(String[] args) {
    // 1、创建窗口
    JFrame win = new JFrame("登录界面");
    JPanel panel = new JPanel();
    win.add(panel);

    // 2、创建一个按钮对象
    JButton btn = new JButton("登录");

    // 注意：讲解匿名内部类的使用
    btn.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            JOptionPane.showMessageDialog(win, "Warning");
        }
    });

    // Lambda 表达式 简化代码
    // btn.addActionListener( e ->  JOptionPane.showMessageDialog(win, "Error") );

    // 3、把按钮对象添加到桌布上展示
    panel.add(btn);

    // 4、展示窗口
    win.setSize(400, 300);
    win.setLocationRelativeTo(null);
    win.setVisible(true);
}

内部类

静态内部类

成员内部类

局部内部类

匿名内部类