La relation entre les génériques Java et la métaprogrammation

Les génériques et la métaprogrammation sont des outils puissants en Java pour créer du code flexible et réutilisable : les génériques permettent l'utilisation de types paramétrés, améliorent la sécurité des types et éliminent le besoin de types primitifs. La métaprogrammation manipule le code par réflexion afin qu'il puisse déterminer des informations génériques et implémenter des abstractions au moment de l'exécution. En pratique, génériques et métaprogrammation peuvent être combinés pour créer des méthodes de filtrage génériques sans qu’il soit nécessaire de créer du code spécifique pour chaque situation.

La relation entre les génériques et la métaprogrammation en Java

Les génériques et la métaprogrammation sont des outils puissants en Java qui aident les développeurs à créer un code plus flexible et réutilisable.

Generics

Les génériques permettent aux développeurs de créer des classes, des interfaces et des méthodes à l'aide de types paramétrés qui peuvent être utilisés avec n'importe quel type de données. Cela élimine le besoin de types primitifs (tels que Object) et améliore la sécurité des types.

Par exemple, une Liste générique :

public class CustomList<T> {
    private List<T> items;
    
    public void addItem(T item) {
        items.add(item);
    }
}

Cette Liste peut être utilisée pour stocker tout type d'objet sans préciser de type spécifique.

Métaprogrammation

La métaprogrammation est la capacité de manipuler du code ou un programme au moment de l'exécution. Reflection en Java permet aux développeurs d'inspecter et de modifier les informations sur les classes, les méthodes et les champs.

Par exemple, nous pouvons utiliser la réflexion pour obtenir les paramètres de type de la classe CustomList :

Class<CustomList<String>> listClass = CustomList.class;
TypeVariable<?>[] typeParams = listClass.getTypeParameters();
System.out.println(typeParams[0].getName()); // 输出 "T"

Relations

Les génériques et la métaprogrammation sont étroitement liés car les informations génériques sont disponibles en métaprogrammation. Les développeurs peuvent atteindre des niveaux d'abstraction plus élevés en tirant parti de la réflexion pour déterminer dynamiquement les paramètres génériques.

Par exemple, nous pouvons utiliser la réflexion pour créer une instance CustomList avec un paramètre de type d'un type spécifique :

CustomList<String> stringList =
        (CustomList<String>) listClass.getDeclaredConstructor().newInstance();

Un cas pratique

Montrons maintenant un cas pratique utilisant des génériques et de la métaprogrammation. Supposons que nous ayons une interface qui définit une méthode filter qui filtre une collection et renvoie une nouvelle collection : filter方法，用于过滤一个集合并返回新集合：

public interface Filter<T> {
    boolean test(T item);
}

我们可以使用泛型和元编程来创建通用的filter

public static <T> List<T> filter(List<T> items, Filter<T> filter) {
    List<T> filteredItems = new ArrayList<>();
    for (T item : items) {
        if (filter.test(item)) {
            filteredItems.add(item);
        }
    }
    return filteredItems;
}

List<Integer> numbers = filter(Arrays.asList(1, 2, 3, 4, 5),
        item -> item % 2 == 0);

List<String> strings = filter(Arrays.asList("apple", "banana", "cherry"),
        item -> item.startsWith("b"));

rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!