文章目录

• • 内部类
  • • 局部内部类
    • 匿名内部类
    • • 匿名内部类介绍
      • 常见的使用形式
      • 开发中使用场景

内部类

局部内部类

局部内部类 （鸡肋语法，了解即可）

局部内部类, 在方法、代码块、构造器等执行体中创建一个类, 称为为局部内部类(但是我们一般都不会这样写)。

局部内部类的类文件名为： 外部类$N内部类.class。

基本演示代码:

package com.chenyq.d10_innerClass;

public class Test {
    public static void main(String[] args) {
        // 在方法中创建一个类
        class Inner {
            private String name;
            public static int age;

            public Inner() {}

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

            public String getName() {
                return name;
            }

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

        // 使用局部内部类
        Inner inr = new Inner("chenyq");
        Inner.age = 22;
        System.out.println(inr.getName());
        System.out.println(Inner.age);
    }
}

匿名内部类

匿名内部类介绍

匿名内部类:

本质上是一个没有名字的局部内部类，定义在方法中、代码块中、等。

作用：方便创建子类对象，最终目的为了简化代码编写。

匿名内部类格式:

new 类|抽象类名|或者接口名() {
  	重写方法;
};

匿名内部类演示代码:

Animal a = new Animal() {
  	public void run() {
    }
};

a. run();

特点总结：

匿名内部类是一个没有名字的内部类。

匿名内部类写出来就会产生一个匿名内部类的对象。

匿名内部类的对象类型相当于是当前new的那个的类型的子类类型。

匿名内部类用于方便创建子类对象, 不需要创建一个子类继承自父类

演示代码:

我们来看下面这样一个案例, 有一个抽象父类Animal, 我们根据父类得到一个子类Tiger有两种方式:

方式一: 定义一个子类Tiger继承自抽象父类Animal

package com.chenyq.d11_innerlass_anonymous;

public class Test {
    public static void main(String[] args) {
        Tiger tig = new Tiger();
        tig.run();
    }
}

/**
    定义Tiger子类
 */
class Tiger extends Animal {
    @Override
    public void run() {
        System.out.println("老虎是跑的");
    }
}

/**
    定义抽象父类
 */
abstract class Animal {
    public abstract void run();
}

方式二: 通过匿名内部类创建子类对象

package com.chenyq.d11_innerlass_anonymous;

public class Test {
    public static void main(String[] args) {
        Animal tig = new Animal() {
            @Override
            public void run() {
                System.out.println("老虎是跑的");
            }
        };
        tig.run();
    }
}

/**
    定义抽象父类
 */
abstract class Animal {
    public abstract void run();
}

总结:

1.匿名内部类的作用？

方便创建子类对象，最终目的为了简化代码编写。

2.匿名内部类的格式？

Animal a = new Animal() {
  	public void run() {
    }
};
a. run();

3.匿名内部类的特点？

匿名内部类是一个没有名字的内部类。

匿名内部类写出来就会产生一个匿名内部类的对象。

匿名内部类的对象类型相当于是当前new的那个的类型的子类类型。

常见的使用形式

匿名内部类在开发中的使用形式了解

例如: 某个学校需要让老师，学生一起参加游泳比赛

首先, 我们需要定义一个接口Swimming, 接口中有抽象方法swimming

其次, 定义一个方法goSwimming, 用于实现所有角色游泳

最后, 通过匿名内部类实现出来老师, 学生的角色, 再调用方法goSwimming将角色传递进去

演示代码:

基本使用

package com.chenyq.d11_innerlass_anonymous;

public class Test2 {
    public static void main(String[] args) {
        // 学生角色
        Swimming stu = new Swimming() {
            @Override
            public void swimming() {
                System.out.println("学生正在游泳");
            }
        };
        // 老师角色
        Swimming tec = new Swimming() {
            @Override
            public void swimming() {
                System.out.println("老师正在游泳");
            }
        };

        // 调用方法
        goSwimmming(stu);
        goSwimmming(tec);
    }

    // 定义一个方法, 用于实现角色游泳功能
    public static void goSwimmming(Swimming swim) {
        System.out.println("开始游泳");
        swim.swimming();
        System.out.println("结束游泳");
    }
}

/**
    定义一个接口
 */
interface Swimming {
    // 要求实现swimming方法
    void swimming();
}

代码简化:

上面我们通过匿名内部类分别创建了stu和tec两个角色后, 调用goSwimming方法

其实我们可以直接调用goSwimming方法, 在goSwimming传递参数时创建角色, 如下

public static void main(String[] args) {
    // 创建学生角色并传入到goSwimming方法中
    goSwimmming(new Swimming() {
        @Override
        public void swimming() {
            System.out.println("学生正在游泳");
        }
    });
    System.out.println("------------------");
    // 创建老师角色并传入到goSwimming方法中
    goSwimmming(new Swimming() {
        @Override
        public void swimming() {
            System.out.println("老师正在游泳");
        }
    });
}

使用总结:

匿名内部类可以作为方法的实际参数进行传输。

开发中使用场景

匿名内部类在开发中的真实使用场景演示: 通过GUI编程理解匿名内部类的真实使用场景

例如: 给如下按钮绑定点击事件

演示代码:

首先通过GUI编程, 创建一个窗口展示按钮(这个代码无需理解, 只是用来举例子)

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

    // 2.创建按钮
    JButton btn = new JButton("登录");

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

    // 4.设置窗口大小 窗口居中显示 展示窗口
    win.setSize(400, 300);
    win.setLocationRelativeTo(null);
    win.setVisible(true);
}

接下来监听按钮点击, 通过addActionListener方法

addActionListener方法要求传入一个参数, 参数要求是ActionListener接口类型的, 我们可以通过匿名内部类穿件ActionListener类型的对象

并重写actionPerformed方法, 在该方法中完成点击后的要实现的功能

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

    // 2.创建按钮
    JButton btn = new JButton("登录");

    // 监听按钮的点击:
    // 点击中要求传入一个ActionListener接口类型的对象
    // 我们通过匿名内部类直接创建一个ActionListener类型的对象
    btn.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            // 点击按钮弹框
            JOptionPane.showMessageDialog(win, "点击了按钮");
        }
    });

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

    // 4.设置窗口大小 窗口居中显示 展示窗口
    win.setSize(400, 300);
    win.setLocationRelativeTo(null);
    win.setVisible(true);
}

匿名内部类通过->新语法可以简化代码(了解, 后续有文章会专门讲解)

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(e -> JOptionPane.showMessageDialog(win, "点击了按钮"));
  
    // 3.把按钮添加到桌布上展示
    panel.add(btn);

    // 4.设置窗口大小 窗口居中显示 展示窗口
    win.setSize(400, 300);
    win.setLocationRelativeTo(null);
    win.setVisible(true);
}

使用总结:

开发中不一定是我们主动去定义匿名内部类的，而很多时候是别人需要我们写或者我们可以写的时候才会使用。

匿名内部类的代码可以实现代码进一步的简化