Java: différentes interfaces génériques

Question

I ont deux classes (A et B) avec des méthodes identiques (foo):

public class A { 
public String foo() { 
    return "A said foo"; 
} 
} 

public class B { 
public String foo() { 
    return "B said foo"; 
} 
} 

Je veux rendre la classe générique qui peut appeler cette méthode. Mais j'ai deux idées sur la façon de le faire dans l'exécution et ont pas des idées sur la compilation:

1. chèque type et coulé à A ou B.

2. méthode Get.

Mon exemple de générique qui appelle getMethod:

public class Template<T> { 
private T mT; 

public Template(T t) { 
    mT = t; 
} 

    public String bar() { 
    String result = "no result"; 
    try { 
     Method m = mT.getClass().getMethod("foo", null); 
    result = (String)m.invoke(mT); 
    } catch (Exception e) { 
    result = e.toString(); 
    e.printStackTrace(); 
    } 
    return result; 
    } 
} 

Y at-il une autre façon comment le faire? Je cherche quelque chose comme ceci:

public class Template<T extends A | B> { 
... 
} 

Notez que je ne suis pas un créateur de classes « A » et « B ».

Answer 1

Vous devez faire en sorte que les deux classes implémentent une interface commune déclarant la méthode foo. Java ne supporte pas ce que l'on appelle "le typage du canard" qui serait utile ici.

Answer 2

Vous pouvez probablement créer une classe ABAbstract en tant que type parent pour A et B. Vous pouvez utiliser cette classe en tant qu'argument, ou conserver Wildcard Generics et le transtyper en ABAbstract. Vous pouvez également laisser les deux classes A et B implémenter une interface déclarant la méthode foo. Ce serait probablement le moyen le plus facile de faire en sorte que votre compilation ne jette pas d'erreurs et se conforme exactement à ce que vous avez dit "vous cherchiez".

Mais I ou thinky dois écrire:

public class Template<T extends ABInterface> { 

mais je ne suis pas vraiment sûr de cela. Il pourrait aussi être implemenet altouth les classes ont besoin d'utiliser le mot clé implement.

Answer 3

Vous devrez créer une interface et laisser votre Template accepter n'importe quelle classe qui implémente l'interface.

interface Foo{ 
    public String foo(); 
} 

public class A implements Foo { 
    public String foo() { 
     return "A said foo"; 
    } 
} 

public class B implements Foo{ 
    public String foo() { 
     return "B said foo"; 
    } 
} 

public class Template<T extends Foo> { 
    private T mT; 

    public Template(T t) { 
     mT = t; 
    } 
    public String bar() { 
     return mT.foo(); 
    } 
}