OOP 类责任

Question

我正在开发一个爱好项目，以正确理解封装、可以负责的类和规则。我在另一个forum 中要求进行代码审查和帮助，但我不同意给出的方法。

我有以下要求：

• 国际学生需要文件来完成注册过程，但国内学生不需要。

学生状态界面：

public interface StudentStatus {
    Collection<String> retrieveDocuments();
    StudentType retrieveStatus();
}

 public final class Domestic implements StudentStatus {

       private final StudentType type;
       private final Collection<String> documents;

       public Domestic() {
           this.type = StudentType.Domestic;
           this.documents = Collections.emptyList();
       }

       @Override
       public Collection<String> retrieveDocuments() {
           return this.documents;
       }

       @Override
       public StudentType retrieveStatus() {
           return type;
       }
   }

public final class International implements StudentStatus {

   private final StudentType type;
   private Collection<String> documents;


   public International(Collection<String> documents) {

       this.type = StudentType.International;
       this.documents = Collections.unmodifiableCollection(documents);
   }

   @Override
   public Collection<String> retrieveDocuments() {
       return Collections.unmodifiableCollection(documents);
   }

   @Override
   public StudentType retrieveStatus() {
      return type;
   }
}

学生班：

public final class Student {

     //left out constructor and getters for other attributes. 

     public Collection<String> retrieveDocuments() {
           return status.retrieveDocuments();
     }

     public StudentType retrieveStatus() {
          return status.retrieveStatus();
     }

     public boolean isVerified(StudentType type) {
         return this.retrieveStatus() == type;
     }
}

大学班：

public class University {

    private final Map<Student,Collection<String>> registeredStudents;
    private final StudentType type;

    public University()
    {
        registeredStudents = new HashMap<Student,Collection<String>>();
        type = StudentType.International;
    }

    public void add(Student student){
        if (student.isVerified(type)){
            registeredStudents.put(student, student.retrieveDocuments());
        }else {
            //throw an exception or handle error accordingly 
        }
    }
}

在继续之前，我了解这是一个真的过于简化的申请流程。在现实世界中，在学生注册之前还需要做很多事情。学生可能必须通过入学考试，并在注册开始前付款。此外，在现实环境中，这些信息可能会存储在校园员工可以访问的数据库中。

在另一个论坛中，讨论的内容是提供了哪些信息，并给出了方法。

• 有一个规则类，它接受 Student 对象并验证它 实际上是国际化的并且有文件。

我遇到的问题是，您仍然需要使用retriveStatus() 或isVerified() 询问学生他/她的状态，我真的不知道该怎么做.

• 分别传递学生和文档集合以添加到地图中。

在现实世界中，大学如上所述制定规则，其职责是检查国际学生是否有文件。

当我使用add(Student student) 建议上述方法时，他们表示这不是一个好主意，因为规则可能会改变，您必须更改 Student 类以及 University 类。

但是，在现实世界中，学生很清楚他/她的身份，以及他/她是国内还是国际，并且拥有可以提供给学校的文件。

鉴于上述方法，以这种方式编写 add 方法是个好主意吗？有没有比 add 方法更好的方法？

tl;dr - 如果学生必须遵守大学制定的规则，那么学生对象将如何与大学通信以获取数据，以便大学可以确保学生对象在不破坏封装的情况下遵守规则？

Answer 1

上一篇文章中的对话可能将您引向了一个总体上不错的方向。最适用的原则是开放/封闭原则。 https://en.wikipedia.org/wiki/Open/closed_principle.

不要让自己不得不不断地修改一个特定的类或一组类（至少在 OO 世界中），在一个你知道将是频繁变化的领域。该原则同样适用于功能世界，但您的示例使用的是 OOPL。

手工构建的小规则引擎是解决您提出的问题的一个很好的解决方案。特别是如果你知道规则在相当固定的输入上流动——比如大学和学生。 DocumentsRequiredForInternationalStudents 是该架构中的一个规则类 - 仅当该规则本身发生变化时才需要更改。新规则，这将发生很多 = 添加新类，而不是修改现有类。

有时你不知道变化的向量，更难做出决定，但如果很明显，不要构建一个系统，因为已知的变化向量你将不得不不断地违反打开/关闭。

有不同的方法来实现小规则引擎。一种选择（这是蹩脚的伪代码，因此占用的空间更少）

interface RegistrationRule
 boolean isRegistrationValid(Student student)  //might need university too for some rules.

class DocumentsNeededForInternationalStudents implements RegistrationRule
 boolean isRegistrationValid(Student student) 
 // return student.status is international and student has documents, or student status is domestic 
// (this rule passes through as valid any domestic students).

class RegistrationRules 
// (holds all the rules you will use - kind of a factory)
constructor -> add to static list of rules an instance of all your rules
boolean runRulesForStudent(Student)
  //iterate through all rules, call isRegistrationValid, short circuit and return false if one of them false


class University
addStudent(Student student)
  if (RegistrationRules.runRules(student).... else

这只是将其组合在一起的一种方式，但您可以看到它实际上并没有很多代码。您有一个接口，每个规则的实现类，以及一个为您应用每个规则的小规则引擎类。新规则 = 新类，修改规则引擎中的构造函数以添加该类的实例，完成。

当规则中需要的属性和行为非常多样化且不集中在同一小类集合中时，这种模式开始有点困难。

Answer 2

你说：

在现实世界中，大学设定了上述规则，并且 它的责任是检查国际学生是否有 文档。

这意味着验证责任在于大学（每个大学可能不同）而不是学生。学生所能做的就是提供必要的信息供大学验证。

add 方法应该从retrieveDocuments 获取文档并运行其规则以确定是否允许学生被接受。