如何找出抽象列表中的对象？

Question

我有一个名为会话的抽象类。讲座和教程延长了会议。然后我有一个名为注册的课程，其中包含课程列表（讲座和教程）。如何在 Enrollment 中遍历会话列表并仅从会话列表中返回 Lectures 列表？

我的下一个问题是我是否应该存储 2 个列表。一个讲座列表和一个教程列表，而不是 1 个会话列表？这是因为会话列表对我来说毫无用处，我每次都必须遍历它以获取有关讲座和教程的信息。有没有办法让我得到所有的讲座对象？我是java新手。

public class Enrolment {

    private List<Session> sessions;

    public Enrolment() {
        this.sessions = new ArrayList<>();
    }

    public addSession(Session session) {
        this.sessions.add(session);
    }
}

---

public class Session {

    private int time;

    public Session(int time) {
        this.time = time;
    }
}

---

public class Lecture extends Session {

    private String lecturer;

    public Lecture(int time, String lecturer) {
        super(time);
        this.lecturer = lecturer;
    }
}

---

public class Tutorial extends Session {

    private String tutor;
    private int tutorScore;

    public Tutorial(int time, String tutor, int tutorScore) {
        super(time);
        this.tutor = tutor;
        this.tutorScore = tutorScore;
    }

}

---

public class test {
    public static void main(String[] args) {
        Enrolment newEnrolment = new Enrolment();

        Lecture morningLec = new Lecture(900, "Dr. Mike");
        newEnrolment.addSession(morningLec);

        Tutorial afternoonTut = new Tutorial(1400, "John Smith", 3);
        newEnrolment.addSession(afternoonTut);

        Lecture middayLec = new Lecture(1200, "Mr. Micheals");
        newEnrolment.addSession(middayLec);

        Tutorial NightTut = new Tutorial(1900, "Harry Pauls", 4);
        newEnrolment.addSession(NightTut);
    }
}

Answer 1

流式传输sessions 列表并使用instanceof 过滤Lectures 类型的对象

List<Lecture> l = sessions.stream()
                           .filter(Lecture.class::isInstance) 
                           .map(Lecture.class::cast)                               
                           .collect(Collectors.toList());

通过使用for 循环，为每种类型使用两个不同的列表

List<Lecture> l = new ArrayList<>();
List<Tutorial> t = new ArrayList<>();
for (Session s : sessions) {
    if (s instanceof Lecture) {
        l.add((Lecture) s);
    }
      else if(s instanceof Tutorial) {
        t.add((Tutorial) s);
    }
}

Answer 2

在class Enrolment 中将private List<Session> sessions; 更改为public List<Session> sessions;

public static void main(String[] args) {
    ....
    var lecturesAndTutorials = newEnrolment.sessions.where(x => x.getType() == typeof(Lecture) || x.getType() == typeof(Tutorial));
    ....
}

Answer 3

        List<Lecture> l = newEnrolment.getSessions()
            .stream()
            .filter(s-> s.getClass().equals(Lecture.class))
            .map(session -> (Lecture) session)
            .collect(Collectors.toList());

！！！不要使用 typeof

Answer 4

也许你应该存储在两个列表中，就像：

public class Enrolment {

    private List<Lecture> lectures;
    private List<Tutorial> tutorials;

    public Enrolment() {
        this.lectures = new ArrayList<>();
        this.tutorials = new ArrayList<>();
    }

    public void addSession(Session session) {
        if (session instanceof Lecture) {
            lectures.add((Lecture) session);
        } else if (session instanceof  Tutorial) {
            tutorials.add((Tutorial) session);
        }
    }

    public List<Lecture> getLectures() {
        return lectures;
    }

    public List<Tutorial> getTutorials() {
        return tutorials;
    }

    public List<Session> getAllSessions() {
        ArrayList<Session> sessions = new ArrayList<>(lectures);
        sessions.addAll(tutorials);
        return sessions;
    }
}

这是你需要的吗？

Answer 5

引用你的问题，

这是因为会话列表对我来说毫无用处。

所以，这可能不是放置列表的正确位置（？）。

我的偏好是拥有

---

public interface Enrolment {
    public abstract addSession(Session session);
    public abstract getSessions();
}

---

并且List<LectureEnrolment> 和List<TutorialEnrolment> 必须在各自的类中。（我已将Lecture 重命名为LectureEnrolment 并将Tutorial 重命名为TutorialEnrolment）

main() 必须有类似的东西，

Enrolment lectureEnrolment= new LectureEnrolment()

Enrolment tutorialEnrolement = new TutorialEnrolment()

根据需要调用相应的addSession() 或getSession()。

Answer 6

我的下一个问题是我是否应该存储 2 个列表。一份清单 讲座和一个教程列表，而不是 1 个会话列表？这是 因为会话列表对我没用，我必须循环 它每次都可以获取有关讲座和教程的信息。有没有 我缺少一种获取所有讲座对象的方法？

你自己回答了你的问题。
当您开始编写过于复杂/样板代码以使事情变得简单时，例如迭代您刚刚添加的对象列表时，这表明您应该退后一步并重新设计事物。

通过介绍Enrolment.addSession(Session session)， 你引入了一个不受欢迎的抽象：

public class Enrolment {

    private List<Session> sessions;

    public Enrolment() {
        this.sessions = new ArrayList<>();
    }

    public addSession(Session session) {
        this.sessions.add(session);
    }
}

您不想从Enrolment 的角度统一处理Lecture 和Tutorial，所以不要将它们合并到同一个List 中，因为它们依赖于相同的接口（@ 987654327@).
必须在需要时使用抽象，而不是系统地使用抽象，因为这是可能的。
你不是在 List 中添加所有对象，因为所有对象都是 Object 吗？没有。

而不是从 API 方法和它的实现创建这种区别：

public class Enrolment {

    private List<Conference> conferences = new ArrayList<>();
    private List<Tutorial> tutorials = new ArrayList<>();


    public addConference(Conference conference) {
        this.conferences.add(conference);
    }

    public addTutorial(Tutorial tutorial) {
        this.tutorials.add(tutorial);
    }
}

并使用它：

Lecture morningLec = new Lecture(900, "Dr. Mike");
newEnrolment.addLecture(morningLec);

Tutorial afternoonTut = new Tutorial(1400, "John Smith", 3);
newEnrolment.addTutorial(afternoonTut);

---

请注意，您可能会遇到这样一种情况，即您需要统一处理 Tutorial 和 Lecture 以进行某些处理，但对于其他处理则需要区分它们。
在这种情况下，你有一些常用的方法：

• instanceOf ：易于使用但也容易使代码变脆。例如，稍后您可以在 Session 层次结构中添加一个新的子类，并且在不知道的情况下，该子类的实例可能会在某些处理中包含或排除，而编译器不会警告您。

• 提供一个抽象方法，该方法返回一个布尔值或枚举值来传达对象的性质（例如：isLecture()）。比instanceOf 更健壮，因为编译器限制您重写该方法，但如果添加多个子类并且过滤器不仅在Lecture 上，而且在Lecture 和另一种类型上，它也可能导致容易出错的代码。因此，在过滤条件保持简单的情况下，我会喜欢这种方式。

• 定义三个列表：一个用于讲座，另一个用于会议，另一个包含所有这些应统一处理的列表。更复杂的方式，但也更健壮的方式。我只支持过滤条件复杂/变化的情况。