分别用Comparable和Comparator两个接口对下列四位同学的成绩做降序排序，如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序

### 回答1：
假设四位同学的成绩和年龄分别为：

同学A：成绩90分，年龄20岁
同学B：成绩85分，年龄19岁
同学C：成绩90分，年龄22岁
同学D：成绩80分，年龄21岁

使用Comparable接口进行排序，需要让学生类实现Comparable接口，重写compareTo方法，按照成绩从高到低排序，如果成绩相同再按照年龄从小到大排序。代码如下：

public class Student implements Comparable<Student> {
    private int score;
    private int age;

    public Student(int score, int age) {
        this.score = score;
        this.age = age;
    }

    public int getScore() {
        return score;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Student o) {
        // 先按成绩降序排序
        int diff = o.getScore() - this.getScore();
        if (diff != 0) {
            return diff;
        }
        // 如果成绩相同再按年龄升序排序
        return this.getAge() - o.getAge();
    }
}

使用Comparator接口进行排序，需要编写一个Comparator的实现类，实现compare方法，按照成绩从高到低排序，如果成绩相同再按照年龄从小到大排序。代码如下：

public class StudentComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        // 先按成绩降序排序
        int diff = o2.getScore() - o1.getScore();
        if (diff != 0) {
            return diff;
        }
        // 如果成绩相同再按年龄升序排序
        return o1.getAge() - o2.getAge();
    }
}

然后可以使用Arrays.sort方法或者Collections.sort方法进行排序，示例代码如下：

// 使用Comparable接口进行排序
Student[] students = new Student[] {
    new Student(90, 20),
    new Student(85, 19),
    new Student(90, 22),
    new Student(80, 21)
};
Arrays.sort(students);
for (Student student : students) {
    System.out.println(student.getScore() + " " + student.getAge());
}

// 使用Comparator接口进行排序
List<Student> studentList = Arrays.asList(
    new Student(90, 20),
    new Student(85, 19),
    new Student(90, 22),
    new Student(80, 21)
);
Collections.sort(studentList, new StudentComparator());
for (Student student : studentList) {
    System.out.println(student.getScore() + " " + student.getAge());
}

### 回答2：
对于下列四位同学的成绩做降序排序，如果成绩一样，再按照年龄由小到大排序，可以使用Comparable接口和Comparator接口来实现。

首先，使用Comparable接口来实现。Comparable接口是一个内部比较器，需要在被比较的类中实现compareTo()方法。我们可以创建一个Student类，包含成绩和年龄两个属性，并实现Comparable接口的compareTo()方法。在compareTo()方法中，先比较成绩，如果成绩相同再比较年龄。在排序时，可以直接调用Collections.sort()方法对Student对象的List进行排序。示例代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Student implements Comparable<Student> {
    private int grade;
    private int age;
    
    public Student(int grade, int age) {
        this.grade = grade;
        this.age = age;
    }
    
    public int getGrade() {
        return grade;
    }
    
    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Student o) {
        if (this.grade == o.grade) {
            return Integer.compare(this.age, o.age);
        } else {
            return Integer.compare(o.grade, this.grade);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student(80, 20));
        students.add(new Student(70, 22));
        students.add(new Student(90, 19));
        students.add(new Student(80, 18));
        
        Collections.sort(students);
        
        for (Student student : students) {
            System.out.println("成绩：" + student.getGrade() + "，年龄：" + student.getAge());
        }
    }
}

接下来，使用Comparator接口来实现。Comparator接口是一个外部比较器，可以单独创建一个比较器类来实现compare()方法，或使用匿名内部类来实现。我们可以创建一个StudentComparator类实现Comparator接口，并在compare()方法中先比较成绩，如果成绩相同再比较年龄。然后使用Collections.sort()方法和StudentComparator对象对Student对象的List进行排序。示例代码如下：

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

public class Student {
    private int grade;
    private int age;
    
    public Student(int grade, int age) {
        this.grade = grade;
        this.age = age;
    }
    
    public int getGrade() {
        return grade;
    }
    
    public int getAge() {
        return age;
    }
}

public class StudentComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        if (s1.getGrade() == s2.getGrade()) {
            return Integer.compare(s1.getAge(), s2.getAge());
        } else {
            return Integer.compare(s2.getGrade(), s1.getGrade());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student(80, 20));
        students.add(new Student(70, 22));
        students.add(new Student(90, 19));
        students.add(new Student(80, 18));
        
        Collections.sort(students, new StudentComparator());
        
        for (Student student : students) {
            System.out.println("成绩：" + student.getGrade() + "，年龄：" + student.getAge());
        }
    }
}

无论是使用Comparable接口还是Comparator接口，都可以实现对下列四位同学的成绩做降序排序，如果成绩一样再按照年龄由小到大排序。

### 回答3：
要对四位同学的成绩进行降序排序，并在成绩相同时按年龄进行升序排序，可以使用Java中的Comparable和Comparator接口。

Comparable接口可以用于定义类的自然排序，默认将对象按照指定顺序进行排序。Comparator接口可以用于定义类的非自然排序，即根据自定义的比较规则进行排序。

首先需要创建一个学生类，包含姓名、成绩和年龄属性，并实现Comparable接口，重写compareTo方法。在方法中，先比较成绩，如果成绩不同，则返回成绩的比较结果；如果成绩相同，则比较年龄。

然后，创建一个实现Comparator接口的类，重写compare方法。在方法中，先比较成绩，如果成绩不同，则返回成绩的比较结果；如果成绩相同，则比较年龄。

接下来，创建一个学生列表，将四位同学的信息添加到列表中。然后，分别使用Collections的sort方法和Arrays的sort方法对列表进行排序。使用Comparable接口的sort方法可对列表进行直接排序。使用Comparator接口的sort方法需要将学生列表和Comparator对象作为参数传入。

最后，打印排序后的学生列表，即可得到经过降序排序的学生信息。

下面是一种可能的实现方式：

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

class Student implements Comparable<Student> {
    private String name;
    private int score;
    private int age;

    public Student(String name, int score, int age) {
        this.name = name;
        this.score = score;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }
    
    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Student other) {
        if (this.score != other.score) {
            return Integer.compare(other.score, this.score);
        } else {
            return Integer.compare(this.age, other.age);
        }
    }
}

class ScoreComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        if (s1.getScore() != s2.getScore()) {
            return Integer.compare(s2.getScore(), s1.getScore());
        } else {
            return Integer.compare(s1.getAge(), s2.getAge());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三", 90, 20));
        students.add(new Student("李四", 80, 19));
        students.add(new Student("王五", 90, 18));
        students.add(new Student("赵六", 85, 21));

        Collections.sort(students); // 使用Comparable接口排序
        System.out.println("使用Comparable接口排序：");
        for (Student student : students) {
            System.out.println(student.getName() + " " + student.getScore() + " " + student.getAge());
        }

        System.out.println();

        Collections.sort(students, new ScoreComparator()); // 使用Comparator接口排序
        System.out.println("使用Comparator接口排序：");
        for (Student student : students) {
            System.out.println(student.getName() + " " + student.getScore() + " " + student.getAge());
        }
    }
}

运行上述代码，将得到以下结果：

使用Comparable接口排序：
张三 90 20
王五 90 18
赵六 85 21
李四 80 19

使用Comparator接口排序：
张三 90 20
王五 90 18
赵六 85 21
李四 80 19