一个类不会导入到另一个类如何解决这个问题？

Question

我创建了一个包含常量的类，如图所示，所有类都在默认的 src 文件夹中

public final class SectionType {
    public static final String LABS = "LABS";
    public static final String LAB_REPORTS = "LABREPORTS";
    public static final String HOMEWORK = "HOMEWORK";
    public static final String EXAM01 = "EXAM 1";
    public static final String EXAM02 = "EXAM 2";
    public static final String FINAL = "FINAL";
}

我现在需要在像这样的另一个类中使用这些常量

import static SectionType.*;
public class Student {
public void addGrade(SectionType type, double grade) {
            if(type.equals(EXAM01)) {
                this.exam01 = grade;
            }
            if(type.equals(EXAM02)) {
                this.exam02 = grade;
            }
            if(type.equals(FINAL)) {
                this.finalExam = grade;
            }
            if(type.equals(LABS)) {
                this.labSum += grade;
                this.labCount++;
            }
            if(type.equals(LAB_REPORTS)) {
                this.labRSum += grade;
                this.labRCount++;
            }
            if(type.equals(HOMEWORK)) {
                this.hwSum += grade;
                this.hwCount++;
            }
        }
}

什么是让它工作的最佳方法？

Answer 1

addGrade 类改为如下

public void addGrade(String type, double grade) {
            if(type.equals(SectionType.EXAM01)) {
                this.exam01 = grade;
            }
            if(type.equals(SectionType.EXAM02)) {
                this.exam02 = grade;
            }
            if(type.equals(SectionType.FINAL)) {
                this.finalExam = grade;
            }
            if(type.equals(SectionType.LABS)) {
                this.labSum += grade;
                this.labCount++;
            }
            if(type.equals(SectionType.LAB_REPORTS)) {
                this.labRSum += grade;
                this.labRCount++;
            }
            if(type.equals(SectionType.HOMEWORK)) {
                this.hwSum += grade;
                this.hwCount++;
            }
        }

Answer 2

SectionType 不是对象，但您正试图像它一样使用它。它只是一个具有静态成员的类，没有一个类的不同实例的概念，每个实例都有自己的值。

要使现有代码正常工作，您可以更改代码以传递节类型的字符串，如下所示：

import static SectionType.*;

public class Student {

public void addGrade(String type, double grade) {
            if(type.equals(EXAM01)) {
                this.exam01 = grade;
            }
            if(type.equals(EXAM02)) {
                this.exam02 = grade;
            }
            if(type.equals(FINAL)) {
                this.finalExam = grade;
            }
            if(type.equals(LABS)) {
                this.labSum += grade;
                this.labCount++;
            }
            if(type.equals(LAB_REPORTS)) {
                this.labRSum += grade;
                this.labRCount++;
            }
            if(type.equals(HOMEWORK)) {
                this.hwSum += grade;
                this.hwCount++;
            }
        }
}

但最好将 SectionType 设为枚举：

public enum SectionType {
    LABS, LAB_REPORTS, HOMEWORK, EXAM01, EXAM02, FINAL
}

这里特别指出有一个 SectionType 的概念，其中每个值都有一个实例（LABS 是一个 SectionType，LAB_REPORTS 是一个不同的 SectionType，等等），这就是您的代码期望使用它的方式。

(使用枚举的好处是您可以利用编译时类型检查。如果传入了无效的字符串值，则代码将直接失败而无需执行任何操作。但代码不会发生这种情况使用枚举，必须将输入的值转换为有效的枚举，然后才能调用代码，当输入字符串值时，使用SectionType.valueOf将其转换为枚举，如果值无效会抛出异常。 )

听起来你被要求做的是实现过​​时的typesafe enumeration pattern，比如：

public abstract class SectionType {
    // left as an exercise            
}

class Lab extends SectionType {
    public Lab() {
        super("Lab");
    }

class LabReports extends SectionType {
    public LabReports() {
        super("LabReports");   
    }
}

这与枚举非常相似，只是更冗长，更容易出错。这种模式的问题是创建枚举的动机。请参阅 this article 了解实现类型安全枚举不是一个好主意的原因列表。

Answer 3

如果导入是您要查找的内容，则只需像导入任何其他包一样导入该类

import path.where.the.package.is.className;

虽然最好将类复制到您正在处理的项目中然后导入它。

还有一些建议是：

1. 将static 用于类，即public static final class SectionType，因此在使用时无需创建此类的实例。

2. 另一种选择是使用枚举