将实例数组视为单个实例

Question

在 Java 中，我正在寻找一个通用模板，它意味着给定类型的数组（比如Foo），将允许对数组进行实例方法调用。在幕后，这将转化为遍历数组中的所有 Foo 实例，并在每个实例上调用实例方法。

也许一些代码会更好地证明这一点：

public class Foo{

   public Foo(){}

   public void Method1(){}

}

所以你有：

Foo foo = new Foo();
foo.Method1();

但是您能否为您的自定义类型制作一些通用模板，从而使这种事情成为可能：

Foo[] foos = new Foo[]{new Foo(),new Foo(), new Foo()};
foos.Method1();

这本质上是语法糖：

foreach(Foo f : foos){
  f.Method1();
}

我的动机是有人可以这样使用可变参数：

someHelper(fooInstance1,fooInstance2).Method1()

其中someHelper() 返回Foo[]。

如果每个Method1() 调用都返回一个值，那么将其包装到一个返回值数组中会更好（其中ReturnVals.size == Foos.size）。

在最坏的情况下，我必须为我需要处理的每种类型编写一个单独的类来实现这一点，可能使用接口来描述适用于单个实例和实例数组的功能。

是否有任何 Java 魔法、设计模式或通用拼图游戏可以优雅地实现这一目标？

此外，如果没有，是否有任何语言在本质上促进了这一点？

我很欣赏它并不适用于所有场景，但我想这是由程序员自行决定的。

非常感谢

Answer 1

您正在拨打Composite Pattern。您可以在项目 PerfectJPattern 中找到组件化的通用和可重用实现，确保签出与 GoF 书中示例匹配的 Composite documentation page 和 example。

示例相关部分的逐字副本，假设您有 IGraphic 接口和一些实现，例如矩形和直线，那么你可以这样做：

// build the composite
IComposite<IGraphic> myComposite = new Composite<IGraphic>(IGraphic.class);
myComposite.add(new Rectangle());                
myComposite.add(new Line());
myComposite.add(new Line());

// use the composite, invokes the IGraphic#draw() in the 
// underlying Rectangle and two Line instances
myComposite.getComponent().draw();

这就是它适用于您的具体情况的方式：

Foo fooInstance1 = new Foo();
Foo fooInstance2 = new Foo();
IComposite<Foo> myComposite = new Composite<Foo>(Foo.class);
myComposite.add(fooInstance1);    
myComposite.add(fooInstance2);    
// invokes Method1 on instance1 and instance2 transparently
myComposite.getComponent().Method1();

// alternatively do
Foo myCompositeFoo = myComposite.getComponent();
// pass this myCompositeFoo around and do
myCompositeFoo.Method1();

请注意，IComposite 可重用实现包含实际的复合，它不实现/提供Foo 接口，您必须通过getComponent 方法来获取它。这是一个小麻烦，它是必需的，因为在 Java 中没有其他方法可以创建实现任何任意和静态未知接口的事物的实例（在本例中为 Composite）。我能做的最好的就是给你一个Composite，它在下面为你构建一个真正的复合组件并返回你想要的接口类型Foo。这是使用动态代理实现的，但该实现是类型安全且完全组件化的，即您不必创建任何新的复合数组来实现您的接口。

Answer 2

你可以通过反射来做到这一点。

创建一个泛型类，它在运行时查看 T 的所有公共方法，并向自身注入具有相同签名的方法和一个循环其所有对象并在其上调用相同方法的主体。

这个问题是如何调用动态创建的方法。由于这只能通过反射实现，这意味着原始代码中的任何方法调用都必须通过反射完成。

Answer 3

有多种方法可以做到这一点，大多数使用包装对象等...... 但是，如果您想要的类型是接口，那么您很幸运，这实际上是可行的 使用dynamic proxies。

例如

public static void main(String[] args) throws IOException {
    B[] objs = {new B(), new B(), new B()};
    A oneForAll = createMulticastObject(objs, A.class);
    oneForAll.print();
}

@SuppressWarnings("unchecked")
public static <T, U extends T> T createMulticastObject(final U[] targets, Class<T> interfaceClass) {
    return (T) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[] {interfaceClass}, new InvocationHandler() {

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object ret = null;
            for (U target : targets) {
                ret = method.invoke(target, args);
            }
            return ret;
        }
    });
}


interface A {
    void print();
}

static class B implements A {
    @Override
    public void print() {
        System.out.println("Invoked.");
    }
}

明显的限制是A（即您将在多播方法调用中使用的对象类型必须是一个接口。

另一个明显的限制是多播对象只能从所有这些调用中返回一个返回值。

代码在一个地方可能看起来很难看，但是createMulticastObject 方法是一种可以用作实用方法的方法，而且A 和B 无论如何都已经编写好了。 所以dynamic proxies 将通常的包装器等减少为：

A oneForAll = createMulticastObject(objs, A.class);

Answer 4

查看apaches的CollectionUtils中的方法。您必须为要在列表中调用的每个方法实现一个接口。

例子：

CollectionUtils.collect(foos, new Transformer() {
    public Object transform(Object foo) {
        return ((Foo) foo).method();
    }
});

这里我使用了一个任意类，但你也可以在一个单独的类中实现 Transformer 并重用它。

我不知道是否存在带有泛型的版本。

还可以尝试一种函数式语言（scala、haskell、...）。他们使这类事情变得非常容易。

Answer 5

是否有任何 Java 魔法、设计模式或通用拼图游戏可以优雅地实现这一目标？

并非如此 - 并非没有大量样板，这意味着您自己编写该死循环的代码更少。

此外，如果没有，是否有任何语言在本质上促进了这一点？

大多数函数式语言都支持类似的东西。在 Scala 中，您可以使用foos.foreach(_.Method1())，其中foreach 是一种在所有元素上调用代码块的方法，下划线是当前元素的别名。可运行代码：http://ideone.com/QRtPlK

在 Java 8 中，您将能够使用集合的流视图以及方法引用来执行以下操作：

foos.stream().forEach(Foo::method1);