使用继承简化 java 程序

Question

我目前正在 java 学习继承。我有一个名为 Students 的超类，其子类为 UndergradStudents 和 GraduateStudents。他们都有一个名为 deansHonourList 的方法。在本科生 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;
    }
 }

注意：这是一个练习，价值不大，但我想得到正确方向的提示。这是问题还指定的内容。

我必须在不使用 instanceof 或 getClass() 且不添加任何更多 if-else 语句或实例变量的情况下使其工作。 GraduateStudent 或 UndergraduateStudent 中不应有 deansHonourList() 方法，并且可以删除 getGPA() 方法。

我得到的提示是向超类添加另一个实例方法，并根据需要在子类中覆盖它；在您的 deansHonourList() 方法中调用该方法。

我想不出办法来做到这一点。我的意思是我可以在我要创建的新实例方法中放入什么，然后在子类中覆盖它。

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

Answer 1

你需要一个（可能是抽象的）方法，其中 returns 可接受的最低 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;
    }
}

现在，如果这不可接受，您将需要通过构造函数将最低 GPA 分数传递给父级 class，例如...

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;
    }
}

例如

Answer 2

好吧，如果你有一个方法 'requiredGPA()'，它 return 达到进入院长荣誉名单所需的 GPA 会怎么样？

然后您将在子类中覆盖此方法以满足 return 它们的不同要求，并且超类的 deansHonourList() 将使用此方法中的值 return 来决定学生是否在名单？

如果需要，我可以给出一个代码示例...如果我在这个答案中没有说清楚，请告诉我？

编辑 - 看起来 MadProgrammer 已经达到了我想要的想法。

Answer 3

这是外观设计模式的一个例子。检查 here.

这个模式是关于提供一个简单的接口来隐藏底层的复杂性。接口用于单次调用，在运行时间JVM会决定调用哪个方法。此方法由调用方法的对象的实现 class 决定。

在你的例子中，学生将作为界面工作。正如其他人所建议的那样，您可以将抽象 class 与抽象方法 deansHonourList 一起使用，或者您可以使用空实现。

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

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

由于父 class 引用变量可以保存子 class 的实例，我们可以将 UnderGraduateStudent 和 GraduateStudent 的对象分配给 Student 类型的引用变量。

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

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

JVM 将通过检查 student1、student2、student3 实例的类型找到正确的 class 从中调用方法。

只会调用这些方法中的一个（与构造函数不同，其中在子class构造函数中调用超级class构造函数）。

即使在父 class 引用上调用 deansHonourList，也会调用子 class 中的方法，因为引用持有子 class 实例。这称为方法覆盖。

检查 this。

覆盖仅在非静态方法的情况下有效，在静态方法的情况下，调用父 class 方法。由于静态成员是 class 而非 class 实例的一部分，因此实例在方法解析中不起作用。这叫做方法隐藏

使用继承简化 java 程序

Simplify java program using inheritance

java

inheritance

overriding