策略模式实践

有这样一个类：

要求：假如有若干个类Person对象存在一个List当中，对他们进行排序，分别按照名字、年龄、id 进行排序（要有正序与倒序两种排序方式）。假如年龄或者姓名重复，按照id的正序进行排序。要求使用策略模式进行。

public class Person {

    private int id;
    private String name;
    private int age;

    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 int getAge() {
        return age;
    }

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

    public Person(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }
}

public interface Sorter {
    void sort(List<Person> list);
}

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 按照Person类的Id属性的升序进行排序。
 */
public class SortByIdAsc implements Sorter {
    /**
     * 使用Collections类中的sort方法进行排序，使用自定义的比较器。
     * public static <T> void sort(List<T> list, Comparator<? super T> c)
     */
    @Override
    public void sort(List<Person> list) {
        Collections.sort(list, new MyComparator());

    }

    /**
     * 自定义比较器，按照Person类的ID属性排序。
     */
    class MyComparator implements Comparator<Person>{
        @Override
        public int compare(Person person1, Person person2) {
            return person1.getId() - person2.getId();
        }
    }
}

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 按照Person类的Id属性的降序进行排序。
 */
public class SortByIdDesc implements Sorter{
    /**
     * 使用Collections类中的sort方法进行排序，使用自定义的比较器。
     * public static <T> void sort(List<T> list, Comparator<? super T> c)
     */
    @Override
    public void sort(List<Person> list) {
        Collections.sort(list, new MyComparator());

    }

    /**
     * 自定义比较器，按照Person类的ID属性排序。
     */
    class MyComparator implements Comparator<Person> {
        @Override
        public int compare(Person person1, Person person2) {
            return person2.getId() - person1.getId();
        }
    }
}

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 按照Person类的name属性的升序进行排序，在name相同的情况下按照id的升序进行排序。
 */
public class SortByNameAsc implements Sorter{
    /**
     * 使用Collections类中的sort方法进行排序，使用自定义的比较器。
     * public static <T> void sort(List<T> list, Comparator<? super T> c)
     */
    @Override
    public void sort(List<Person> list) {
        Collections.sort(list, new MyComparator());
    }
    /**
     * 自定义比较器，按照Person类的name属性按照字典顺序升序排序，name相同按照id的升序排序。
     */
    class MyComparator implements Comparator<Person> {

        @Override
        public int compare(Person p1, Person p2) {
            String p1Name = p1.getName();
            String p2Name = p2.getName();
            if(p1Name.equals(p2Name)){
                return p1.getId() - p2.getId();
            }
            return p1Name.compareTo(p2Name);
        }
    }
}

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 按照Person类的name属性的降序进行排序，在name相同的情况下按照id的升序进行排序。
 */
public class SortByNameDesc implements Sorter {
    /**
     * 使用Collections类中的sort方法进行排序，使用自定义的比较器。
     * public static <T> void sort(List<T> list, Comparator<? super T> c)
     */
    @Override
    public void sort(List<Person> list) {
        Collections.sort(list, new MyComparator());
    }
    /**
     * 自定义比较器，按照Person类的name属性按照字典顺序降序排序，name相同按照id的升序排序。
     */
    class MyComparator implements Comparator<Person> {

        @Override
        public int compare(Person p1, Person p2) {
            String p1Name = p1.getName();
            String p2Name = p2.getName();
            if(p1Name.equals(p2Name)){
                return p1.getId() - p2.getId();
            }
            return p2Name.compareTo(p1Name);
        }
    }
}

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 按照Person类的age属性的升序进行排序，age相同时按照id的升序排序
 */
public class SortByAgeAsc implements Sorter {
    /**
     * 使用Collections类中的sort方法进行排序，使用自定义的比较器。
     * public static <T> void sort(List<T> list, Comparator<? super T> c)
     */
    @Override
    public void sort(List<Person> list) {
        Collections.sort(list, new MyComparator());

    }

    /**
     * 自定义比较器，按照Person类的age属性升序排序。
     */
    class MyComparator implements Comparator<Person> {
        @Override
        public int compare(Person person1, Person person2) {
            int p1Age = person1.getAge();
            int p2Age = person2.getAge();
            if (p1Age == p2Age) {
                return person1.getId() - person2.getId();
            }
            return p1Age - p2Age;
        }
    }
}

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 按照Person类的age属性的降序进行排序，age相同时按照id的升序排序.
 */
public class SortByAgeDesc implements Sorter {
    /**
     * 使用Collections类中的sort方法进行排序，使用自定义的比较器。
     * public static <T> void sort(List<T> list, Comparator<? super T> c)
     */
    @Override
    public void sort(List<Person> list) {
        Collections.sort(list, new MyComparator());

    }

    /**
     * 自定义比较器，按照Person类的age属性升序排序。
     */
    class MyComparator implements Comparator<Person> {
        @Override
        public int compare(Person person1, Person person2) {
            int p1Age = person1.getAge();
            int p2Age = person2.getAge();
            if (p1Age == p2Age) {
                return person1.getId() - person2.getId();
            }
            return p2Age - p1Age;
        }
    }
}