Java 在OOP中如何按参数顺序调用方法？

假设我有四个类A、B、C和容器

我有以下对象，如何通过只向容器类添加代码来实现以下输出

“con”对象的第一个调用应该与第一个参数对应

您的答复将不胜感激

A  a = new A();    
B  b = new B();    
C  c = new C();

Container  con = new Container(a,b,c);

con.calling();
con.calling();
con.calling();

预期产出为：

calling from A
calling from B
calling from C

---

---

我将添加一个变量以考虑调用方法执行的时间，这可能是容器类：

class Container {

    int times = 0;

    A objectA;
    B objectB;
    C objectC;


    public Container(A a, B b, C c) {
        this.objectA = a;
        this.objectB = b;
        this.objectC = c;
    }

    public void Calling(){
        if(this.times==0){
            a.callA();
        }
        if(this.times==1){
            b.callB();
        }
        if(this.times==2){
            c.callC();
        }
        this.times++;
    }
}

---

我将添加一个变量以考虑调用方法执行的时间，这可能是容器类：

class Container {

    int times = 0;

    A objectA;
    B objectB;
    C objectC;


    public Container(A a, B b, C c) {
        this.objectA = a;
        this.objectB = b;
        this.objectC = c;
    }

    public void Calling(){
        if(this.times==0){
            a.callA();
        }
        if(this.times==1){
            b.callB();
        }
        if(this.times==2){
            c.callC();
        }
        this.times++;
    }
}

---

看起来非常类似于

Iterator

pattern/interface。这里不是

调用（）

方法，而是

next（）

我可以给你画个草图，比如：

import java.util.Arrays;
import java.util.Iterator;

public class Container implements Iterator {

    private Iterator<?> iter;

    public Container(Object ...values) {
        this.iter = Arrays.asList(values).iterator();
    }

    @Override
    public boolean hasNext() {
        return iter.hasNext();
    }

    @Override
    public Object next() {
        return iter.next();
    }
}

以及测试这些内容的示例代码：

Container container = new Container(new A()::callA, new B()::callB, new C()::callC);

container.next();
container.next();
container.next();

---

在这种情况下，它不仅会返回下一个实例，还将调用所需的方法。

看起来与

迭代器

模式/接口非常相似。这里不是

调用（）

方法，而是

next（）

我可以给你画个草图，比如：

import java.util.Arrays;
import java.util.Iterator;

public class Container implements Iterator {

    private Iterator<?> iter;

    public Container(Object ...values) {
        this.iter = Arrays.asList(values).iterator();
    }

    @Override
    public boolean hasNext() {
        return iter.hasNext();
    }

    @Override
    public Object next() {
        return iter.next();
    }
}

以及测试这些内容的示例代码：

Container container = new Container(new A()::callA, new B()::callB, new C()::callC);

container.next();
container.next();
container.next();

---

在这种情况下，它不仅会返回下一个实例，还会调用所需的方法。

这似乎令人困惑。你为什么想要这个？你是说你想在1,4,7次内给A打电话。。B 2,5,8。。像这样。通过执行此con.calling（）；有一次，我们可以做到这一点。这是可能的，但不是我所说的好主意。我想你把别的话题和这个混淆了。最好是制作三个

容器

s，并在每个容器中放置一个对象。然后

calling（）

只调用内部对象。（编辑：或者可能是Prasath所说的）让A、B和C实现一些公共接口。让容器获取该接口的实例，并将它们放入Deque中。然后在

calling（）

中，从该deque轮询并调用该接口上定义的方法。这似乎令人困惑。你为什么想要这个？你是说你想在1,4,7次内给A打电话。。B 2,5,8。。像这样。通过执行此con.calling（）；有一次，我们可以做到这一点。这是可能的，但不是我所说的好主意。我想你把别的话题和这个混淆了。最好是制作三个

容器

s，并在每个容器中放置一个对象。然后

calling（）

只调用内部对象。（编辑：或者可能是Prasath所说的）让A、B和C实现一些公共接口。让容器获取该接口的实例，并将它们放入Deque中。然后在

calling（）

中，从该deque轮询并调用该接口上定义的方法。迭代列表也是一个好主意。OP的想法不是那么多。你应该使用一个非原始迭代器：

迭代器

或者类似的。为什么我应该，你能解释一下吗？因为原始类型是不好的。编译器警告您不要这样做，“不要在新代码中使用原始类型”是Java的一般规则。约书亚·布洛赫（C.f.Joshua Bloch）的高效Java。迭代列表也是一个好主意。OP的想法不是那么多。你应该使用一个非原始迭代器：

迭代器

或者类似的。为什么我应该，你能解释一下吗？因为原始类型是不好的。编译器警告您不要这样做，“不要在新代码中使用原始类型”是Java的一般规则。约书亚·布洛赫的有效Java。