blocks|key|1072314|text|Java不支持扩展方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1072315|相反，您可以创建一个常规的静态方法，或者编写您自己的类。|1072316|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Java does not support extension methods.

Instead, you can make a regular static method, or write your own class.

blocks|key|857893|text|扩展方法不仅仅是静态方法，也不仅仅是方便的语法糖，事实上它们是非常强大的工具。主要是能够基于不同泛型的参数实例化覆盖不同的方法。这类似于Haskell的类型类，事实上，它们看起来像是在C#中支持C#的Monads+(即LINQ)。即使去掉LINQ语法，我仍然不知道在Java中实现类似接口的任何方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|857894|而且我认为不可能在Java中实现它们，因为Java对泛型参数的类型擦除语义。|857895|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Extension methods are not just static method and not just convenience syntax sugar, in fact they are quite powerful tool. The main thing there is ability to override different methods based on different generic’s parameters instantiation. This is similar to Haskell’s type classes, and in fact, it looks like they are in C# to support C#’s Monads (i.e. LINQ). Even dropping LINQ syntax, I still don’t know any way to implement similar interfaces in Java. 

And I don’t think it is possible to implement them in Java, because of Java’s type erasure semantics of generics parameters.

blocks|key|857928|text|Project+Lombok提供了一个注释@ExtensionMethod，可用于实现您所要求的功能。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|857929|entityMap|0|LINK|mutability|MUTABLE|url|https://projectlombok.org/|1|https://projectlombok.org/features/experimental/ExtensionMethod.html^0|L|G|0|E|0|L|G|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]|$9|V|A|W|1|X]]|E|$]]|$1|F|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

<a href="https://projectlombok.org" rel="noreferrer">Project Lombok</a> provides an annotation <a href="https://projectlombok.org/features/experimental/ExtensionMethod.html" rel="noreferrer"><code>@ExtensionMethod</code></a> that can be used to achieve the functionality you are asking for.

blocks|key|1072650|text|从技术上讲，C#扩展在Java语言中没有等价物。但是，如果你确实想实现这样的功能，以获得更干净的代码和可维护性，你就必须使用Manifold框架。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1072651|package+extensions.java.lang.String;

import+manifold.ext.api.*;

@Extension
public+class+MyStringExtension+{

++public+static+void+print(@This+String+thiz)+{
++++System.out.println(thiz);
++}

++@Extension
++public+static+String+lineSeparator()+{
++++return+System.lineSeparator();
++}
}|code-block|syntax|javascript|1072652|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Technically C# Extension have no equivalent in Java. But if you do want to implement such functions for a cleaner code and maintainability, you have to use Manifold framework.

<pre><code>package extensions.java.lang.String;

import manifold.ext.api.*;

@Extension
public class MyStringExtension {

 public static void print(@This String thiz) {
 System.out.println(thiz);
 }

 @Extension
 public static String lineSeparator() {
 return System.lineSeparator();
 }
}
</code></pre>

blocks|key|858004|text|Manifold提供了C#风格的extension+methods和其他几个特性。与其他工具不同，Manifold没有限制，也不会从泛型、lambda、集成开发环境等问题中进行suffer。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|858005|此外，IntelliJ通过流形plugin为流形提供了全面的支持。|858006|流形是一个可在github上使用的开源项目。|858007|entityMap|0|LINK|mutability|MUTABLE|url|http://manifold.systems/|1|http://manifold.systems/docs.html#the-extension-manifold|2|https://github.com/rzwitserloot/lombok/issues/921|3|http://manifold.systems/docs.html#working-with-intellij|4|https://github.com/manifold-systems/manifold^0|0|8|0|G|H|1|2G|6|2|0|F|6|3|0|7|6|4|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]|$A|11|B|12|1|13]|$A|14|B|15|1|16]]|C|$]]|$1|D|3|E|5|6|7|17|8|@]|9|@$A|18|B|19|1|1A]]|C|$]]|$1|F|3|G|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|H|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]|T|$5|K|L|M|C|$N|U]]|V|$5|K|L|M|C|$N|W]]]]

<a href="http://manifold.systems/" rel="noreferrer">Manifold</a> provides Java with C#-style <a href="http://manifold.systems/docs.html#the-extension-manifold" rel="noreferrer">extension methods</a> and several other features. Unlike other tools, Manifold has no limitations and does not <a href="https://github.com/rzwitserloot/lombok/issues/921" rel="noreferrer">suffer</a> from issues with generics, lambdas, IDE etc. Manifold provides several other features such as F#-style <a href="http://manifold.systems/docs.html#type-manifolds" rel="noreferrer">custom types</a>, TypeScript-style <a href="http://manifold.systems/docs.html#structural-interfaces" rel="noreferrer">structural interfaces</a>, and Javascript-style <a href="http://manifold.systems/docs.html#dynamic-typing-with-icallhandler" rel="noreferrer">expando types</a>.

Additionally, IntelliJ provides comprehensive support for Manifold via the Manifold <a href="http://manifold.systems/docs.html#working-with-intellij" rel="noreferrer">plugin</a>.

Manifold is an open source project available on <a href="https://github.com/manifold-systems/manifold" rel="noreferrer">github</a>.

blocks|key|857809|text|另一种选择是使用google-guava库中的ForwardingXXX类。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|857810|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/google/guava/wiki/CollectionHelpersExplained#forwarding-decorators^0|N|D|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]]]]

Another option is to use <a href="https://github.com/google/guava/wiki/CollectionHelpersExplained#forwarding-decorators" rel="nofollow noreferrer">ForwardingXXX</a> classes from google-guava library.

blocks|key|857788|text|Java没有这样的特性。相反，您可以创建列表实现的常规子类，也可以创建匿名内部类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|857789|List<String>+list+=+new+ArrayList<String>()+{
+++public+String+getData()+{
+++++++return+"";+//+add+your+implementation+here.+
+++}
};|code-block|syntax|javascript|857790|问题是调用这个方法。你可以“就地”完成：|857791|new+ArrayList<String>()+{
+++public+String+getData()+{
+++++++return+"";+//+add+your+implementation+here.+
+++}
}.getData();|857792|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|$]]

Java does not have such feature. 
Instead you can either create regular subclass of your list implementation or create anonymous inner class:

<pre><code>List&lt;String&gt; list = new ArrayList&lt;String&gt;() {
 public String getData() {
 return ""; // add your implementation here. 
 }
};
</code></pre>

The problem is to call this method. You can do it "in place":

<pre><code>new ArrayList&lt;String&gt;() {
 public String getData() {
 return ""; // add your implementation here. 
 }
}.getData();
</code></pre>

blocks|key|857855|text|在这个问题上有点晚了，但如果有人发现它很有用，我刚刚创建了一个子类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|857856|public+class+ArrayList2<T>+extends+ArrayList<T>+
{
++++private+static+final+long+serialVersionUID+=+1L;

++++public+T+getLast()
++++{
++++++++if+(this.isEmpty())
++++++++{
++++++++++++return+null;
++++++++}
++++++++else
++++++++{+++++++
++++++++++++return+this.get(this.size()+-+1);
++++++++}
++++}
}|code-block|syntax|javascript|857857|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Bit late to the party on this question, but in case anyone finds it useful I just created a subclass:

<pre><code>public class ArrayList2&lt;T&gt; extends ArrayList&lt;T&gt; 
{
 private static final long serialVersionUID = 1L;

 public T getLast()
 {
 if (this.isEmpty())
 {
 return null;
 }
 else
 { 
 return this.get(this.size() - 1);
 }
 }
}
</code></pre>

blocks|key|858177|text|我们可以通过使用自Java8以来可用的默认方法实现来模拟C#扩展方法的实现。我们首先定义一个接口，该接口允许我们通过一个base()方法访问支持对象，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|858178|public+interface+Extension<T>+{

++++default+T+base()+{
++++++++return+null;
++++}
}|code-block|syntax|javascript|858179|我们返回null，因为接口不能有状态，但这必须在以后通过代理来解决。|858180|扩展的开发人员必须通过包含扩展方法的新接口来扩展此接口。假设我们想要在List接口上添加一个forEach消费者：|858181|public+interface+ListExtension<T>+extends+Extension<List<T>>+{

++++default+void+foreach(Consumer<T>+consumer)+{
++++++++for+(T+item+:+base())+{
++++++++++++consumer.accept(item);
++++++++}
++++}

}|858182|因为我们扩展了扩展接口，所以我们可以在扩展方法中调用base()方法来访问我们附加的支持对象。|858183|扩展接口必须有一个工厂方法，该方法将创建给定支持对象的扩展：|858184|public+interface+Extension<T>+{

++++...

++++static+<E+extends+Extension<T>,+T>+E+create(Class<E>+type,+T+instance)+{
++++++++if+(type.isInterface())+{
++++++++++++ExtensionHandler<T>+handler+=+new+ExtensionHandler<T>(instance);
++++++++++++List<Class<?>>+interfaces+=+new+ArrayList<Class<?>>();
++++++++++++interfaces.add(type);
++++++++++++Class<?>+baseType+=+type.getSuperclass();
++++++++++++while+(baseType+!=+null+&&+baseType.isInterface())+{
++++++++++++++++interfaces.add(baseType);
++++++++++++++++baseType+=+baseType.getSuperclass();
++++++++++++}
++++++++++++Object+proxy+=+Proxy.newProxyInstance(
++++++++++++++++++++Extension.class.getClassLoader(),
++++++++++++++++++++interfaces.toArray(new+Class<?>[interfaces.size()]),
++++++++++++++++++++handler);
++++++++++++return+type.cast(proxy);
++++++++}+else+{
++++++++++++return+null;
++++++++}
++++}
}|858185|我们创建一个代理来实现扩展接口和由支持对象的类型实现的所有接口。指定给代理的调用处理程序会将所有调用分派给支持对象，但"base“方法除外，该方法必须返回支持对象，否则其默认实现为返回null：|858186|public+class+ExtensionHandler<T>+implements+InvocationHandler+{

++++private+T+instance;

++++private+ExtensionHandler(T+instance)+{
++++++++this.instance+=+instance;
++++}

++++@Override
++++public+Object+invoke(Object+proxy,+Method+method,+Object[]+args)
++++++++++++throws+Throwable+{
++++++++if+("base".equals(method.getName())
++++++++++++++++&&+method.getParameterCount()+==+0)+{
++++++++++++return+instance;
++++++++}+else+{
++++++++++++Class<?>+type+=+method.getDeclaringClass();
++++++++++++MethodHandles.Lookup+lookup+=+MethodHandles.lookup()
++++++++++++++++.in(type);
++++++++++++Field+allowedModesField+=+lookup.getClass().getDeclaredField("allowedModes");
++++++++++++makeFieldModifiable(allowedModesField);
++++++++++++allowedModesField.set(lookup,+-1);
++++++++++++return+lookup
++++++++++++++++.unreflectSpecial(method,+type)
++++++++++++++++.bindTo(proxy)
++++++++++++++++.invokeWithArguments(args);
++++++++}
++++}

++++private+static+void+makeFieldModifiable(Field+field)+throws+Exception+{
++++++++field.setAccessible(true);
++++++++Field+modifiersField+=+Field.class.getDeclaredField("modifiers");
++++++++modifiersField.setAccessible(true);
++++++++modifiersField
++++++++++++++++.setInt(field,+field.getModifiers()+&+~Modifier.FINAL);
++++}

}|858187|然后，我们可以使用Extension.create()方法将包含扩展方法的接口附加到支持对象。结果是一个可以强制转换到扩展接口的对象，通过它我们仍然可以访问调用base()方法的支持对象。有了对扩展接口的引用，我们现在可以安全地调用可以访问支持对象的扩展方法，这样我们就可以将新方法附加到现有对象，但不能附加到其定义类型：|858188|public+class+Program+{

++++public+static+void+main(String[]+args)+{
++++++++List<String>+list+=+Arrays.asList("a",+"b",+"c");
++++++++ListExtension<String>+listExtension+=+Extension.create(ListExtension.class,+list);
++++++++listExtension.foreach(System.out::println);
++++}

}|858189|因此，这是一种我们可以通过向Java中的对象添加新的约定来模拟扩展对象的能力的方法，这允许我们在给定的对象上调用其他方法。|858190|下面你可以找到扩展接口的代码：|858191|import+java.lang.reflect.Field;
import+java.lang.reflect.InvocationHandler;
import+java.lang.reflect.Method;
import+java.lang.reflect.Modifier;
import+java.lang.reflect.Proxy;
import+java.util.ArrayList;
import+java.util.List;

public+interface+Extension<T>+{

++++public+class+ExtensionHandler<T>+implements+InvocationHandler+{

++++++++private+T+instance;

++++++++private+ExtensionHandler(T+instance)+{
++++++++++++this.instance+=+instance;
++++++++}

++++++++@Override
++++++++public+Object+invoke(Object+proxy,+Method+method,+Object[]+args)
++++++++++++++++throws+Throwable+{
++++++++++++if+("base".equals(method.getName())
++++++++++++++++++++&&+method.getParameterCount()+==+0)+{
++++++++++++++++return+instance;
++++++++++++}+else+{
++++++++++++++++Class<?>+type+=+method.getDeclaringClass();
++++++++++++++++MethodHandles.Lookup+lookup+=+MethodHandles.lookup()
++++++++++++++++++++.in(type);
++++++++++++++++Field+allowedModesField+=+lookup.getClass().getDeclaredField("allowedModes");
++++++++++++++++makeFieldModifiable(allowedModesField);
++++++++++++++++allowedModesField.set(lookup,+-1);
++++++++++++++++return+lookup
++++++++++++++++++++.unreflectSpecial(method,+type)
++++++++++++++++++++.bindTo(proxy)
++++++++++++++++++++.invokeWithArguments(args);
++++++++++++}
++++++++}

++++++++private+static+void+makeFieldModifiable(Field+field)+throws+Exception+{
++++++++++++field.setAccessible(true);
++++++++++++Field+modifiersField+=+Field.class.getDeclaredField("modifiers");
++++++++++++modifiersField.setAccessible(true);
++++++++++++modifiersField.setInt(field,+field.getModifiers()+&+~Modifier.FINAL);
++++++++}

++++}

++++default+T+base()+{
++++++++return+null;
++++}

++++static+<E+extends+Extension<T>,+T>+E+create(Class<E>+type,+T+instance)+{
++++++++if+(type.isInterface())+{
++++++++++++ExtensionHandler<T>+handler+=+new+ExtensionHandler<T>(instance);
++++++++++++List<Class<?>>+interfaces+=+new+ArrayList<Class<?>>();
++++++++++++interfaces.add(type);
++++++++++++Class<?>+baseType+=+type.getSuperclass();
++++++++++++while+(baseType+!=+null+&&+baseType.isInterface())+{
++++++++++++++++interfaces.add(baseType);
++++++++++++++++baseType+=+baseType.getSuperclass();
++++++++++++}
++++++++++++Object+proxy+=+Proxy.newProxyInstance(
++++++++++++++++++++Extension.class.getClassLoader(),
++++++++++++++++++++interfaces.toArray(new+Class<?>[interfaces.size()]),
++++++++++++++++++++handler);
++++++++++++return+type.cast(proxy);
++++++++}+else+{
++++++++++++return+null;
++++++++}
++++}

}|858192|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1A|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1K|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1L|8|@]|9|@]|A|$]]|$1|14|3|15|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|16|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|17|$]]

We can simulate the implementation of C# extension methods in Java by using the default method implementation available since Java 8.
We start by defining an interface that will allow us to access the support object via a base() method, like so:

<pre><code>public interface Extension&lt;T&gt; {

 default T base() {
 return null;
 }
}
</code></pre>

We return null since interfaces cannot have state, but this has to be fixed later via a proxy.

The developer of extensions would have to extend this interface by a new interface containing extension methods.
Let's say we want to add a forEach consumer on List interface:

<pre><code>public interface ListExtension&lt;T&gt; extends Extension&lt;List&lt;T&gt;&gt; {

 default void foreach(Consumer&lt;T&gt; consumer) {
 for (T item : base()) {
 consumer.accept(item);
 }
 }

}
</code></pre>

Because we extend the Extension interface, we can call base() method inside our extension method to access the support object we attach to.

The Extension interface must have a factory method which will create an extension of a given support object:

<pre><code>public interface Extension&lt;T&gt; {

 ...

 static &lt;E extends Extension&lt;T&gt;, T&gt; E create(Class&lt;E&gt; type, T instance) {
 if (type.isInterface()) {
 ExtensionHandler&lt;T&gt; handler = new ExtensionHandler&lt;T&gt;(instance);
 List&lt;Class&lt;?&gt;&gt; interfaces = new ArrayList&lt;Class&lt;?&gt;&gt;();
 interfaces.add(type);
 Class&lt;?&gt; baseType = type.getSuperclass();
 while (baseType != null &amp;&amp; baseType.isInterface()) {
 interfaces.add(baseType);
 baseType = baseType.getSuperclass();
 }
 Object proxy = Proxy.newProxyInstance(
 Extension.class.getClassLoader(),
 interfaces.toArray(new Class&lt;?&gt;[interfaces.size()]),
 handler);
 return type.cast(proxy);
 } else {
 return null;
 }
 }
}
</code></pre>

We create a proxy that implements the extension interface and all the interface implemented by the type of the support object.
The invocation handler given to the proxy would dispatch all the calls to the support object, except for the "base" method, which must return the support object, otherwise its default implementation is returning null:

<pre><code>public class ExtensionHandler&lt;T&gt; implements InvocationHandler {

 private T instance;

 private ExtensionHandler(T instance) {
 this.instance = instance;
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
 throws Throwable {
 if ("base".equals(method.getName())
 &amp;&amp; method.getParameterCount() == 0) {
 return instance;
 } else {
 Class&lt;?&gt; type = method.getDeclaringClass();
 MethodHandles.Lookup lookup = MethodHandles.lookup()
 .in(type);
 Field allowedModesField = lookup.getClass().getDeclaredField("allowedModes");
 makeFieldModifiable(allowedModesField);
 allowedModesField.set(lookup, -1);
 return lookup
 .unreflectSpecial(method, type)
 .bindTo(proxy)
 .invokeWithArguments(args);
 }
 }

 private static void makeFieldModifiable(Field field) throws Exception {
 field.setAccessible(true);
 Field modifiersField = Field.class.getDeclaredField("modifiers");
 modifiersField.setAccessible(true);
 modifiersField
 .setInt(field, field.getModifiers() &amp; ~Modifier.FINAL);
 }

}
</code></pre>

Then, we can use the Extension.create() method to attach the interface containing the extension method to the support object.
The result is an object which can be casted to the extension interface by which we can still access the support object calling the base() method.
Having the reference casted to the extension interface, we now can safely call the extension methods that can have access to the support object, so that now we can attach new methods to the existing object, but not to its defining type:

<pre><code>public class Program {

 public static void main(String[] args) {
 List&lt;String&gt; list = Arrays.asList("a", "b", "c");
 ListExtension&lt;String&gt; listExtension = Extension.create(ListExtension.class, list);
 listExtension.foreach(System.out::println);
 }

}
</code></pre>

So, this is a way we can simulate the ability to extend objects in Java by adding new contracts to them, which allow us to call additional methods on the given objects.

Below you may find the code of the Extension interface:

<pre><code>import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

public interface Extension&lt;T&gt; {

 public class ExtensionHandler&lt;T&gt; implements InvocationHandler {

 private T instance;

 private ExtensionHandler(T instance) {
 this.instance = instance;
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
 throws Throwable {
 if ("base".equals(method.getName())
 &amp;&amp; method.getParameterCount() == 0) {
 return instance;
 } else {
 Class&lt;?&gt; type = method.getDeclaringClass();
 MethodHandles.Lookup lookup = MethodHandles.lookup()
 .in(type);
 Field allowedModesField = lookup.getClass().getDeclaredField("allowedModes");
 makeFieldModifiable(allowedModesField);
 allowedModesField.set(lookup, -1);
 return lookup
 .unreflectSpecial(method, type)
 .bindTo(proxy)
 .invokeWithArguments(args);
 }
 }

 private static void makeFieldModifiable(Field field) throws Exception {
 field.setAccessible(true);
 Field modifiersField = Field.class.getDeclaredField("modifiers");
 modifiersField.setAccessible(true);
 modifiersField.setInt(field, field.getModifiers() &amp; ~Modifier.FINAL);
 }

 }

 default T base() {
 return null;
 }

 static &lt;E extends Extension&lt;T&gt;, T&gt; E create(Class&lt;E&gt; type, T instance) {
 if (type.isInterface()) {
 ExtensionHandler&lt;T&gt; handler = new ExtensionHandler&lt;T&gt;(instance);
 List&lt;Class&lt;?&gt;&gt; interfaces = new ArrayList&lt;Class&lt;?&gt;&gt;();
 interfaces.add(type);
 Class&lt;?&gt; baseType = type.getSuperclass();
 while (baseType != null &amp;&amp; baseType.isInterface()) {
 interfaces.add(baseType);
 baseType = baseType.getSuperclass();
 }
 Object proxy = Proxy.newProxyInstance(
 Extension.class.getClassLoader(),
 interfaces.toArray(new Class&lt;?&gt;[interfaces.size()]),
 handler);
 return type.cast(proxy);
 } else {
 return null;
 }
 }

}
</code></pre>

blocks|key|1072776|text|您可以通过(RE)实现Collections接口并添加-+example+for+Java+Collection来创建一个类似C#的扩展/助手方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1072777|public+class+RockCollection<T+extends+Comparable<T>>+implements+Collection<T>+{
private+Collection<T>+_list+=+new+ArrayList<T>();

//###########Custom+extension+methods###########

public+T+doSomething()+{
++++//do+some+stuff
++++return+_list++
}

//proper+examples
public+T+find(Predicate<T>+predicate)+{
++++return+_list.stream()
++++++++++++.filter(predicate)
++++++++++++.findFirst()
++++++++++++.get();
}

public+List<T>+findAll(Predicate<T>+predicate)+{
++++return+_list.stream()
++++++++++++.filter(predicate)
++++++++++++.collect(Collectors.<T>toList());
}

public+String+join(String+joiner)+{
++++StringBuilder+aggregate+=+new+StringBuilder("");
++++_list.forEach(+item+->
++++++++aggregate.append(item.toString()+%2B+joiner)
++++);
++++return+aggregate.toString().substring(0,+aggregate.length()+-+1);
}

public+List<T>+reverse()+{
++++List<T>+listToReverse+=+(List<T>)_list;
++++Collections.reverse(listToReverse);
++++return+listToReverse;
}

public+List<T>+sort(Comparator<T>+sortComparer)+{
++++List<T>+listToReverse+=+(List<T>)_list;
++++Collections.sort(listToReverse,+sortComparer);
++++return+listToReverse;
}

public+int+sum()+{
++++List<T>+list+=+(List<T>)_list;
++++int+total+=+0;
++++for+(T+aList+:+list)+{
++++++++total+%2B=+Integer.parseInt(aList.toString());
++++}
++++return+total;
}

public+List<T>+minus(RockCollection<T>+listToMinus)+{
++++List<T>+list+=+(List<T>)_list;
++++int+total+=+0;
++++listToMinus.forEach(list::remove);
++++return+list;
}

public+Double+average()+{
++++List<T>+list+=+(List<T>)_list;
++++Double+total+=+0.0;
++++for+(T+aList+:+list)+{
++++++++total+%2B=+Double.parseDouble(aList.toString());
++++}
++++return+total+/+list.size();
}

public+T+first()+{
++++return+_list.stream().findFirst().get();
++++++++++++//.collect(Collectors.<T>toList());
}
public+T+last()+{
++++List<T>+list+=+(List<T>)_list;
++++return+list.get(_list.size()+-+1);
}
//##############################################
//Re-implement+existing+methods
@Override
public+int+size()+{
++++return+_list.size();
}

@Override
public+boolean+isEmpty()+{
++++return+_list+==+null+%7C%7C+_list.size()+==+0;
}|code-block|syntax|javascript|1072778|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can create a C# like extension/helper method by (RE) implementing the Collections interface and adding- example for Java Collection:

<pre><code>public class RockCollection&lt;T extends Comparable&lt;T&gt;&gt; implements Collection&lt;T&gt; {
private Collection&lt;T&gt; _list = new ArrayList&lt;T&gt;();

//###########Custom extension methods###########

public T doSomething() {
 //do some stuff
 return _list 
}

//proper examples
public T find(Predicate&lt;T&gt; predicate) {
 return _list.stream()
 .filter(predicate)
 .findFirst()
 .get();
}

public List&lt;T&gt; findAll(Predicate&lt;T&gt; predicate) {
 return _list.stream()
 .filter(predicate)
 .collect(Collectors.&lt;T&gt;toList());
}

public String join(String joiner) {
 StringBuilder aggregate = new StringBuilder("");
 _list.forEach( item -&gt;
 aggregate.append(item.toString() + joiner)
 );
 return aggregate.toString().substring(0, aggregate.length() - 1);
}

public List&lt;T&gt; reverse() {
 List&lt;T&gt; listToReverse = (List&lt;T&gt;)_list;
 Collections.reverse(listToReverse);
 return listToReverse;
}

public List&lt;T&gt; sort(Comparator&lt;T&gt; sortComparer) {
 List&lt;T&gt; listToReverse = (List&lt;T&gt;)_list;
 Collections.sort(listToReverse, sortComparer);
 return listToReverse;
}

public int sum() {
 List&lt;T&gt; list = (List&lt;T&gt;)_list;
 int total = 0;
 for (T aList : list) {
 total += Integer.parseInt(aList.toString());
 }
 return total;
}

public List&lt;T&gt; minus(RockCollection&lt;T&gt; listToMinus) {
 List&lt;T&gt; list = (List&lt;T&gt;)_list;
 int total = 0;
 listToMinus.forEach(list::remove);
 return list;
}

public Double average() {
 List&lt;T&gt; list = (List&lt;T&gt;)_list;
 Double total = 0.0;
 for (T aList : list) {
 total += Double.parseDouble(aList.toString());
 }
 return total / list.size();
}

public T first() {
 return _list.stream().findFirst().get();
 //.collect(Collectors.&lt;T&gt;toList());
}
public T last() {
 List&lt;T&gt; list = (List&lt;T&gt;)_list;
 return list.get(_list.size() - 1);
}
//##############################################
//Re-implement existing methods
@Override
public int size() {
 return _list.size();
}

@Override
public boolean isEmpty() {
 return _list == null || _list.size() == 0;
}
</code></pre>

I am looking to implement a functionality in a list of object as I would in C# using an extension method.

Something like this:

<pre><code>List&lt;DataObject&gt; list;
// ... List initialization.
list.getData(id);
</code></pre>

How do I do that in Java?

Java equivalent to C# extension methods

集成开发环境

Java

我希望在对象列表中实现一个功能，就像我在C#中使用扩展方法一样。如下所示：List<DataObject> list;// ... List initialization.list.getData(id);我如何在Java中做到这一点？

问与C#扩展方法等效的Java
EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问与C#扩展方法等效的JavaEN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问与C#扩展方法等效的Java
EN