Параметр метода нескольких типов Java?

Вы можете написать interface MyInterface одним методом myMethod. Затем для каждого типа, который вы хотите рассматривать как часть конечного набора, напишите класс-оболочку, например:

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));

Преимущество этого подхода заключается в том, что код остается неизменным независимо от того, какой тип вы используете. Если вы используете этот подход, вам нужно заменить implements MyInterface в объявлении Wrapper1 на extends MyWrapper.

А как насчет передачи функции в качестве параметра вашей функции useMyMethod?

Если вы используете Java ‹8:

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 вы можете использовать лямбда-выражения:

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());
}

Попробуйте использовать шаблон проектирования Адаптер.

Или, если возможно, добавьте базовый интерфейс:

public interface Base {
    void myMethod();
}

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

Кроме того, вы можете использовать что-то похожее на это

Что ж, правильный способ смоделировать ваше требование - объявить myMethod () в интерфейсе супертипа C, который расширяется как A, так и B; затем ваш метод принимает тип C в качестве параметра. Тот факт, что у вас возникли проблемы с выполнением этого в описанной вами ситуации, указывает на то, что вы не моделируете иерархию классов таким образом, который фактически отражает их поведение.

Конечно, если вы не можете изменить структуру интерфейса, вы всегда можете сделать это с помощью отражений.

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

Возможно, это не лучшая практика, но не могли бы вы создать новый класс (назовите его 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 (если он есть).

Мне это очень похоже на шаблон шаблона:

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
    }
}

Динамический прокси-сервер можно использовать для создания моста между общим интерфейсом, который вы определяете, и объектами, реализующими другие интерфейсы, которые соответствуют новому интерфейсу. Затем вы можете сделать так, чтобы ваши 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), который будет использоваться в качестве общего интерфейса.

(См. Другой пример здесь, а также другие идеи по этой теме)

Правильный способ - использовать Java Generics.

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