Java 请帮助我从这个超类继承

我想确定一个数组的最大分数，该数组包含学生的教室名称及其分数。为此，我有一个超类，如

Person

，它包含

getName（）

、

Max（）

和

print（）

抽象方法，不应更改

我有一个名为

Student

的子类，它应该从

Person

超类扩展而来。这个子类应该保存学生的信息，获得教室的最高分数，然后打印出来。主类名是

点

。我使用hashmap将标记存储在其值中。如何在

Max（）

方法中使用此值，以及如何使用

Print（）

方法显示最大分数和学生姓名。谢谢

这是我写的

Person

超类：

public abstract class Person {
private String name;

Person(String name) {
    this.name = name;
}

public String getName() {
    return name;
}

public abstract void Max();

public abstract void Print();

}

Student

子类：

import java.util.*;

public class Student extends Person {
Map<String, Integer> scores = new HashMap<>();

Student(String name) {
    super(name);
    String[] bits = name.trim().split(" ");
    for (int i = 0; i < bits.length; i++) {
        int Marks = Integer.parseInt(bits[1]);
        scores.put(bits[0], Marks);
    }
}

@Override
public void Max() {

}

@Override
public void Print() {

}

}

---

根据继承的概念，您在这里要说的是：

每个

学生

，都是

人

。这没关系

但是，每个人只能访问自己的数据，而不能访问其他人的数据，包括姓名、分数和。它只能访问自己的数据

在

点

主类的定义中，您用学生的信息填充了数组标记，因此

点

类可以访问所有学生。因此，理想情况是在维护所有对象的类中实现处理多个对象的方法

这里有两个提示：

• 对于

  Student

  类，您确实不需要

  HashMap

  。每个

  学生

  只存储自己的姓名和分数，而不是所有学生的姓名和分数<代码>HashMap用于存储同一类型但具有不同指示符的多个值，因此您可以轻松找到一个值

• 尽量缩短

  main

  方法。例如，您可以使用

  run（）

  方法创建一个类

  Program

  ，并在

  main

  方法中仅实例化该

  Program

  类并调用其

  run（）

  方法

---

如下图所示更改Point类，调用max，在for循环外部打印方法

为max和print方法编写逻辑。在max方法内部，直接使用hashmap来检索max值

另外，您正在为您创建的每个对象创建hashmap，因此对于每个名称，它将创建新的hashmap，因此您将始终从max方法获得姓氏

因此，在学生类中将hashmap设置为静态，如下所示

static Map<String, Integer> scores = new HashMap<>();

static Map scores=new HashMap（）；

请参阅下面的全部代码

Person.java

package com.kb.studentMaxMarks;

import java.util.Map.Entry;

public abstract class Person {
private String name;

public Person() {
    // TODO Auto-generated constructor stub
}
Person(String name) {
    this.name = name;
}

public String getName() {
    return name;
}

public abstract Entry<String, Integer> Max();

public abstract void Print(Entry<String, Integer> entry);

}

package com.kb.studentMaxMarks；
导入java.util.Map.Entry；
公共抽象类人物{
私有字符串名称；
公众人士（）{
//TODO自动生成的构造函数存根
}
Person（字符串名称）{
this.name=名称；
}
公共字符串getName（）{
返回名称；
}
公共摘要条目Max（）；
公开摘要作废打印（分录）；
}

Student.java

package com.kb.studentMaxMarks;

import java.util.*;
import java.util.Map.Entry;

public class Student extends Person {
static Map<String, Integer> scores = new HashMap<>();

Student(String name) {
    super(name);
    String[] bits = name.trim().split(" ");
    for (int i = 0; i < bits.length; i++) {
        int marks = Integer.parseInt(bits[1]);
       // System.out.println(marks);
        scores.put(bits[0], marks);
    }
}

@Override
public Entry<String, Integer> Max() {
    System.out.println("inside max");

     Map.Entry<String,Integer> maxEntry = null;
     //System.out.println(" max value of map "+maxValueInMap);
    for (Map.Entry<String,Integer> entry : scores.entrySet()) {
         if (maxEntry == null || entry.getValue().compareTo(maxEntry.getValue()) > 0)
            {
                maxEntry = entry;
            }
    }
    //System.out.println(maxEntry.getValue());
    return maxEntry;

}

@Override
public void Print(Entry<String, Integer> entry) {
    System.out.println("name "+entry.getKey()+" score "+entry.getValue());

}

}

package com.kb.studentMaxMarks；
导入java.util.*；
导入java.util.Map.Entry；
公营班级学生人数{
静态映射分数=新HashMap（）；
学生（字符串名称）{
超级（姓名）；
字符串[]位=name.trim（）.split（“”）；
for（int i=0；i0）
{
maxEntry=entry；
}
}
//System.out.println（maxEntry.getValue（））；
返回maxEntry；
}
@凌驾
公共作废打印（条目）{
System.out.println（“name”+entry.getKey（）+“score”+entry.getValue（））；
}
}

Points.java

package com.kb.studentMaxMarks;

import java.util.Map.Entry;

public class Points {

public static void main(String[] args) {
    String[] Marks = new String[] { "Student1 12",
            "Student2 90",
            "Student3 45",
            "Student4 76", 
            "Student5 58", };
    Student std = null;
    for (int i = 0; i < Marks.length; i++) {
         std = new Student(Marks[i]);
        std.getName();
    }
    Entry<String, Integer> entry = std.Max();
    std.Print(entry);
}

}

package com.kb.studentMaxMarks；
导入java.util.Map.Entry；
公共课分数{
公共静态void main（字符串[]args）{
字符串[]标记=新字符串[]{“Student1 12”，
“学生2 90”，
“学生3 45”，
“学生4 76”，
“学生5 58”，}；
学生std=null；
for（int i=0；i

---

如果有任何问题，请告诉我。

有人告诉我，您应该使用hashmap。我只是不知道如何重写

Print（）

和

Max（）

方法并调用它们。我不熟悉超类。我认为如果在代码中必须使用

HashMap

，那么它应该只使用

Points

类，而不是

Marks

数组。您应该在主类中实现

Max（）

和

Print（）

方法。但是，如果您为您的程序创建了一个驱动程序类，那将是最好的。事实上，我认为您的程序中没有任何继承的需要。您只需创建类

Student

，然后维护驱动程序对象中的所有记录。使用继承肯定有更好的例子：例如，看看一些RPG游戏。您将立即认识到继承的用途。谢谢。现在我不知道如何重写max方法，例如，当我写这段代码时，我只得到最后一个学生的分数：

@override public void max（）{System.out.println（scores.values（））；}

max应该只返回max scores学生的详细信息，对吗？你能告诉我你用什么逻辑来找到最大值吗？看看更新后的答案，让地图在学生课堂上成为静态的。事实上我不知道如何使用逻辑来

package com.kb.studentMaxMarks;

import java.util.Map.Entry;

public class Points {

public static void main(String[] args) {
    String[] Marks = new String[] { "Student1 12",
            "Student2 90",
            "Student3 45",
            "Student4 76", 
            "Student5 58", };
    Student std = null;
    for (int i = 0; i < Marks.length; i++) {
         std = new Student(Marks[i]);
        std.getName();
    }
    Entry<String, Integer> entry = std.Max();
    std.Print(entry);
}

}