Quelle est la différence entre covariance et contravariance en programmation ?

Covariance et contravariance : comprendre la différence entre "entrée" et "sortie"

La covariance et la contravariance sont des concepts de programmation qui impliquent la manière dont les types génériques sont attribués ou accessibles à partir de types hérités ou de types qui leur sont liés.

Covariance : position de sortie

La covariance permet d'utiliser un type plus général (ou "plus grand") à la place d'un type plus spécifique lorsque le type primitif est utilisé uniquement comme valeur de sortie. Par exemple, une liste de fruits peut être traitée comme une liste de bananes, puisqu'il n'y a aucune restriction sur la conversion d'un type plus spécifique en un type plus général :

<code>List<水果> 水果列表 = new List<水果>();
水果列表.Add(new 香蕉()); // 有效，因为香蕉是水果</code>

Inversion : position d'entrée

Contravariance permet de remplacer un type plus spécifique (ou "plus petit") par un type plus général lorsque le type d'origine est utilisé uniquement comme valeur d'entrée. En effet, des types plus spécifiques peuvent être réduits en toute sécurité à des types plus généraux :

<code>MyInterface<基类> 基类接口 = new MyInterface<派生类>(); // 有效，因为派生类是基类</code>

Notation "Entrée" et "Sortie"

Les mots-clés "in" et "out" peuvent être utilisés dans une définition d'interface générique pour spécifier si un paramètre de type générique représente un emplacement de sortie ou un emplacement d'entrée.

• « out »  : Utilisé lorsque le type générique est uniquement utilisé comme valeur de retour. Cela permet aux classes dérivées d'être implicitement converties en classes de base.
• "in" : Utilisé lorsque le type générique est uniquement utilisé comme paramètre de méthode. Cela permet la conversion implicite des classes de base en classes dérivées.

En spécifiant "in" ou "out", le compilateur peut effectuer une opération de conversion sécurisée sans conversion explicite.

Exemple pratique

Considérons une interface générique qui prend un paramètre de type comme paramètre :

<code>interface MyInterface<T> {
    void Process(T value);
}</code>

Si vous utilisez l'inversion pour implémenter cette interface :

<code>interface MyInterface<in T> {
    void Process(T value);
}</code>

Cela signifie que n'importe quel objet de n'importe quelle classe dérivée peut être transmis en tant que paramètre à la méthode Process. Ceci est utile lorsque la logique d'une méthode nécessite uniquement le type de classe de base, quel que soit le type d'objet réel.

Par contre, si vous implémentez l'interface en utilisant la covariance :

<code>interface MyInterface<out T> {
    T GetValue();
}</code>

Cela signifie que n'importe quel objet de n'importe quelle classe de base peut être renvoyé par la méthode GetValue. Ceci est utile lorsqu'une méthode renvoie un type plus général qui peut être converti en toute sécurité en divers types spécifiques.

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!