Java学习笔记——匿名内部类

匿名内部类

1.定义

• 是一种特殊的局部内部类

• 所谓匿名：指的是程序员不需要为这个类声明名字，默认有个隐藏的名字

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

• 作用：用于更方便的创建一个子类对象

• 代码：

  new 类或接口（参数值...）{
      类体（一般是方法重写）
  }
  

  这里的“类”、“接口”必须是已经存在的类或者接口

  示例：

  new Animal(){
  	@Override
  	public void eat(){
  	
  	}
  }
  

​ 具体示例讲解：

​ 在这里定义一个Animal类和类方法eat，由于不同的Animal吃不同的东西，因此Animal类和eat方法都定义为抽象类和抽象方法

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

​ 正常的情况下要定义一个Dog子类，对eat方法进行重写，代码如下：

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.eat();
    }
}

class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

​ 但是，匿名内部类则不需要构建一个子类，就能更方便的构造子类对象。由于抽象类不能new，则可以直接在new抽象类的时候重写eat方法，如下代码：

public class Test {
    public static void main(String[] args) {
        Animal dog = new Animal() {
            @Override
            public void eat() {
                System.out.println("狗吃骨头");
            }
        };
        dog.eat();
    }
}

//class Dog extends Animal{
//    @Override
//    public void eat() {
//        System.out.println("狗吃骨头");
//    }
//}

​ 匿名内部类是有名字的，可以通过查询编译的结果（out文件）看到为：外部类名$编号.class

​ 通过对该文件进行反编译，再次验证匿名内部类是一个子类：

2.使用场景

调用别人提供的方法实现需求时，这个方法正好可以让我们传输一个匿名内部类对象给其使用

2.1 登录窗口登录

需求：创建一个登录窗口，登录窗口中包含一个登录按钮

在代码中地22行java要求必须给按钮添加一个点击事件监听器对象，这样就可以监听用户事件，做出反应

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Test2 {
    public static void main(String[] args) {
        //需求：创建一个登录窗口，登录窗口中包含一个登录按钮
        JFrame win = new JFrame("登录窗口");
        win.setSize(300, 200);
        win.setLocationRelativeTo(null);//居中显示
        win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //创建一个面板，把按钮添加到面板中
        JPanel panel = new JPanel();
        win.add(panel);

        //创建一个按钮
        JButton button = new JButton("登录");
        panel.add(button);

        //java要求必须给按钮添加一个点击事件监听器对象，这样就可以监听用户事件，做出反应
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("登录成功");
            }
        });
        win.setVisible(true);
    }
}

​ 查看**addActionListener()**的函数定义，该函数传入参数是一个对象，再接着查看对象的定义，该对象是一个接口，也就是说可以写一个对象实现该接口，从而可以使用匿名内部类

​ 该代码运行结果

2.2 使用comparator接口的匿名内部函数类实现对数组进行排序

场景：对学生按照年龄进行升序排序

准备：先创建一个学生类，包含姓名、年龄、身高这三个属性

package com.fqw.anonymousclass;

public class Student {
    //姓名、年龄、身高
    private String name;
    private int age;
    private double height;
    public Student() {}
    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }
}

测试类：在测试中需要调用已经写好的API Arrays.sort()来对学生的年龄进行排序

Arrays.sort()的声明：
public static <T> void sort(T[] a, Comparator<T> c)
第一个参数是数组
第二个参数给sort声明一个比较器对象（即排序规则）,具体的排序规则看实现类代码

import java.util.Arrays;
import java.util.Comparator;

public class Test3 {
    public static void main(String[] args) {
        Student[] students=new Student[6];
        students[0]=new Student("张三", 18, 1.75);
        students[1]=new Student("李四", 23, 1.80);
        students[2]=new Student("王五", 20, 1.65);
        students[3]=new Student("赵六", 17, 1.70);
        students[4]=new Student("钱七", 22, 1.65);
        students[5]=new Student("孙八", 16, 1.75);
        //输出排序前的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }

        //调用API学生数组进行排序
        // public static <T> void sort(T[] a, Comparator<T> c)
        // 第一个参数是数组
        // 第二个参数给sort声明一个比较器对象（即排序规则）

        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2)
            {
                //指定排序规则
                //如果左边大于右边则返回正整数
                //如果左边小于右边则返回负整数
                //if (o1.getAge()>o2.getAge()) {
                //      return 1;
                //}else if(o1.getAge()<o2.getAge()){
                //    return -1;
                //}
                //可以简化下面的代码

                return o1.getAge()-o2.getAge();//升序
                //return o2.getAge()>o1.getAge()降序
            }
        });
        System.out.println("=======================================");
        //输出排序后的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }

    }

}

可以查看Comparator的声明，其为一个接口，因此需要匿名内部类来实现该接口

运行结果：

Tips:开发中并不是主动去写匿名内部类，而是函数方法需要我们写才写，是被动地写