blocks|key|42303|text|尝试使用Adapter设计模式。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|42304|或者，如果可能的话，添加一些基本接口：|42305|public+interface+Base+{
++++void+myMethod();
}

public+interface+A+extends+Base+{}
public+interface+B+extends+Base+{}
...
public+void+useMyMethod(Base+b)+{
++++b.myMethod()
}|code-block|syntax|javascript|42306|此外，您还可以使用类似于this的内容|42307|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Adapter_pattern|1|https://stackoverflow.com/a/26039044/1047723^0|4|7|0|0|0|0|C|4|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

Try using <a href="http://en.wikipedia.org/wiki/Adapter_pattern" rel="nofollow noreferrer">Adapter</a> design pattern.

Or, if it's possible, add some base interface:

<pre><code>public interface Base {
 void myMethod();
}

public interface A extends Base {}
public interface B extends Base {}
...
public void useMyMethod(Base b) {
 b.myMethod()
}
</code></pre>

Also, you can use something similar to <a href="https://stackoverflow.com/a/26039044/1047723">this</a>

blocks|key|4549192|text|您可以使用单个方法myMethod编写一个interface+MyInterface。然后，对于要考虑作为有限集的一部分的每种类型，编写一个包装类，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4549193|class+Wrapper1+implements+MyInterface+{

++++private+final+Type1+type1;

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

++++@Override
++++public+void+myMethod()+{
++++++++type1.method1();
++++}
}|code-block|syntax|javascript|4549194|然后，您只需要使用MyInterface，而不是有限类型集中的一个，并且将始终调用来自适当类型的适当方法。|4549195|请注意，要实际使用这些包装类来调用方法myMethod，您必须编写|4549196|myMethod(new+Wrapper1(type1));|4549197|这将变得有点难看，因为您必须记住集合中每个类型的包装器类的名称。因此，您可能更喜欢将MyInterface替换为具有多个静态工厂的抽象类，这些工厂生成包装器类型。如下所示：|4549198|abstract+class+MyWrapper+{

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

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

++++abstract+void+myMethod();
}|4549199|然后，您可以使用以下代码调用该方法|4549200|myMethod(MyWrapper.of(type1));|4549201|这种方法的优点是，无论您使用哪种类型，代码都是相同的。如果使用这种方法，则必须将Wrapper1声明中的implements+MyInterface替换为extends+MyWrapper。|4549202|entityMap^0|9|8|L|9|V|B|0|0|9|B|0|J|8|0|0|16|B|0|0|0|0|14|8|1G|M|25|H|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|S|3|T|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1L|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|1M|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|10|3|-4|5|6|7|1U|8|@]|D|@]|E|$]]]|11|$]]

You could write an <code>interface</code> <code>MyInterface</code> with a single method <code>myMethod</code>. Then, for each type you want to consider as part of the finite set, write a wrapper class, like this:

<pre><code>class Wrapper1 implements MyInterface {

 private final Type1 type1;

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

 @Override
 public void myMethod() {
 type1.method1();
 }
}
</code></pre>

Then you just need to use a <code>MyInterface</code> rather than one of the finite set of types, and the appropriate method from the appropriate type will always get called.

Note that to actually use these wrapper classes to call the method <code>myMethod</code> you would have to write 

<pre><code>myMethod(new Wrapper1(type1));
</code></pre>

This is going to get a bit ugly as you are going to have to remember the name of the wrapper class for each type in the set. For this reason, you may prefer to replace <code>MyInterface</code>with an abstract class with several static factories that produce the wrapper types. Like this:

<pre><code>abstract class MyWrapper {

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

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

 abstract void myMethod();
}
</code></pre>

then you can call the method using the code 

<pre><code>myMethod(MyWrapper.of(type1));
</code></pre>

The advantage of this approach is that the code is the same no matter which type you use. If you use this approach you have to replace <code>implements MyInterface</code> in the <code>Wrapper1</code> declaration with <code>extends MyWrapper</code>.

blocks|key|42393|text|对需求建模的正确方法是在A和B都扩展的超类型接口C中声明myMethod()；然后您的方法接受类型C作为其参数。在您描述的情况下，您很难做到这一点，这一事实表明您没有以一种实际反映它们行为的方式对类层次结构进行建模。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|42394|当然，如果你不能改变界面结构，那么你总是可以用反射来改变。|42395|public+static+void+useMyMethod(Object+classAorB)+throws+Exception+{
++++classAorB.getClass().getMethod("myMethod").invoke(classAorB);
}|code-block|syntax|javascript|42396|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Well, the correct way to model your requirement would be to have myMethod() declared in a supertype interface C which both A and B extend; your method then accepts type C as its parameter. The fact that you have trouble doing this in the situation you describe indicates you are not modelling the class hierarchy in a way that actually reflects how they behave.

Of course, if you can't change the interface structure then you could always do it with reflections.

<pre><code>public static void useMyMethod(Object classAorB) throws Exception {
 classAorB.getClass().getMethod("myMethod").invoke(classAorB);
}
</code></pre>

blocks|key|42456|text|正确的方法是使用Java泛型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|42457|请参阅http://docs.oracle.com/javase/tutorial/java/generics/bounded.html|offset|length|42458|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/tutorial/java/generics/bounded.html^0|0|3|1T|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

The correct way is to use Java Generics. 

See <a href="http://docs.oracle.com/javase/tutorial/java/generics/bounded.html" rel="nofollow">http://docs.oracle.com/javase/tutorial/java/generics/bounded.html</a>

blocks|key|42537|text|如何将函数作为参数传递给useMyMethod函数？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|42538|如果您正在使用Java+<+8：|42539|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;
++++++++}
++++});
}|code-block|syntax|javascript|42540|对于Java+>=+8，可以使用Lambda+Expressions|offset|length|42541|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());
}|42542|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html^0|0|0|0|G|I|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@$K|10|L|11|1|12]]|A|$]]|$1|M|3|N|5|F|7|13|8|@]|9|@]|A|$G|H]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

What about passing the function as a parameter to your useMyMethod function?

If you are using Java &lt; 8:

<pre><code>public interface A {
 void myMethod();
}

public interface B {
 void myMethod();
}

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

//Use

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

 interfaceB b = new ClassImplementingB();
 useMyMethod(new Callable&lt;Void&gt;() {
 public call() {
 b.myMethod();
 return null;
 }
 });
}
</code></pre>

For Java >= 8, you could use <a href="https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html" rel="nofollow">Lambda Expressions</a>:

<pre><code>public interface IMyMethod {
 void myMethod();
}

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

//Use

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

 interfaceB b = new ClassImplementingB();
 useMyMethod(() -&gt; b.myMethod());
}
</code></pre>

blocks|key|42555|text|在我看来，这很像模板模式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|42556|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
++++}
}|code-block|syntax|javascript|42557|在Java+8中，它要简洁得多：|42558|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
++++}
}|42559|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This looks to me much like the template pattern:

<pre><code>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
 }
}
</code></pre>

In Java 8 it is much more succinct:

<pre><code>public class C {

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

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

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

blocks|key|42584|text|这可能不是最佳实践，但您是否可以创建一个新类(称为C)，其中包含A和B中复制的部分，并创建一个采用C的新方法，让您的采用A和B的方法创建一个C实例并调用新方法？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|42585|这样你就有了|42586|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
}|code-block|syntax|javascript|42587|这还可以让您在A和B的方法中保留任何非重复的代码(如果有)。|42588|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This might not constitute a best practice, but could you make a new class (call it C), that contains the parts from A and B that are duplicated, and the make a new method that takes C, have your methods that take A and B make a C instance and call the new method?

So that you have 

<pre><code>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
}
</code></pre>

That would also let you keep any non duplicated code in the methods for A and B (if there is any).

I wonder if it is possible to require that a java method parameter is of any type from finite set of types. For example - I am using a library where two (or more) types have common methods, but their lowest common ancestor in the type hierarchy is Object. What I mean here:

<pre><code> public interface A {
 void myMethod();
 }

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

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

I want to avoid the code duplication. What I think of is something like this:

<pre><code> public void useMyMethod(A|B obj){
 obj.myMethod();
 }
</code></pre>

There is similar type of syntax in java already. For example:

<pre><code> try{
 //fail
 } catch (IllegalArgumentException | IllegalStateException e){
 // use e safely here
 }
</code></pre>

Obviously this is not possible. How can I achieve well designed code using such type of uneditable type hierarchy ?

Java multi-type method parameter?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想知道是否可以要求java方法参数是有限类型集中的任何类型。例如，我正在使用一个库，其中有两个(或更多)类型具有公共方法，但它们在类型层次结构中的最低公共祖先是Object。我这里的意思是：   public interface A {      void myMethod();   }   public inter...

问Java多类型方法参数？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java多类型方法参数？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java多类型方法参数？
EN