Java setara dengan metode ekstensi C #

Saya mencari untuk mengimplementasikan fungsionalitas dalam daftar objek seperti yang saya lakukan di C # menggunakan metode ekstensi.

Sesuatu seperti ini:

List<DataObject> list;
// ... List initialization.
list.getData(id);

Bagaimana saya melakukannya di Jawa?

Java tidak mendukung metode ekstensi.

Sebagai gantinya, Anda dapat membuat metode statis biasa, atau menulis kelas Anda sendiri.

Metode penyuluhan bukan hanya metode statis dan bukan hanya kenyamanan sintaksis gula, pada kenyataannya mereka adalah alat yang sangat kuat. Hal utama yang ada adalah kemampuan untuk mengganti metode yang berbeda berdasarkan instantiasi parameter generik yang berbeda. Ini mirip dengan kelas tipe Haskell, dan pada kenyataannya, sepertinya mereka berada di C # untuk mendukung Monad C # (yaitu LINQ). Bahkan menjatuhkan sintaks LINQ, saya masih tidak tahu cara untuk mengimplementasikan antarmuka serupa di Jawa.

Dan saya rasa tidak mungkin untuk mengimplementasikannya di Jawa, karena semantik tipe generik dari parameter generik.

Project Lombok menyediakan anotasi @ExtensionMethodyang dapat digunakan untuk mencapai fungsionalitas yang Anda minta.

Secara teknis C # Extension tidak memiliki padanan di Java. Tetapi jika Anda ingin mengimplementasikan fungsi-fungsi tersebut untuk kode yang lebih bersih dan pemeliharaan, Anda harus menggunakan kerangka kerja Manifold.

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

Bahasa XTend - yang merupakan set super Java, dan mengkompilasi ke kode sumber Java ¹  - mendukung ini.

Manifold memberi Java metode ekstensi gaya C # dan beberapa fitur lainnya. Tidak seperti alat lain, Manifold tidak memiliki batasan dan tidak menderita masalah dengan generik, lambdas, IDE dll. Manifold menyediakan beberapa fitur lain seperti tipe kustom gaya-F , antarmuka struktural gaya-TypeScript , dan tipe ekspansi gaya Javascript .

Selain itu, IntelliJ menyediakan dukungan komprehensif untuk Manifold melalui plugin Manifold .

Manifold adalah proyek sumber terbuka yang tersedia di github .

Pilihan lain adalah dengan menggunakan kelas ForwardingXXX dari perpustakaan google-jambu.

Java tidak memiliki fitur seperti itu. Alih-alih, Anda bisa membuat subkelas reguler dari implementasi daftar atau membuat kelas dalam anonim:

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

Masalahnya adalah memanggil metode ini. Anda dapat melakukannya "di tempat":

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

Sepertinya ada beberapa kemungkinan kecil bahwa Metode Defender (metode standar yaitu) mungkin membuatnya menjadi Java 8. Namun, sejauh yang saya memahami mereka, mereka hanya memungkinkan penulis dariinterface surut memperpanjang, tidak pengguna sewenang-wenang.

Metode Defender + Injeksi Antarmuka akan dapat sepenuhnya menerapkan metode ekstensi gaya C #, tetapi AFAICS, Antarmuka Antarmuka bahkan belum ada di peta jalan Java 8.

Agak terlambat ke pesta tentang pertanyaan ini, tetapi kalau-kalau ada yang merasa berguna saya baru saja membuat subkelas:

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

Kita dapat mensimulasikan implementasi metode ekstensi C # di Java dengan menggunakan implementasi metode default yang tersedia sejak Java 8. Kita mulai dengan mendefinisikan antarmuka yang akan memungkinkan kita untuk mengakses objek dukungan melalui metode base (), seperti:

public interface Extension<T> {

    default T base() {
        return null;
    }
}

Kami mengembalikan nol karena antarmuka tidak dapat memiliki keadaan, tetapi ini harus diperbaiki nanti melalui proxy.

Pengembang ekstensi harus memperluas antarmuka ini dengan antarmuka baru yang berisi metode ekstensi. Katakanlah kita ingin menambahkan konsumen forEach pada antarmuka Daftar:

public interface ListExtension<T> extends Extension<List<T>> {

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

}

Karena kami memperluas antarmuka Ekstensi, kami dapat memanggil metode base () di dalam metode ekstensi kami untuk mengakses objek dukungan yang kami lampirkan.

Antarmuka Ekstensi harus memiliki metode pabrik yang akan membuat ekstensi objek dukungan yang diberikan:

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

Kami membuat proksi yang mengimplementasikan antarmuka ekstensi dan semua antarmuka yang diterapkan oleh jenis objek dukungan. Penangan doa yang diberikan kepada proxy akan mengirimkan semua panggilan ke objek dukungan, kecuali untuk metode "basis", yang harus mengembalikan objek dukungan, jika tidak, implementasi defaultnya adalah mengembalikan nol:

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

}

Kemudian, kita bisa menggunakan metode Extension.create () untuk melampirkan antarmuka yang berisi metode ekstensi ke objek dukungan. Hasilnya adalah sebuah objek yang dapat dilemparkan ke antarmuka ekstensi dimana kita masih dapat mengakses objek dukungan yang memanggil metode base (). Setelah referensi dilemparkan ke antarmuka ekstensi, kita sekarang dapat memanggil metode ekstensi dengan aman yang dapat memiliki akses ke objek dukungan, sehingga sekarang kita dapat melampirkan metode baru ke objek yang ada, tetapi tidak dengan jenis definisi:

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

}

Jadi, ini adalah cara kita dapat mensimulasikan kemampuan untuk memperluas objek di Jawa dengan menambahkan kontrak baru kepada mereka, yang memungkinkan kita untuk memanggil metode tambahan pada objek yang diberikan.

Di bawah ini Anda dapat menemukan kode antarmuka Ekstensi:

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

}

Seseorang dapat menggunakan pola desain berorientasi objek dekorator . Contoh dari pola ini yang digunakan di pustaka standar Java adalah DataOutputStream .

Berikut beberapa kode untuk menambah fungsionalitas Daftar:

public class ListDecorator<E> implements List<E>
{
    public final List<E> wrapee;

    public ListDecorator(List<E> wrapee)
    {
        this.wrapee = wrapee;
    }

    // implementation of all the list's methods here...

    public <R> ListDecorator<R> map(Transform<E,R> transformer)
    {
        ArrayList<R> result = new ArrayList<R>(size());
        for (E element : this)
        {
            R transformed = transformer.transform(element);
            result.add(transformed);
        }
        return new ListDecorator<R>(result);
    }
}

PS Saya penggemar berat Kotlin . Ini memiliki metode ekstensi dan juga berjalan di JVM.

Anda dapat membuat metode ekstensi / pembantu C # like dengan (RE) mengimplementasikan antarmuka Collections dan menambahkan- contoh untuk Java Collection:

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() + 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 += 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 += 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 || _list.size() == 0;
}

Java8 sekarang mendukung metode standar , yang mirip dengan C#metode ekstensi.