Java泛型通配符extends与super
Java 泛型
关键字说明
? 通配符类型
extends T> 表示类型的上界,表示参数化类型的可能是T 或是 T的子类
super T> 表示类型下界(Java Core中叫超类型限定),表示参数化类型是此类型的超类型(父类型),直至Object
extends 示例
static class Food{}
static class Fruit extends Food{}
static class Apple extends Fruit{}
static class RedApple extends Apple{}
List extends Fruit> flist = new ArrayList
// complie error:
// flist.add(new Apple());
// flist.add(new Fruit());
// flist.add(new Object());
flist.add(null); // only work for null
List extends Frut> 表示 “具有任何从Fruit继承类型的列表”,编译器无法确定List所持有的类型,所以无法安全的向其中添加对象。可以添加null,因为null 可以表示任何类型。所以List 的add 方法不能添加任何有意义的元素,但是可以接受现有的子类型List
Fruit fruit = flist.get(0);
Apple apple = (Apple)flist.get(0);
由于,其中放置是从Fruit中继承的类型,所以可以安全地取出Fruit类型。
flist.contains(new Fruit());
flist.contains(new Apple());
在使用Collection中的contains 方法时,接受Object 参数类型,可以不涉及任何通配符,编译器也允许这么调用。
super 示例
List super Fruit> flist = new ArrayList
flist.add(new Fruit());
flist.add(new Apple());
flist.add(new RedApple());
// compile error:
List super Fruit> flist = new ArrayList
List super Fruit> 表示“具有任何Fruit超类型的列表”,列表的类型至少是一个 Fruit 类型,因此可以安全的向其中添加Fruit 及其子类型。由于List super Fruit>中的类型可能是任何Fruit 的超类型,无法赋值为Fruit的子类型Apple的List
// compile error:
Fruit item = flist.get(0);
因为,List super Fruit>中的类型可能是任何Fruit 的超类型,所以编译器无法确定get返回的对象类型是Fruit,还是Fruit的父类Food 或 Object.
小结
extends 可用于的返回类型限定,不能用于参数类型限定。
super 可用于参数类型限定,不能用于返回类型限定。
>带有super超类型限定的通配符可以向泛型对易用写入,带有extends子类型限定的通配符可以向泛型对象读取。
更多Java泛型通配符extends与super相关文章请关注PHP中文网!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Les fonctions génériques dans Go résolvent le problème des types variadiques : les fonctions génériques permettent de spécifier les paramètres de type au moment de l'exécution. Cela permet d'écrire des fonctions capables de gérer des arguments de différents types. Par exemple, la fonction Max est une fonction générique qui accepte deux paramètres comparables et renvoie la plus grande valeur. En utilisant des fonctions génériques, nous pouvons écrire du code plus flexible et général capable de gérer différents types de paramètres.

Scénarios d'application des génériques dans Go : Opérations de collecte : Créez des opérations de collecte adaptées à tout type, comme le filtrage. Structures de données : écrivez des structures de données à usage général telles que des files d'attente, des piles et des cartes pour stocker et manipuler divers types de données. Algorithmes : écrivez des algorithmes à usage général tels que le tri, la recherche et la réduction qui peuvent gérer différents types de données.

Les fonctions génériques Java permettent de définir des limites supérieures et inférieures. Extends spécifie que le type de données accepté ou renvoyé par une fonction doit être un sous-type du type spécifié, par ex. La limite inférieure (super) spécifie que le type de données accepté ou renvoyé par une fonction doit être un supertype du type spécifié, par ex. L'utilisation de génériques améliore la réutilisabilité et la sécurité du code.

Réponse : Les génériques Golang sont un outil puissant pour améliorer la réutilisabilité, la flexibilité, la sécurité des types et l'évolutivité du code. Description détaillée : Avantages : Réutilisabilité du code : algorithmes et structures de données communs Flexibilité : création d'instances de types spécifiques au moment de l'exécution Sécurité des types : vérification du type au moment de la compilation Extensibilité : facile à étendre et à personnaliser Objectif : fonctions communes : tri, comparaison Structures de données communes telles que les listes , cartes, piles, etc. Alias de type : simplifiez les déclarations de type Génériques contraints : assurez la sécurité des types

L'application de génériques dans le développement Android améliore la réutilisabilité, la sécurité et la flexibilité du code. La syntaxe consiste à déclarer une variable de type T qui peut être utilisée pour manipuler des données paramétrées par type. Les génériques en action incluent des adaptateurs de données personnalisés, permettant à l'adaptateur de s'adapter à tout type d'objet de données personnalisé. Android fournit également des classes de listes génériques (telles que ArrayList) et des méthodes génériques permettant la manipulation de paramètres de différents types. Les avantages de l'utilisation de génériques incluent la réutilisabilité, la sécurité et la flexibilité du code, mais il faut veiller à spécifier les limites correctes et à les utiliser avec modération pour garantir la lisibilité du code.

Limitations des fonctions génériques Go : seuls les paramètres de type sont pris en charge, les paramètres de valeur ne sont pas pris en charge. La récursion des fonctions n'est pas prise en charge. Les paramètres de type ne peuvent pas être spécifiés explicitement, ils sont déduits par le compilateur.

L'impact des génériques sur les signatures et les paramètres des fonctions Go comprend : Paramètres de type : les signatures de fonction peuvent contenir des paramètres de type, spécifiant les types que la fonction peut utiliser. Contraintes de type : les paramètres de type peuvent avoir des contraintes qui spécifient les conditions qu'ils doivent satisfaire. Inférence de type de paramètre : le compilateur peut déduire le type de paramètres de type non spécifiés. Spécification des types : les types de paramètres peuvent être explicitement spécifiés pour appeler des fonctions génériques. Cela augmente la réutilisabilité et la flexibilité du code, vous permettant d'écrire des fonctions et des types pouvant être utilisés avec plusieurs types.

Dans Go, les paramètres variadiques peuvent être utilisés pour des fonctions génériques, permettant la création de fonctions génériques acceptant un nombre variable de paramètres et adaptées à plusieurs types. Par exemple, vous pouvez créer une fonction générique Mode qui recherche l'élément le plus fréquent dans une liste donnée : Mode accepte un nombre variable d'éléments de type T. Il compte les éléments en créant des comptes pour chaque élément. Ensuite, il trouve l'élément qui apparaît le plus et le renvoie en mode. Dans la fonction principale, vous pouvez appeler la fonction Mode pour la liste de chaînes et la liste d'entiers, qui renverront respectivement la chaîne et le nombre avec le plus d'occurrences.
