Java多类型方法参数？

Question

我想知道是否可以要求 java 方法参数是有限类型集中的任何类型。例如 - 我正在使用一个库，其中两个（或更多）类型具有公共方法，但它们在类型层次结构中的最低共同祖先是 Object。我的意思是：

   public interface A {
      void myMethod();
   }

   public interface B {
      void myMethod();
   }
...
   public void useMyMethod(A a) {
      // code duplication
   }

   public void useMyMethod(B b) {
      // code duplication
   }

我想避免代码重复。我想到的是这样的：

   public void useMyMethod(A|B obj){
      obj.myMethod();
   }

java 中已经有类似的语法类型。例如：

  try{
     //fail
  } catch (IllegalArgumentException | IllegalStateException e){
     // use e safely here
  }

显然这是不可能的。如何使用这种不可编辑的类型层次结构来实现设计良好的代码？

Answer 1

将函数作为参数传递给你的 useMyMethod 函数怎么样？

如果您使用的是 Java

public interface A {
    void myMethod();
}

public interface B {
    void myMethod();
}

public void useMyMethod(Callable<Void> myMethod) {
    try {
        myMethod.call();
    } catch(Exception e) {
        // handle exception of callable interface
    }
}

//Use

public void test() {
    interfaceA a = new ClassImplementingA();
    useMyMethod(new Callable<Void>() {
        public call() {
            a.myMethod();
            return null;
        }
    });

    interfaceB b = new ClassImplementingB();
    useMyMethod(new Callable<Void>() {
        public call() {
            b.myMethod();
            return null;
        }
    });
}

对于 Java >= 8，您可以使用 Lambda Expressions：

public interface IMyMethod {
    void myMethod();
}

public void useMyMethod(IMyMethod theMethod) {
    theMethod.myMethod();
}

//Use

public void test() {
    interfaceA a = new ClassImplementingA();
    useMyMethod(() -> a.myMethod());

    interfaceB b = new ClassImplementingB();
    useMyMethod(() -> b.myMethod());
}

Answer 2

尝试使用Adapter 设计模式。

或者，如果可能，添加一些基本接口：

public interface Base {
    void myMethod();
}

public interface A extends Base {}
public interface B extends Base {}
...
public void useMyMethod(Base b) {
    b.myMethod()
}

另外，你可以使用类似于this的东西

Answer 3

您可以使用单个方法myMethod 编写interface MyInterface。然后，对于您想作为有限集的一部分考虑的每种类型，编写一个包装类，如下所示：

class Wrapper1 implements MyInterface {

    private final Type1 type1;

    Wrapper1(Type1 type1) {
        this.type1 = type1;
    }

    @Override
    public void myMethod() {
        type1.method1();
    }
}

那么您只需要使用MyInterface 而不是有限类型集合中的一个，并且始终会调用来自适当类型的适当方法。

请注意，要实际使用这些包装类来调用方法myMethod，您必须编写

myMethod(new Wrapper1(type1));

这会变得有点难看，因为您必须记住集合中每种类型的包装类的名称。出于这个原因，您可能更愿意将MyInterface 替换为一个抽象类，该类具有几个生成包装器类型的静态工厂。像这样：

abstract class MyWrapper {

    static MyWrapper of(Type1 type1) {
        return new Wrapper1(type1);
    }

    static MyWrapper of(Type2 type2) {
        return new Wrapper2(type2);
    }

    abstract void myMethod();
}

然后就可以使用代码调用方法了

myMethod(MyWrapper.of(type1));

这种方法的优点是无论你使用哪种类型，代码都是相同的。如果使用这种方法，则必须将 Wrapper1 声明中的 implements MyInterface 替换为 extends MyWrapper。

Answer 4

好吧，为您的需求建模的正确方法是在 A 和 B 都扩展的超类型接口 C 中声明 myMethod()；然后，您的方法接受类型 C 作为其参数。在您描述的情况下，您无法执行此操作这一事实表明您没有以实际反映它们行为方式的方式对类层次结构进行建模。

当然，如果你不能改变接口结构，那么你总是可以用反射来做的。

public static void useMyMethod(Object classAorB) throws Exception {
    classAorB.getClass().getMethod("myMethod").invoke(classAorB);
}

Answer 5

这可能不构成最佳实践，但您能否创建一个新类（称为 C），其中包含 A 和 B 中重复的部分，并创建一个采用 C 的新方法，让您的方法拿 A 和 B 做一个 C 实例并调用新方法？

这样你就有了

class C {
    // Stuff from both A and B
}

public void useMyMethod(A a) {
    // Make a C
    useMyMethod(c);
}

public void useMyMethod(B b) {
    // Make a C
    useMyMethod(c);
}

public void useMyMethod(C c) {
    // previously duplicated code
}

这还可以让您在 A 和 B 的方法中保留任何不重复的代码（如果有的话）。

Answer 6

这在我看来很像模板模式：

public interface A {

    void myMethod();
}

public interface B {

    void myMethod();
}

public class C {

    private abstract class AorBCaller {

        abstract void myMethod();

    }

    public void useMyMethod(A a) {
        commonAndUseMyMethod(new AorBCaller() {

            @Override
            void myMethod() {
                a.myMethod();
            }
        });
    }

    public void useMyMethod(B b) {
        commonAndUseMyMethod(new AorBCaller() {

            @Override
            void myMethod() {
                b.myMethod();
            }
        });
    }

    private void commonAndUseMyMethod(AorBCaller aOrB) {
        // ... Loads of stuff.
        aOrB.myMethod();
        // ... Loads more stuff
    }
}

在 Java 8 中它更加简洁：

public class C {

    // Expose an "A" form of the method.
    public void useMyMethod(A a) {
        commonAndUseMyMethod(() -> a.myMethod());
    }

    // And a "B" form.
    public void useMyMethod(B b) {
        commonAndUseMyMethod(() -> b.myMethod());
    }

    private void commonAndUseMyMethod(Runnable aOrB) {
        // ... Loads of stuff -- no longer duplicated.
        aOrB.run();
        // ... Loads more stuff
    }
}

Answer 7

动态代理可用于在您定义的通用接口和实现其他接口的对象之间建立桥梁，这些接口符合新接口。然后，您可以让您的useMyMethods 将参数转换为新接口（作为动态代理），并让您的通用代码仅根据新接口编写。

这将是新界面：

interface Common {
  void myMethod();
}

然后，使用此调用处理程序：

class ForwardInvocationHandler implements InvocationHandler {
  private final Object wrapped;
  public ForwardInvocationHandler(Object wrapped) {
    this.wrapped = wrapped;
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args)
      throws Throwable {
    Method match = wrapped.getClass().getMethod(method.getName(), method.getParameterTypes());
    return match.invoke(wrapped, args);
  }
}

你可以有这样的方法：

public void useMyMethod(A a) {
  useMyMethod(toCommon(a));
}

public void useMyMethod(B b) {
  useMyMethod(toCommon(b));
}

public void useMyMethod(Common common) {
  // ...
}

private Common toCommon(Object o) {
  return (Common)Proxy.newProxyInstance(
    Common.class.getClassLoader(), 
    new Class[] { Common.class }, 
    new ForwardInvocationHandler(o));   
}

请注意，为简化问题，您甚至可以选择现有接口之一（A 或 B）作为通用接口。

（看看另一个例子here，以及围绕这个主题的其他想法）

Answer 8

正确的方法是使用 Java 泛型。

见http://docs.oracle.com/javase/tutorial/java/generics/bounded.html