一、代码分析

共三个类。

1、Employee类

2、ArrayTools类

3、TestAnonymousInnerUse类

（一）Employee类

1、代码分析：

（1）实现（implements）接口 Comparable ：

实现接口，需重写接口的抽象方法。

（2）成员属性：

①编号（id）

②姓名（name）

③薪资（saraly）

③年龄（age）

（3）构造器：

有参的构造器：public Employee(int id, String name, Double saraly, int age)

使用“Alt+Insert”快捷键，点击"Constructor",生成有参的构造器。

（4）成员方法：

①Getter和Setter方法：可使用“Alt+Insert”快捷键快速生成。

②重写父类“Object”(一般类默认的父类)的“toString”方法。可使用“Alt+Insert”快捷键，找到“toString”方法快速生成。public String toString()

③重写接口的方法：public int compareTo(Object o)

重写接口方法，可使用“Ctrl + I”快捷键快速生成。

//2022.7.28
public class Employee implements Comparable{
    //成员属性
    private int id;
    private String name;
    private Double saraly;
    private int age;
    //构造器
 
    public Employee(int id, String name, Double saraly, int age) {
        this.id = id;
        this.name = name;
        this.saraly = saraly;
        this.age = age;
    }
    //getter和setter方法
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Double getSaraly() {
        return saraly;
    }
 
    public void setSaraly(Double saraly) {
        this.saraly = saraly;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
    //重写toString方法、
 
    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", saraly=" + saraly +
                ", age=" + age +
                '}';
    }
    //需要重写CompareTo方法
 
    @Override
    public int compareTo(Object o) {
        return this.id-((Employee)o).id;
    }
}

（二）ArrayTools类

1、实现的方法：

（1）自然排序：public static void sort(Object[] arr)   使用了冒泡排序

（2）定制排序：public static void sort(Object[] arr, Comparator c)

（3）打印输出：public static void print(Object[] arr)

//2022.7.28
import java.util.Comparator;
 
public class ArrayTools {
      //自然排序
      public static void sort(Object[] arr) {
            //进行冒泡排序
            for (int i = 1; i < arr.length; i++) {
                for (int j = 0; j < arr.length - i; j++) {
                    Comparable left = (Comparable) arr[j];
                    if (left.compareTo(arr[j + 1]) > 0) {
                        Object temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
 
        //定制排序
        public static void sort(Object[] arr, Comparator c) {
            //进行冒泡排序
            for (int i = 1; i < arr.length; i++) {
                for (int j = 0; j < arr.length - i; j++) {
                    if (c.compare(arr[j], arr[j + 1]) > 0) {
                        Object temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
 
        //打印
        public static void print(Object[] arr) {
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
 
            }
        }
}

（三）TestAnonymousInnerUse类

1、该类为测试类，是主程序的入口。

2、在此类中创建了Employee类的对象数组，对5个数组对象分别按照“编号从小到大排序”、“编号从大到小排序”、“薪资从大到小排序”、“年龄从大到小排序”。

3、在后面三个的排序中对“Comparator接口”使用了“匿名内部类”方法。

重写接口方法时，使用了“向下转型”，将Object类的对象转型为Employee类进行属性的比较。

//2022.7.28
import java.util.Comparator;
 
public class TestAnonymousInnerUse {
    public static void main(String[] args) {
        //创建Employee类的对象数组，存5个对象
        Employee[] arr = new Employee[5];
        arr[0] = new Employee(1,"张三",15000.0,23);
        arr[1] = new Employee(3,"李四",16000.0,23);
        arr[2] = new Employee(5,"王五",12000.0,26);
        arr[3] = new Employee(4,"赵六",17000.0,21);
        arr[4] = new Employee(2,"钱七",13000.0,22);
 
 
        //按照员工的编号进行排序
 
        System.out.println("按照编号从小到大排序：");
        ArrayTools.sort(arr);
        ArrayTools.print(arr);
 
        System.out.println("按照编号从大到小排序：");
        //使用匿名内部类
        ArrayTools.sort(arr, new Comparator() {
            @Override
            public int compare(Object o, Object t1) {
                Employee e1 = (Employee)o;
                Employee e2 = (Employee)t1;
                return e2.getId() - e1.getId();
            }
        });
        ArrayTools.print(arr);
 
        System.out.println("按照薪资从大到小排序：");
        ArrayTools.sort(arr, new Comparator() {
            @Override
            public int compare(Object o, Object t1) {
                Employee e1 = (Employee)o;
                Employee e2 = (Employee)t1;
                return Double.compare(e2.getSaraly(),e1.getSaraly());
            }
        });
        ArrayTools.print(arr);
 
        System.out.println("按照年龄从大到小排序：");
        ArrayTools.sort(arr, new Comparator() {
            @Override
            public int compare(Object o, Object t1) {
                Employee e1 = (Employee) o;
                Employee e2 = (Employee) t1;
                return e2.getAge() - e1.getAge();
            }
        });
        ArrayTools.print(arr);
    }
}

三、测试代码

验证结果实现测试要求，测试OK，代码可行。