制作使用枚举在Java中的等级水平，则允许用户输入数字级输出信等级

问题描述 投票：1回答：5

我对我的在线学习Java四个星期，有一个分配使用枚举创建一个分级标准。

我创建了分级标准枚举，但我对如何允许用户输入一个数值，将其输出信价值完全丧失。每一次尝试，它要么告诉我，我不能使用恢复功能有什么我选择或的System.out.println并不想要么接受我的价值观。我已经决定彻底​​放弃我的类文件，并重新启动，但不知道我做了什么错。这里是我的枚举的代码：

public enum Grade {

    A(95-100, "A"),
    AMINUS(92-94, "A-"),
    BPLUS(89-91, "B+"),
    B(86-88, "B"),
    BMINUS(83-85, "B-"),
    CPLUS(80-82, "C+"),
    C(77-79, "C"),
    CMINUS(74-76, "C-"),
    DPLUS(71-73, "D+"),
    D(68-70, "D"),
    DMINUS(65-67, "D-"),
    F(1-64, "F"),
    FA(0, "FAILURE TO APPEAR");

    private final String gradeText; 

    private Grade(int gradeValue, String gradeText) {
        this.gradeText = gradeText; 
    }

    public String printGrade() {
        return gradeText; 
    }
}
java enums enumeration
5个回答
0
投票

我认为this approach可以帮助你。

而不是试图存储范围在枚举，存储仍然可以认为等级，每个等级的最大值。然后你可以检索实际字母等级用静态方法的帮助：

public enum Grade {

    A(100, "A"), AMINUS(94, "A-"), BPLUS(91, "B+"), B(88, "B"), BMINUS(85, "B-"),
    CPLUS(82, "C+"), C(79, "C"), CMINUS(76, "C-"), DPLUS(73, "D+"), D(70, "D"),
    DMINUS(67, "D-"), F(64, "F"), FA(0, "FAILURE TO APPEAR");

    private final int gradeValue;
    private final String gradeText;

    private Grade(int gradeValue, String gradeText) {
        this.gradeValue = gradeValue;
        this.gradeText = gradeText;
    }

    public static Grade getGrade(int value) {
        Grade grade = FA;
        for(Grade g : values()) {
            if(value <= g.gradeValue) {
                grade = g;
            }
        }
        return grade;
    }

    public String printGrade() {
        return gradeText;
    }
}

测试一下：

System.out.println(Grade.getGrade(99).printGrade());
System.out.println(Grade.getGrade(80).printGrade());
System.out.println(Grade.getGrade(88).printGrade());
System.out.println(Grade.getGrade(75).printGrade());

给了我们这样的：

A
C+
B
C-
0
投票

您需要定义的边界作为单独的领域为编译器理解。也许你正在寻找一个枚举是这样的：

public enum Grade {
    A("A", 95, 100),
    AMINUS("A-", 92, 94);
    // DEFINE ALL YOUR GRADES HERE

    String grade;
    int gradeMin;
    int gradeMax;

    Grade(String grade, int gradeMin, int gradeMax) {
        this.grade = grade;
        this.gradeMin = gradeMin;
        this.gradeMax = gradeMax;
    }

    /**
     * @return the grade
     */
    public String getGrade() {
        return grade;
    }

    /**
     * @return the gradeMin
     */
    public int getGradeMin() {
        return gradeMin;
    }

    /**
     * @return the gradeMax
     */
    public int getGradeMax() {
        return gradeMax;
    }

    public static Grade getGrade(int marks) {
        for (Grade g : values()) {
            if (marks >= g.getGradeMin() && marks <= g.getGradeMax()) {
                return g;
            }
        }

        return null;
    }
}

然后你可以使用这个在你的类来获得等级为

public class GradeRetriever {
    public static void main(String... args) {
        System.out.println(Grade.getGrade(92).getGrade());
    }
}
0
投票

我猜你正在努力实现这样的事情：

public enum Grade {

    A(95, 100, "A"),
    AMINUS(92, 94, "A-"),
    BPLUS(89, 91, "B+"),
    B(86, 88, "B"),
    BMINUS(83, 85, "B-"),
    CPLUS(80, 82, "C+"),
    C(77, 79, "C"),
    CMINUS(74, 76, "C-"),
    DPLUS(71, 73, "D+"),
    D(68, 70, "D"),
    DMINUS(65, 67, "D-"),
    F(1, 64, "F"),
    FA(0, 0, "FAILURE TO APPEAR");

    private final String gradeText;
    private final int lower;
    private final int higher;

    private Grade(int lower, int higher, String gradeText) {
        this.gradeText = gradeText;
        this.lower = lower;
        this.higher = higher;
    }

    public String getGradeText() {
        return this.gradeText;
    }

    public static Grade getGrade(int points) {
        for (Grade g : Grade.values()) {
            if (g.lower <= points && points <= g.higher) {
                return g;
            }
        }

        return null;
    }

    public static void main(String[] args) {
        for (int i = 0; i <= 100; i++) {
            System.out.println(Grade.getGrade(i));
        }
    }
}

我已经更换了你“范围”的定义有两个单独的参数，将它们存储到枚举领域，并增加了getGrade(int points)方法，即返回与点的给定数量的对应Grade枚举项目。如果你不进入范围内的任何数0到100，该方法返回null。该main方法仅在那里完成概念的这个简单的证明，并就如何使用getGrade(int)方法的例子。

0
投票

构造函数将无法正常工作，你正在使用它的方式。如果你想将值添加到枚举类型，因为你在这里做，你需要在构造函数来设置这些值。

enum类型只需要一个构造原因，并构造不能由其他Java类中使用。

由于在Java中没有容易的范围类，我建议你定义的最小值和最大值为单独的参数：

public enum Grade {
    A(95, 100, "A")
    // and so on

    String gradeText;
    int gradeMinPoints;
    int gradeMaxPoints;

    // ...
}

在你的构造函数，你需要指定这些值：

private Grade (int minimum, int maximum, String text) {
    this.gradeMinPoints = minimum;
    this.gradeMaxPoints = maximum;
    this.gradeText      = text;
}

您可以通过附加的功能访问的变量，并宣布恢复取决于你提供的参数“级别”枚举类型的静态功能。其他答案这个帖子提供更好的功能，比我能写了，所以我将把你的。

0
投票
public enum Grade {
    A("A", 95, 100),
    AMINUS("A-", 92, 94),
    BPLUS("B+", 89, 91),
    B("B", 86, 88),
    BMINUS("B-", 83, 85),
    CPLUS("C+", 80, 82),
    C("C", 77, 79),
    CMINUS("C-", 74, 76),
    DPLUS("D+", 71, 73),
    D("D", 68, 70),
    DMINUS("D-", 65, 67),
    F("F", 1, 64),
    FA("FAILURE TO APPEAR", 0, 0);

    private final String text;
    private final int min;
    private final int max;

    Grade(String text, int min, int maxScore) {
        this.text = text;
        this.min = min;
        this.max = maxScore;
    }

    public String getText() {
        return text;
    }

    public static Grade parseScore(int score) {
        for (Grade grade : values())
            if (score >= grade.min && score <= grade.max)
                return grade;
        throw new EnumConstantNotPresentException(Grade.class, String.valueOf(score));
    }
}

现在你可以得分转换成Gradle：

Grade grade = Grade.parseScore(85);  // BMINUS
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.