如何在此代码中更改一个人的角色

Question

public class Person implements Roles{

    private String id;
    private String name;
    private String[] skills;
    private List<Note> notes;

    public Person(String id, String name, String[] skills) {
        this.id = id;
        this.name = name;
        this.skills = skills;
        this.notes = new ArrayList<Note>();
    }

    public String getName() {
        return this.name;
    }

    public String getId() {
        return this.id;
    }

    public String[] getSkills() {
        return this.skills;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSkills(String[] skills) {
        this.skills = skills;
    }

    public void addNote(String note, String authorName) {
        notes.add(new Note(authorName, note));
    }

    public String listNotes() {
        String result = this.name + " - " + this.id;
        for (Note note: notes) {
            result += "\n" + note.toString();
        }
        return result;
    }

    @Override
    public String toString() {
        String result = this.name + " - " + this.id;
        Arrays.sort(skills);
        for (String skill: skills) {
            result += "\n- " + skills;
        }
        return result;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        if (o.getClass() != this.getClass()) {
            return false;
        }
        Person Person2 = (Person) o;
        return this.id.equals(Person2.getId());
    }

    @Override
    public int hashCode() {
        return this.id.hashCode();
    }
}

public class Student extends Person implements Roles {
    
    private String registration;
    private int year;

    public Student(String id, String name, String registration, int year, String[] skills) {
        super(id, name, skills);
        this.registration = registration;
        this.year = year;
    }
    
    @Override
    public String toString() {
        String result = super.name + " - " + super.id + "\nStudent - " + this.registration + " - " + this.year;
        Arrays.sort(skills);
        for (String skill: skills) {
            result += "\n- " + skill;
        }
        return result;
    }
    
    @Override
    public String listNotes() {
        String result = super.name + " - " + super.id + "\nStudent - " + this.registration + " - " + this.year + "\nNotes:";
        for (Note note: notes) {
            result += "\n" + note.toString();
        }
        return result;
    }
}

public class Teacher extends Person implements Roles{
    
    private String number;
    private String[] subjects;

    public Teacher(String id, String name, String number, String[] subjects, String[] skills) {
        super(id, name, skills);
        this.number = number;
        this.subjects = subjects;
    }
    
    @Override
    public String toString() {
        String result = this.name + " - " + this.id + "\nTeacher - " + this.number + " - ";
        
        for (int i = 0; i <= subjects.length - 1; i++) {
            if (i == subjects.length - 1) {
                result += subjects[i];
                break;
            }
            
            result += subjects[i] + ", ";
        }
        Arrays.sort(skills);
        for (String skill: skills) {
            result += "\n- " + skill;
        }
        return result;
    }
    
    @Override
    public String listNotes() {
        String result = this.name + " - " + this.id + "\nTeacher - " + this.number + " - ";
        
        for (int i = 0; i <= subjects.length - 1; i++) {
            if (i == subjects.length - 1) {
                result += subjects[i] + "\n:";
                break;
            }
            
            result += subjects[i] + ", ";
        }
        
        for (Note note: notes) {
            result += "\n" + note.toString();
        }
        return result;
    }
}

该系统必须能够登记人员、学生和教师。我创建了一个带有学生和教师子类的超类人员，并创建了一个将其存储在人员地图中的接口。

现在我需要一种方法来改变那些已经注册的人的角色，比如一个人成为一名教师，或者一个学生失去了角色。

Answer 1

我需要一种方法来改变那些已经注册的人的角色，比如一个人成为一名教师，或者一个学生离开了某个角色。

在回答你的问题之前，我想指出几个关键的设计错误。(你可以跳过前面，但非常气馁)

1. 您不需要在Student和Teacher类中多次实现Roles接口，因为超类Person已经这样做了。

正如

Federico在评论中所说的那样：

这是个奇怪的设计。为什么角色是接口？一个人“有一个角色”，而不是“一个角色”。

正如

1. 在Federico前面所说的，Person类不应该继承于Roles接口，因为这表明一个人“是一个角色”，而不是“有一个角色”。您的Person类应该引用Roles (您可以阅读更多关于Roles的信息)。

1. Furthermore，我认为Roles不适合作为上下文中的接口。在这里，枚举或一组静态常量似乎更合适。

回答你的问题。通过修复上面指出的关键错误，添加一个额外的检查、一个自定义异常和一个辅助构造函数；您将得到您想要的东西。

为了简单起见，下面是类的简单版本，其余的都可以很容易地添加进来。

public enum Role {
    NONE,
    STUDENT,
    TEACHER
}

public class UnrelatedRoleException extends RuntimeException {
    private static final String EXCEPTION_MESSAGE = "%s cannot be casted %s!";

    public UnrelatedRoleException(final Class<? extends Person> from, final Class<? extends Person> to) {
        super(String.format(EXCEPTION_MESSAGE, from.getSimpleName(), to.getSimpleName()));
    }
}

public class Person {
    private Role role;

    public Person() {
        this(Role.NONE);
    }

    public Person(final Role role) {
        this.role = role;
    }

    protected Person(final Person person) {
        if (!isApplicable(person.role)) {
            throw new UnrelatedRoleException(this.getClass(), this.getClass());
        }
    }

    /**
     * @param role the updated role
     */
    public void setRole(final Role role) {
        this.role = role;
    }

    /**
     * @return the person role
     */
    public Role getRole() {
        return role;
    }

    /**
     * @param role the role to check against
     *
     * @return true if the role is compatible with {@link Person}
     */
    public boolean isApplicable(final Role role) {
        return true;
    }
}

public class Student extends Person {
    public Student() {
        super(Role.STUDENT);
    }

    public Student(final Person person) {
        super(person);
    }

    @Override
    public boolean isApplicable(final Role role) {
        return role == Role.STUDENT;
    }
}

public class Teacher extends Person {
    public Teacher() {
        super(Role.TEACHER);
    }

    public Teacher(final Person person) {
        super(person);
    }

    @Override
    public boolean isApplicable(final Role role) {
        return role == Role.TEACHER;
    }
}

这就是如何使用它：

public class Main {
    public static void main(String[] args) {
        final Person person = new Person();

        // updating the person's role to Student
        person.setRole(Role.STUDENT);
        final Student student = new Student(person);

        // updating the person's role to TEACHER
        person.setRole(Role.TEACHER);
        final Teacher teacher = new Teacher(person);
    }
}

其设计方式如下：

1. Person实例可以使用Role.NONE作为默认角色构建，也可以传递给您自己的Role.

1. Person将被视为Student和Teacher之间的常见类型。因此，使用.

是安全的。

1. 有两种方法来检索Student和Teacher的实例。

3.1。如果您有一个Person实例，则将Person的角色更改为Role.STUDENT/Role.TEACHER，并将Person实例传递给Student/Teacher以保留数据。

3.2。否则，创建Student/Teacher.的新实例

需要注意的是：当您将相关方法添加到Person的子类中时，我建议您包含一个检查，检查角色是否与当前类(通过#isApplicable(role))持续存在，并在角色不再相关时抛出一个未检查的异常(checked vs unchecked exceptions)。

否则，子类的角色可以更改为与类无关的内容，并且预先破坏了您的需求；因为您不应该能够处理与您的角色不再相关的任务。

请随便问你可能有的任何问题。