blocks|key|4269853|text|Java被设计成不适合于鸭子类型。你可以选择的方式是反射：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4269854|public+void+doSomething(Object+obj)+throws+Exception+{

++++obj.getClass().getMethod("getName",+new+Class<?>[]+{}).invoke(obj);
}|code-block|syntax|javascript|4269855|但我主张使用动态语言，比如Groovy，这样做更有意义：|4269856|class+Duck+{
++++quack()+{+println+"I+am+a+Duck"+}
}

class+Frog+{
++++quack()+{+println+"I+am+a+Frog"+}
}

quackers+=+[+new+Duck(),+new+Frog()+]
for+(q+in+quackers)+{
++++q.quack()
}|4269857|Reference|offset|length|4269858|entityMap|0|LINK|mutability|MUTABLE|url|http://onestepback.org/articles/groovy/ducktyping.html^0|0|0|0|0|0|9|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Java is by design not fit for duck typing. The way you might choose to do it is reflection:

<pre><code>public void doSomething(Object obj) throws Exception {

 obj.getClass().getMethod("getName", new Class&lt;?&gt;[] {}).invoke(obj);
}
</code></pre>

But I would advocate doing it in a dynamic language, such as Groovy, where it makes more sense:

<pre><code>class Duck {
 quack() { println "I am a Duck" }
}

class Frog {
 quack() { println "I am a Frog" }
}

quackers = [ new Duck(), new Frog() ]
for (q in quackers) {
 q.quack()
}
</code></pre>

<a href="http://onestepback.org/articles/groovy/ducktyping.html" rel="noreferrer">Reference</a>

blocks|key|4270021|text|参见this+blog+post。它非常详细地描述了如何在Java中使用动态代理来实现鸭子类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4270022|总而言之：|4270023|4270024|通过键入|unordered-list-item|4270025|创建表示要使用的方法的接口|4270026|创建使用此接口的动态代理，以及通过反射(假设签名匹配)调用基础对象上的接口方法的实现对象|4270027|4270028|entityMap|0|LINK|mutability|MUTABLE|url|http://thinking-in-code.blogspot.com/2008/11/duck-typing-in-java-using-dynamic.html^0|2|E|0|0|0|0|0|0|0|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|-4|5|6|7|11|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|12|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|13|8|@]|9|@]|C|$]]|$1|L|3|M|5|I|7|14|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

See <a href="http://thinking-in-code.blogspot.com/2008/11/duck-typing-in-java-using-dynamic.html" rel="noreferrer">this blog post</a>. It gives a very detailed account of how to use dynamic proxies to implement duck typing in Java.

In summary:

<ul>
<li>create an interface that represents the methods you want to use via duck typing</li>
<li>create a dynamic proxy that uses this interface and an implementation object that invokes methods of the interface on the underlying object by reflection (assuming the signatures match)</li>
</ul>

blocks|key|4269823|text|check+this+library|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4269824|interface+MyInterface+{
++++void+foo();
++++int+bar(int+x,+int+y);
++++int+baz(int+x);
}

public+class+Delegate+{
++++public+int+bar()+{
++++++++return+42;
++++}
}

DuckPrxy+duckProxy+=+new+DuckPrxyImpl();
MyInterface+prxy+=+duckProxy.makeProxy(MyInterface.class,+new+Delegate());
prxy.bar(2,+3);+//+Will+return+42.|code-block|syntax|javascript|4269825|有了接口，使用Dynamic+Proxy就可以很容易地实现鸭子类型，你应该匹配方法名和返回类型。|4269826|entityMap|0|LINK|mutability|MUTABLE|url|http://mr-co.de/projects/duckprxy/|1|http://java.sun.com/j2se/1.4.2/docs/api/java/lang/reflect/Proxy.html^0|0|I|0|0|0|7|D|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

<a href="http://mr-co.de/projects/duckprxy/" rel="noreferrer">check this library</a>:

<pre><code>interface MyInterface {
 void foo();
 int bar(int x, int y);
 int baz(int x);
}

public class Delegate {
 public int bar() {
 return 42;
 }
}

DuckPrxy duckProxy = new DuckPrxyImpl();
MyInterface prxy = duckProxy.makeProxy(MyInterface.class, new Delegate());
prxy.bar(2, 3); // Will return 42.
</code></pre>

With an interface duck typing is simple using a <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/reflect/Proxy.html" rel="noreferrer">Dynamic Proxy</a>, you should match the method name and return type.

blocks|key|4269880|text|Java没有实现鸭子类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4269881|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Java doesn't implement duck typing.

blocks|key|88968|text|对于java+8，您有两种方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|88969|N:1:如果您只需要一种方法，请使用lambdas|88970|static+interface+Action+{+public+int+act();+}

public+int+forEachAct(List<Action>+actionlist)+{
+++int+total+=+0;
+++for+(Action+a+:+actionList)
+++++++total+%2B=+a.act();
}

public+void+example()+{
++++List<Action>+actionList+=+new+ArrayList<>();
++++String+example+=+"example";
++++actionList.add(example::length);
++++forEachAct(actionList);
}|code-block|syntax|javascript|88971|N:2:使用匿名类(在性能方面不是很好，但在一些非关键部分可以做到)|88972|static+interface+Action+{
++++public+int+act();
++++public+String+describe();
}

public+void+example()+{
++++List<Action>+actionList+=+new+ArrayList<>();
++++String+example+=+"example";

++++actionList.add(new+Action(){
++++++++public+int+act()+{+return+example.length();+}
++++++++public+String+describe()+{+return+"Action:+"+%2B+example;+}
++++});
}|88973|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

With java 8, you have 2 ways:

nº1: if you only need one method, use lambdas

<pre><code>static interface Action { public int act(); }

public int forEachAct(List&lt;Action&gt; actionlist) {
 int total = 0;
 for (Action a : actionList)
 total += a.act();
}

public void example() {
 List&lt;Action&gt; actionList = new ArrayList&lt;&gt;();
 String example = "example";
 actionList.add(example::length);
 forEachAct(actionList);
}
</code></pre>

nº2: Use anonymous classes (not very performance-wise, but in some non-critical parts it can be done)

<pre><code>static interface Action {
 public int act();
 public String describe();
}

public void example() {
 List&lt;Action&gt; actionList = new ArrayList&lt;&gt;();
 String example = "example";

 actionList.add(new Action(){
 public int act() { return example.length(); }
 public String describe() { return "Action: " + example; }
 });
}
</code></pre>

blocks|key|1389322|text|我已经编写了一个实用程序类来为对象动态创建装饰器。您可以将其用于鸭子类型：https://gist.github.com/stijnvanbael/5965616|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1389323|示例：|1389324|interface+Quacking+{
++++void+quack();
}

class+Duck+{
++++public+void+quack()+{+System.out.println("Quack!");+}
}

class+Frog+{
++++public+void+quack()+{+System.out.println("Ribbip!");+}
}

Quacking+duck+=+Extenter.extend(new+Duck()).as(Quacking.class);
Quacking+frog+=+Extenter.extend(new+Frog()).as(Quacking.class);

duck.quack();
frog.quack();|code-block|syntax|javascript|1389325|输出：|1389326|Quack!
Ribbip!|1389327|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/stijnvanbael/5965616^0|11|18|0|0|0|0|0|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|@]|C|$]]|$1|M|3|N|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

I've written a utility class to dynamically create decorators for an object. You could use it for duck typing:
<a href="https://gist.github.com/stijnvanbael/5965616" rel="nofollow noreferrer">https://gist.github.com/stijnvanbael/5965616</a>

Example:

<pre><code>interface Quacking {
 void quack();
}

class Duck {
 public void quack() { System.out.println("Quack!"); }
}

class Frog {
 public void quack() { System.out.println("Ribbip!"); }
}

Quacking duck = Extenter.extend(new Duck()).as(Quacking.class);
Quacking frog = Extenter.extend(new Frog()).as(Quacking.class);

duck.quack();
frog.quack();
</code></pre>

Output:

<pre><code>Quack!
Ribbip!
</code></pre>

blocks|key|1052604|text|Java中的类型是名义上的-兼容性是基于名称的。如果您需要有关Java中的鸭子类型(或结构类型)的示例，请查看此页面：http://whiteoak.sourceforge.net/#Examples，它提供了用Whiteoak编写的程序示例:Whiteoak是一种与Java兼容的语言，也支持结构类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1052605|entityMap|0|LINK|mutability|MUTABLE|url|http://whiteoak.sourceforge.net/#Examples^0|1N|15|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Typing in Java is nominal - compatibility is based on names. If you need an examples on how duck-typing (or structural typing) may look like in Java please look at this page: <a href="http://whiteoak.sourceforge.net/#Examples" rel="nofollow noreferrer">http://whiteoak.sourceforge.net/#Examples</a> which provides examples for program written in Whiteoak: A Java-compatible language that also supports structural typing.

blocks|key|4269969|text|通常，在动态类型的语言中会使用到鸭子类型。您可以在运行时检查是否存在满足需求所需的方法或属性，而不考虑继承层次结构。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4269970|除了使用反射，这将变得丑陋，你能得到的最接近的是通过使用最小的接口，匹配你需要的条件来进行鸭子类型。这个blog+post很好地描述了这个概念。它在很大程度上失去了python、ruby或javascript中鸭子类型的简单性，但如果您正在寻找高级别的可重用性，那么在Java中它实际上是一个很好的实践。|offset|length|4269971|entityMap|0|LINK|mutability|MUTABLE|url|http://rickyclarkson.blogspot.com/2006/07/duck-typing-in-java-and-no-reflection.html^0|0|1G|9|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]]]]

Typically, duck typing is used with dynamically typed languages. You would check at runtime for the existence of methods or properties that are required to fulfill your needs, regardless of inheritance hierarchies.

Other than using reflection, which would get ugly, the closest you can get is by using minimal interfaces that match the criteria of what you would need for duck typing. This <a href="http://rickyclarkson.blogspot.com/2006/07/duck-typing-in-java-and-no-reflection.html" rel="nofollow noreferrer">blog post</a> does a good job describing the concept. It loses much of the simplicity of duck typing in python or ruby or javascript, but its actually pretty good practice in Java if you're looking for a high level of reusability.

blocks|key|1052760|text|定义很好：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1052761|对象是多态的，与公共基类或接口无关。|offset|length|style|BOLD|1052762|Reference|1052763|entityMap|0|LINK|mutability|MUTABLE|url|http://onestepback.org/articles/groovy/ducktyping.html^0|0|0|I|0|0|9|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

Nice definition: 

Objects are polymorphic without being related by a common base class or interface.

<a href="http://onestepback.org/articles/groovy/ducktyping.html" rel="nofollow">Reference</a>

blocks|key|89026|text|聚会迟到了(和往常一样)，但我写了一个快速的类，因为我自己输入了一些鸭子。参见here。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|89027|它只会转到接口，但下面是一个使用示例：|89028|interface+Bird+{
++++void+fly();
}

interface+Duck+extends+Bird+{
++++void+quack();
}

class+PseudoDuck+{
++++void+fly()+{
++++++++System.out.println("Flying");
++++}

++++void+quack()+{
++++++++System.out.println("Quacking");
++++}
}

class+Tester+{
++++@Test
++++void+testDuckTyping()+{
++++++++final+Duck+duck
++++++++++++++++=+DuckTyper.duckType(new+PseudoDuck(),+Duck.class);
++++}
}|code-block|syntax|javascript|89029|支持默认的接口方法，参数，检查异常类型是否兼容，并将检查所有方法的伪鸭的类(包括私有)。不过，我还没有对泛型接口做任何测试。|89030|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/BeUndead/duck^0|13|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Late to the party (as usual), but I wrote a quick class for doing some duck typing myself. See <a href="https://github.com/BeUndead/duck" rel="nofollow noreferrer">here</a>.

It will only go to interfaces, but for a usage example:

<pre><code>interface Bird {
 void fly();
}

interface Duck extends Bird {
 void quack();
}

class PseudoDuck {
 void fly() {
 System.out.println("Flying");
 }

 void quack() {
 System.out.println("Quacking");
 }
}

class Tester {
 @Test
 void testDuckTyping() {
 final Duck duck
 = DuckTyper.duckType(new PseudoDuck(), Duck.class);
 }
}
</code></pre>

Supports default interface methods, parameters, checking Exception types are compatible and will check all methods of the PseudoDuck's class (including private). Haven't done any testing with generic interfaces yet though.

I just recently heard of duck typing and I read the <a href="http://en.wikipedia.org/wiki/Duck_typing" rel="noreferrer">Wikipedia article</a> about it, but I'm having a hard time translating the examples into Java, which would really help my understanding.

Would anyone be able to give a clear example of duck typing in Java and how I might possibly use it?

What's an example of duck typing in Java?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我最近刚刚听说过关于鸭子类型的文章，我也读过关于它的，但是我很难把例子翻译成Java，这真的会对我的理解有所帮助。有没有人能给出一个清晰的Java鸭子类型的例子，以及我可能如何使用它？

问在Java中，什么是鸭子类型的例子？
EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中，什么是鸭子类型的例子？EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中，什么是鸭子类型的例子？
EN