1

我有两个类 A 和 B。A 有一个方法，比如说 foo，它可以有任意数量的任意类型的参数。该方法将这些参数中继到具有预定数量的预定类型的参数的方法。

Class A{
   foo(<?> ... params){
      (new B()).bar(params);
   }
} 

Class B{
   bar(int a, int b){
       Log.v("The params passed are "+a+" and "+b);
   }
}

Class Caller{

    callingMethod(){
        (new A()).foo(1, 2);
    }
}

我知道编译器不允许我为 foo 写下的签名；我写它只是为了解释我想要实现的目标。

我不想在 B 类的 bar(int, int) 中进行任何转换。

4

4 回答 4

2

您可以使用可变参数...

public static void foo(Object... parameters ){

}
于 2012-09-18T13:48:26.003 回答
1

您可以添加有限数量的参数，这些参数在可变参数之前是固定的。这是在EnumSet

我已更改为foo接受 3 个参数的方法，以E e1, E e2, E... params确保我有至少 2 个参数来调用bar(e1, e2)方法。

<E extends Number>确保您可以传递Number Integer恰好是一个的任何子类。

static class A {
    <E extends Number> void foo(E e1, E e2, E... params) {
        (new B<E>()).bar(e1, e2);
    }
}

static class B<E extends Number> {
    public void bar(E a, E b) {

    }
}

public static void main(String[] args) {

    A name = new A();
    name.foo(1, 2, 123);
}
于 2012-09-18T13:47:31.537 回答
1

正如其他人所建议的那样，您可以接受可变数量的Objects 作为函数参数。棘手的一点是打开包装以调用bar. B我已经整理了一个示例，说明如何使用反射来做到这一点：

import java.lang.reflect.Method;

public class test {
  static class A {
    private final Class cl;
    A(Class cl) { 
      this.cl = cl;
    }
    void foo(Object ... params) throws Exception {
      Object obj = cl.newInstance();
      for (Method m : cl.getMethods()) {
        if (m.getName().equals("bar")) {
          try {
            m.invoke(obj, params);
            return;
          }
          catch(IllegalArgumentException ex) {} // try next overload
        }
      }
      throw new IllegalArgumentException();
    }
  }

  static class B {
    public void bar() {
      System.out.println("Got nothing");
    }

    public void bar(double a, double b) {
      System.out.println("Got doubles");
    }

    public void bar(int a, int b) {
      System.out.println("Got: " + a + " and " + b);
    }
  }

  public static void main(String argv[]) throws Exception {
    new A(B.class).foo(1,2);
    new A(B.class).foo();
    new B().bar(1,2);
    new A(B.class).foo("Hello");
  }
}

但是您会注意到，这里的重载解决方案远非完美，并且传入1,2调用. 要解决这个问题，您需要通过与给定的每个对象的最佳匹配来对对象数组进行排序，但据我所知，这远非微不足道。double,doublebarMethodClass

于 2012-09-18T14:22:16.077 回答
0

Java中的可变参数：

foo(Object... objs) {}

例子：

public static void main(String... args) {}

相当于

public static void main(String[] args) {}

注意：只要方法签名中没有剩余参数，就相当于使用数组。

于 2012-09-18T13:57:33.077 回答