使用继承简化java程序

我目前正在学习java中的继承。我有一个名为“学生”的超类，其子类为本科生和研究生。它们都有一个称为deansHonourList的方法。在本科生院长荣誉列表方法中，它检查GPA是否大于3.5以符合院长名单的要求，对于毕业生子类，GPA必须大于3.75，我必须删除子类中的方法，并在超类中创建一个方法，以确定学生是否符合院长荣誉列表的要求。这是到目前为止我的代码

 import java.io.*;

public class Activity6C {
    public static void main(String[] args) {
        Student[] students = new Student[4];

        students[0] = new UndergradStudent(8032, "Casper", 2.78, 2);
        students[1] = new GraduateStudent(3044, "Sheena", 3.92, "Natural Language Processing");
        students[2] = new UndergradStudent(6170, "Yolanda", 4.26, 3);
        students[3] = new GraduateStudent(1755, "Geordi", 3.58, "Human-Computer Interaction");

        printStudents(students);
        printDeansList(students);

        System.out.println("\nEnd of processing.");
    }

    public static void printStudents(Student[] students) {
        System.out.println("\nList of all students:\n");
        for (int i = 0; i < students.length; i++) {
            System.out.println(i + 1 + ": " + students[i]);
        }
    }

    public static void printDeansList(Student[] students) {
        System.out.println("\nDean's honour list:\n");
        for (int i = 0; i < students.length; i++) {
            if (students[i].deansHonourList()) {
                System.out.println(students[i]);
            }
        }
    }
 }

 class Student {
    private int number;
    private String name;
    private double gpa;

    public Student(int number, String name, double gpa) {
        this.number = number;
        this.name = name;
        this.gpa = gpa;
    }

    public double getGPA() {
        return gpa;
    }

    public boolean deansHonourList() {
        //Here is where i make my code to determine honour list students
        return false;
    }

    public String toString() {
        return number + " " + name + " (" + gpa + ")";
    }
 }

 class UndergradStudent extends Student {
    private int year;

    public UndergradStudent(int number, String name, double gpa, int year)   {
        super(number, name, gpa);
        this.year = year;
    }

    public boolean deansHonourList() {
        boolean result = false;
        if (getGPA() >= 3.5)
            result = true;
        return result;
    }

    public String toString() {
        return "Undergraduate: " + super.toString() + " year: " + year;
    }
 }

 class GraduateStudent extends Student {
    private String thesis;

    public GraduateStudent(int number, String name, double gpa, String       thesis) {
        super(number, name, gpa);
        this.thesis = thesis;
    }

    public boolean deansHonourList() {
        boolean result = false;
        if (getGPA() >= 3.75)
            result = true;
        return result;
    }

    public String toString() {
        return "Graduate: " + super.toString() + " thesis: " + thesis;
    }
 }

import java.io.*；
公共课堂活动6c{
公共静态void main（字符串[]args）{
学生[]学生=新生[4]；
学生[0]=新本科生（8032，“卡斯珀”，2.78,2）；
学生[1]=新研究生（3044，“Sheena”，3.92，“自然语言处理”）；
学生[2]=新的本科生（6170，“约兰达”，4.26,3）；
学生[3]=应届研究生（1755，“乔治迪”，3.58，“人机交互”）；
学生（学生）；
印刷系主任（学生）；
System.out.println（“\n处理日期”）；
}
公共静态学生（学生[]学生）{
System.out.println（“\n所有学生列表：\n”）；
for（int i=0；i=3.5）
结果=真；
返回结果；
}
公共字符串toString（）{
返回“本科：+super.toString（）+”年份：+year；
}
}
班级研究生{
私有字符串论文；
公共研究生（整数，字符串名称，双gpa，字符串论文）{
超级（编号、名称、gpa）；
这篇论文=论文；
}
公共布尔deansHonourList（）{
布尔结果=假；
如果（getGPA（）>=3.75）
结果=真；
返回结果；
}
公共字符串toString（）{
return“Graduate:+super.toString（）+”论文：+论文；
}
}

注意：这是一个练习，它不值得太多，但我想得到一个正确方向的提示。以下是问题还具体说明的内容

我必须在不使用instanceof或getClass（）的情况下使其工作，并且不添加任何if-else语句或实例变量。在研究生或本科生中都不应该有deansHonourList（）方法，并且可以删除getGPA（）方法

我得到的提示是向超类添加另一个实例方法，并根据需要在子类中重写它；在deansHonourList（）方法中调用该方法

---

我想不出一个办法。我的意思是，我可以在我将要创建的新实例方法中放入什么，然后在子类中重写它

感谢您阅读我的问题或您能给我的任何提示。

您需要一个（可能是抽象的）方法，该方法返回可被考虑列入荣誉名单的最低GPA分数，可能类似于

abstract class Student {

    private int number;
    private String name;
    private double gpa;

    public Student(int number, String name, double gpa) {
        this.number = number;
        this.name = name;
        this.gpa = gpa;
    }

    public double getGPA() {
        return gpa;
    }

    public abstract double getMinimumHonourListGPA();

    public boolean deansHonourList() {
        boolean result = false;
        if (getGPA() >= getMinimumHonourListGPA()) {
            result = true;
        }
        return result;
    }

    public String toString() {
        return number + " " + name + " (" + gpa + ")";
    }
}

然后你可以实现做一些像

class UndergradStudent extends Student {

    private int year;

    public UndergradStudent(int number, String name, double gpa, int year) {
        super(number, name, gpa);
        this.year = year;
    }

    public String toString() {
        return "Undergraduate: " + super.toString() + " year: " + year;
    }

    @Override
    public double getMinimumHonourListGPA() {
        return 3.5;
    }
}

class Student {

    private int number;
    private String name;
    private double gpa;
    private double minimumHonourListGPA;

    public Student(int number, String name, double gpa, double minimumHonourListGPA) {
        this.number = number;
        this.name = name;
        this.gpa = gpa;
        this.minimumHonourListGPA;
    }

    public double getGPA() {
        return gpa;
    }

    public boolean deansHonourList() {
        boolean result = false;
        if (getGPA() >= minimumHonourListGPA) {
            result = true;
        }
        return result;
    }

    public String toString() {
        return number + " " + name + " (" + gpa + ")";
    }
}

class UndergradStudent extends Student {

    private int year;

    public UndergradStudent(int number, String name, double gpa, int year) {
        super(number, name, gpa, 3.5);
        this.year = year;
    }

    public String toString() {
        return "Undergraduate: " + super.toString() + " year: " + year;
    }
}

现在，如果这是不可接受的，您将需要通过构造函数将最低GPA分数传递给父类，类似于

class UndergradStudent extends Student {

    private int year;

    public UndergradStudent(int number, String name, double gpa, int year) {
        super(number, name, gpa);
        this.year = year;
    }

    public String toString() {
        return "Undergraduate: " + super.toString() + " year: " + year;
    }

    @Override
    public double getMinimumHonourListGPA() {
        return 3.5;
    }
}

class Student {

    private int number;
    private String name;
    private double gpa;
    private double minimumHonourListGPA;

    public Student(int number, String name, double gpa, double minimumHonourListGPA) {
        this.number = number;
        this.name = name;
        this.gpa = gpa;
        this.minimumHonourListGPA;
    }

    public double getGPA() {
        return gpa;
    }

    public boolean deansHonourList() {
        boolean result = false;
        if (getGPA() >= minimumHonourListGPA) {
            result = true;
        }
        return result;
    }

    public String toString() {
        return number + " " + name + " (" + gpa + ")";
    }
}

class UndergradStudent extends Student {

    private int year;

    public UndergradStudent(int number, String name, double gpa, int year) {
        super(number, name, gpa, 3.5);
        this.year = year;
    }

    public String toString() {
        return "Undergraduate: " + super.toString() + " year: " + year;
    }
}

---

例如

好的，如果您有一个方法'requiredGPA（）'，该方法返回进入院长荣誉名单所需的GPA，该怎么办

然后在子类中重写此方法以返回其不同的需求，超类的deansHonourList（）将使用此方法返回的值来确定学生是否在列表中

如果需要，我可以给出一个代码示例。。。如果我的回答不清楚，请告诉我

---

编辑-看起来程序员已经找到了我想要的想法。

这是立面设计模式的一个例子。 检查

这个模式是关于提供一个简单的接口来隐藏潜在的复杂性。接口用于调用单个函数，在运行时JVM将决定调用哪个方法。此方法由调用方法的对象的实现类确定

在您的情况下，学生将作为接口工作。正如其他人所建议的那样，您可以使用抽象方法deansHonourList的抽象类，也可以使用空实现

现在假设我们在所有三个类中都有空构造函数

Student student1 = new Student();
Student student2 = new UnderGraduateStudent();
Student student3 = new GraduateStudent();

因为父类引用变量可以保存子类的实例，所以我们可以将本科生和研究生的对象分配给学生类型引用变量

这三个类都有方法deansHonourList。 当我们对所有三个对象调用此方法时，如下所示

student1.deansHonourList(arguments...)
student2.deansHonourList(arguments...)
student3.deansHonourList(arguments...)

JVM将找到它必须从中调用metho的正确类