存储Java中不同类型对象的有序列表的最佳方法是什么？

我有几个用于创建对象的类。这些对象都有必须根据插入顺序运行的代码

它们需要按顺序存储，并按存储顺序调用

对象A

对象B

对象A

对象A

对象C

对象D

我不确定在Java中处理这个问题的正确方法是否是一个通用列表并在运行时检查键入

List<Object> list = new ArrayList<Object>();

List List=new ArrayList（）；

我还考虑过将每种对象类型存储在它们自己的类型化列表中，父对象按照正确的顺序从列表中读取。然而，这似乎比在运行时检查对象类型更复杂

List<Object> list = new ArrayList<Object>();

---

什么是正确的“Java”处理方法？

如果对象不共享一个共同的祖先：

这些类没有关联。他们没有共同的祖先

然后，您可以创建另一个类作为以下对象的包装器：

类型为

T

的对象

一个

使用者

对象，用作对需要调用的代码的引用

例如：

    class Invocable<T> {
        private final T target;
        private final Consumer<T> invocation;

        public Invocable(T target, Consumer<T> invocation) {
            this.target = target;
            this.invocation = invocation;
        }

        public void runInvocation() {
            invocation.accept(target);
        }
    }

---

希望这有帮助。

这些对象是否实现了一个公共接口？他们能吗？确定吗？要使所有类实现公共接口或扩展公共超类，请定义公共

call（）

方法。然后创建一个列表，对其进行迭代，并对每个列表调用

.call（）

。这就是多态性的全部原理。@JBNizet这个

调用

方法会做什么，什么行为？它会做OP所说的“需要按照存储顺序[…]调用它们”。@JBNizet接口如何管理这个功能？你能在这里大致概括一下你的逻辑吗？

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class RunnableList {

    private List<Invocable<?>> invocables = new ArrayList<Invocable<?>>();

    public <T> void add(T target, Consumer<T> invocation) {
        invocables.add(new Invocable<T>(target, invocation));
    }

    public void run() {
        invocables.forEach(Invocable::runInvocation);
    }

    static class Invocable<T> {
        private final T target;
        private final Consumer<T> invocation;

        public Invocable(T target, Consumer<T> invocation) {
            this.target = target;
            this.invocation = invocation;
        }

        public void runInvocation() {
            invocation.accept(target);
        }
    }

    // TEST

    public static void main(String[] args) {
        RunnableList runnableList = new RunnableList();
        runnableList.add(new ClassA(), o -> o.run1("hello from A1"));
        runnableList.add(new ClassB(), o -> o.run1("hello from B1"));
        runnableList.add(new ClassC(), o -> o.run1("hello from C1"));

        runnableList.add(new ClassA(), ClassA::run2);
        runnableList.add(new ClassB(), ClassB::run2);
        runnableList.add(new ClassC(), ClassC::run2);
        runnableList.run();
    }

    static class ClassA {
        public void run1(String msg) {
            System.out.println("A.run1: " + msg);
        }
        public void run2() { System.out.println("A.run2"); }
    }
    static class ClassB {
        public void run1(String msg) {
            System.out.println("B.run1: " + msg);
        }
        public void run2() { System.out.println("B.run2"); }
    }
    static class ClassC {
        public void run1(String msg) {
            System.out.println("C.run1: " + msg);
        }
        public void run2() { System.out.println("C.run2"); }
    }
}