Quel impact la fonctionnalité de protection de type des génériques en Java a-t-elle sur le code ?

Utiliser des génériques pour masquer les différences de types

Dans le langage C++, il existe une fonction template (template) très utile, qui peut écrire une version universelle avec des types paramétrés, permettant la compilation Le processeur génère automatiquement versions spécifiques pour différents types. Dans le langage Java, il existe une fonction similaire appelée génériques. Lors de l'écriture de classes et de méthodes, des types spécifiques sont généralement utilisés, et des génériques peuvent être utilisés pour paramétrer les types, afin de pouvoir écrire du code plus général.

Beaucoup de gens pensent que les concepts de modèles C++ et de génériques Java sont équivalents, mais en fait les mécanismes de mise en œuvre sont complètement différents. Les modèles C++ sont un ensemble de macro-instructions, et le compilateur créera une copie du code du modèle pour chaque type ; l'implémentation des génériques Java est basée sur le concept d'« effacement de type », qui est essentiellement un sucre syntaxique pour les restrictions de type.

1. Classe générique

Prenons la classe de support comme exemple pour définir une classe de support générique :

/** 通用支撑类 */@Getter@Setter@ToStringpublic class GenericHolder<T> {    /** 通用取值 */
    private T value;    /** 构造函数 */
    public GenericHolder() {}    /** 构造函数 */
    public GenericHolder(T value) {        this.value = value;
    }
}

2. #

/** 数据提供者接口 */public interface DataProvider<T> {    /** 获取数据函数 */
    public T getData();
}

/** 浅拷贝函数 */public static <T> T shallowCopy(Object source, Class<T> clazz) throws BeansException {    // 判断源对象
    if (Objects.isNull(source)) {        return null;
    }    // 新建目标对象
    T target;    try {
        target = clazz.newInstance();
    } catch (Exception e) {        throw new BeansException("新建类实例异常", e);
    }    // 拷贝对象属性
    BeanUtils.copyProperties(source, target);    // 返回目标对象
    return target;
}

/** 打印取值函数 */public static void printValue(GenericHolder<?> holder) {
    System.out.println(holder.getValue());
}/** 主函数 */public static void main(String[] args) {
    printValue(new GenericHolder<>(12345));
    printValue(new GenericHolder<>("abcde"));
}

/** 打印取值函数 */public static <T> void printValue(GenericHolder<T> holder) {
    System.out.println(holder.getValue());
}

# 🎜🎜#Lors de l'utilisation de génériques, nous pouvons également définir des limites supérieures et inférieures pour les paramètres réels transmis dans le type générique. Par exemple : les paramètres de type réels ne sont autorisés à passer que dans un certain type de classe parent ou. un certain type de sous-classe. La déclaration des limites supérieure et inférieure d'un type générique doit être placée avec la déclaration du type générique.

Caractère générique de limite supérieure (étend):

Le caractère générique de limite supérieure est "étend", qui peut accepter son type spécifié ou sa sous-classe comme paramètre général. Il existe également un formulaire spécial qui précise qu'il doit non seulement s'agir d'une sous-classe du type spécifié, mais également implémenter certaines interfaces. Par exemple : List indique qu'il s'agit d'une liste d'une sous-classe spécifique de A et que l'objet enregistré doit être A ou une sous-classe de A. Pour la liste List, vous ne pouvez pas ajouter A ou un objet de sous-classe de A, mais vous ne pouvez obtenir que l'objet de A.

Caractère générique de limite inférieure (super) :

Le caractère générique de limite inférieure est "super", qui peut accepter son type spécifié ou sa classe parent comme paramètre général. Par exemple : List indique qu'il s'agit d'une liste d'une classe parent spécifique de A et que l'objet enregistré doit être A ou une superclasse de A. Pour la liste List, vous pouvez ajouter A ou un objet de sous-classe de A, mais vous ne pouvez obtenir que l'objet de Object.

Principe PECS (Producer Extends Consumer Super) :

Dans le codage quotidien, le caractère générique de limite supérieure (étend) est plus couramment utilisé, qui est utilisé pour limiter la classe parent d'un type générique. L'exemple de code est le suivant :

/** 数字支撑类 */@Getter@Setter@ToStringpublic class NumberHolder<T extends Number> {    /** 通用取值 */
    private T value;    /** 构造函数 */
    public NumberHolder() {}    /** 构造函数 */
    public NumberHolder(T value) {        this.value = value;
    }
}/** 打印取值函数 */public static <T extends Number> void printValue(GenericHolder<T> holder) {
    System.out.println(holder.getValue());
}

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!