Maison Java javaDidacticiel Un bref tutoriel sur les génériques Java

Un bref tutoriel sur les génériques Java

Feb 07, 2017 am 10:33 AM

Les génériques sont une fonctionnalité introduite dans Java SE 5.0 Au fil des années depuis l'apparition de cette fonctionnalité du langage, je pense que presque tous les programmeurs Java en ont non seulement entendu parler, mais l'ont également utilisé. Il existe de nombreux tutoriels sur les génériques Java, gratuits et payants. Les meilleurs manuels que j'ai rencontrés sont :

  • The Java Tutorial

  • Java Generics and Collections, de Maurice Naftalin et Philip Wadler

  • Effective Java Chinese Edition (2e édition), par Joshua Bloch.

Bien qu'il y ait tellement d'informations riches, parfois j'ai l'impression qu'il y en a beaucoup des programmeurs ne comprennent toujours pas bien la fonction et la signification des génériques Java. C'est pourquoi j'ai voulu résumer sous la forme la plus simple les choses les plus élémentaires qu'un programmeur doit savoir sur les génériques Java.

La motivation derrière les génériques Java

La façon la plus simple de comprendre les génériques Java est de les considérer comme une syntaxe pratique qui peut vous éviter certaines opérations de conversion (casting) de type Java :

List<Apple> box = ...;
Apple apple = box.get(0);
Copier après la connexion

Le code ci-dessus lui-même s'exprime très clairement : box est une liste contenant des objets Apple. La méthode get renvoie une instance d'objet Apple et aucune conversion de type n'est requise dans ce processus. Sans génériques, le code ci-dessus doit être écrit comme ceci :

List box = ...;
Apple apple = (Apple) box.get(0);
Copier après la connexion

De toute évidence, le principal avantage des génériques est de permettre au compilateur de conserver les informations de type des paramètres, d'effectuer une vérification de type et effectuer des opérations de conversion de type : le compilateur garantit que ces conversions de type sont sans erreur.

Plutôt que de compter sur les programmeurs pour mémoriser les types d'objets et effectuer des conversions de types - ce qui peut provoquer des échecs d'exécution du programme difficiles à déboguer et à résoudre, les compilateurs peuvent aider les programmeurs à forcer un grand nombre de vérifications de type pour trouver des erreurs.

La composition des génériques

La composition des génériques introduit la notion de variable de type. Selon la spécification du langage Java, une variable de type est un identifiant sans restriction qui se produit dans les situations suivantes :

  • Déclaration de classe générique

  • Interface générique déclaration

  • Déclaration de méthode générique

  • Déclaration de constructeur générique

Classes et interfaces génériques

Si une classe ou une interface possède une ou plusieurs variables de type, elle est générique. Les variables de type sont délimitées par des crochets angulaires et placées après le nom de la classe ou de l'interface :

public interface List<T> extends Collection<T> {
...
}
Copier après la connexion

En termes simples, le rôle d'une variable de type est comme un paramètre, qui est fourni au compilateur pour le type vérification des informations.


De nombreuses classes de la bibliothèque de classes Java, comme l'ensemble du framework Collection, ont été modifiées pour être génériques. Par exemple, l'interface List que nous avons utilisée dans le premier morceau de code ci-dessus est une classe générique. Dans ce code, box est un objet List, qui est une instance d'une implémentation de classe de l'interface List avec une variable de type Apple. Le compilateur utilise ce paramètre de variable de type pour effectuer automatiquement une conversion de type lorsque la méthode get est appelée et renvoie un objet Apple.


En fait, cette nouvelle balise générique, ou la méthode get dans cette interface List ressemble à ceci :

T get(int index);
Copier après la connexion

méthode get Ce qui est réellement retourné est un objet de type T, qui est la variable de type dans la déclaration List


Les méthodes et constructeurs génériques (Constructeur)

sont très similaires, si un ou plusieurs types sont déclarés sur la méthode et le constructeur Variables, ils peut aussi être générique.

public static <t> T getFirst(List<T> list)
Copier après la connexion

Cette méthode acceptera un paramètre de type List et renverra un objet de type T.


Exemple

Vous pouvez soit utiliser les classes génériques fournies dans la bibliothèque de classes Java, soit utiliser vos propres classes génériques.

Écriture de données sécurisées...

Le code suivant est un exemple. Nous créons une instance List

List<String> str = new ArrayList<String>();
str.add("Hello ");
str.add("World.");
Copier après la connexion
Si nous essayons de charger un autre type d'objet dans List, le compilateur affichera une erreur :


str.add(1); // 不能编译
Copier après la connexion
Type-safe Reading Data.. .


Lorsque nous utilisons l'objet List, il peut toujours garantir que ce que nous obtenons est un objet String :


String myString = str.get(0);
Copier après la connexion
Traversal

De nombreuses classes de la bibliothèque de classes, telles que Iterator, ont des fonctions améliorées et ont été génériques. La méthode iterator() dans l'interface List renvoie désormais Iterator. L'objet renvoyé par sa méthode T next() n'a pas besoin d'être converti en type et vous obtenez directement le type correct.


for (Iterator<String> iter = str.iterator(); iter.hasNext();) {
String s = iter.next();
System.out.print(s);
}
Copier après la connexion


Utiliser foreach

La syntaxe "for each" bénéficie également des génériques. Le code précédent peut s'écrire comme ceci :


for (String s: str) {
System.out.print(s);
}
Copier après la connexion
C'est facile à lire et à maintenir.



Autoboxing et Autounboxing

Lors de l'utilisation de génériques Java, les deux fonctionnalités d'autoboxing/autounboxing seront utilisées automatiquement, tout comme le code suivant :


List<Integer> ints = new ArrayList<Integer>();
ints.add(0);
ints.add(1);
int sum = 0;
for (int i : ints) {
sum += i;
}
Copier après la connexion
Cependant, une chose que vous devez comprendre est que l'encapsulation et la décapsulation entraîneront des pertes de performances, le tout, universel. À utiliser avec prudence.

Sous-types

En Java, comme d'autres langages avec des types orientés objet, la hiérarchie des types peut être conçue comme ceci :

Un bref tutoriel sur les génériques Java

在Java中,类型T的子类型既可以是类型T的一个扩展,也可以是类型T的一个直接或非直接实现(如果T是一个接口的话)。因为“成为某类型的子类型”是一个具有传递性质的关系,如果类型A是B的一个子类型,B是C的子类型,那么A也是C的子类型。在上面的图中:

  • FujiApple(富士苹果)是Apple的子类型

  • Apple是Fruit(水果)的子类型

  • FujiApple(富士苹果)是Fruit(水果)的子类型

所有Java类型都是Object类型的子类型。


B类型的任何一个子类型A都可以被赋给一个类型B的声明:

Apple a = ...;
Fruit f = a;
Copier après la connexion

泛型类型的子类型

如果一个Apple对象的实例可以被赋给一个Fruit对象的声明,就像上面看到的,那么,List 和 a List之间又是个什么关系呢?更通用些,如果类型A是类型B的子类型,那C 和 C之间是什么关系?

答案会出乎你的意料:没有任何关系。用更通俗的话,泛型类型跟其是否子类型没有任何关系。

这意味着下面的这段代码是无效的:

下面的同样也不允许:

为什么?一个苹果是一个水果,为什么一箱苹果不能是一箱水果?

在某些事情上,这种说法可以成立,但在类型(类)封装的状态和操作上不成立。如果把一箱苹果当成一箱水果会发生什么情况?

如果可以这样的话,我们就可以在list里装入各种不同的水果子类型,这是绝对不允许的。

另外一种方式会让你有更直观的理解:一箱水果不是一箱苹果,因为它有可能是一箱另外一种水果,比如草莓(子类型)。

这是一个需要注意的问题吗?

应该不是个大问题。而程序员对此感到意外的最大原因是数组和泛型类型上用法的不一致。对于泛型类型,它们和类型的子类型之间是没什么关系的。而对于数组,它们和子类型是相关的:如果类型A是类型B的子类型,那么A[]是B[]的子类型:

可是稍等一下!如果我们把前面的那个议论中暴露出的问题放在这里,我们仍然能够在一个apple类型的数组中加入strawberrie(草莓)对象:

这样写真的可以编译,但是在运行时抛出ArrayStoreException异常。因为数组的这特点,在存储数据的操作上,Java运行时需要检查类型的兼容性。这种检查,很显然,会带来一定的性能问题,你需要明白这一点。

重申一下,泛型使用起来更安全,能“纠正”Java数组中这种类型上的缺陷。

现在估计你会感到很奇怪,为什么在数组上会有这种类型和子类型的关系,我来给你一个《Java Generics and Collections》这本书上给出的答案:如果它们不相关,你就没有办法把一个未知类型的对象数组传入一个方法里(不经过每次都封装成Object[]),就像下面的:

泛型出现后,数组的这个个性已经不再有使用上的必要了(下面一部分我们会谈到这个),实际上是应该避免使用。

通配符

在本文的前面的部分里已经说过了泛型类型的子类型的不相关性。但有些时候,我们希望能够像使用普通类型那样使用泛型类型:

向上造型一个泛型对象的引用


例如,假设我们有很多箱子,每个箱子里都装有不同的水果,我们需要找到一种方法能够通用的处理任何一箱水果。更通俗的说法,A是B的子类型,我们需要找到一种方法能够将C类型的实例赋给一个C类型的声明。

为了完成这种操作,我们需要使用带有通配符的扩展声明,就像下面的例子里那样:

“? extends”是泛型类型的子类型相关性成为现实:Apple是Fruit的子类型,List 是 List 的子类型。


向下造型一个泛型对象的引用


现在我来介绍另外一种通配符:? super。如果类型B是类型A的超类型(父类型),那么C 是 C 的子类型:


为什么使用通配符标记能行得通?

原理现在已经很明白:我们如何利用这种新的语法结构?


? extends


让我们重新看看这第二部分使用的一个例子,其中谈到了Java数组的子类型相关性:


就像我们看到的,当你往一个声明为Fruit数组的Apple对象数组里加入Strawberry对象后,代码可以编译,但在运行时抛出异常。


现在我们可以使用通配符把相关的代码转换成泛型:因为Apple是Fruit的一个子类,我们使用? extends 通配符,这样就能将一个List对象的定义赋到一个List的声明上:


这次,代码就编译不过去了!Java编译器会阻止你往一个Fruit list里加入strawberry。在编译时我们就能检测到错误,在运行时就不需要进行检查来确保往列表里加入不兼容的类型了。即使你往list里加入Fruit对象也不行:

你没有办法做到这些。事实上你不能够往一个使用了? extends的数据结构里写入任何的值。


原因非常的简单,你可以这样想:这个? extends T 通配符告诉编译器我们在处理一个类型T的子类型,但我们不知道这个子类型究竟是什么。因为没法确定,为了保证类型安全,我们就不允许往里面加入任何这种类型的数据。另一方面,因为我们知道,不论它是什么类型,它总是类型T的子类型,当我们在读取数据时,能确保得到的数据是一个T类型的实例:

? super


使用 ? super 通配符一般是什么情况?让我们先看看这个:

我们看到fruits指向的是一个装有Apple的某种超类(supertype)的List。同样的,我们不知道究竟是什么超类,但我们知道Apple和任何Apple的子类都跟它的类型兼容。既然这个未知的类型即是Apple,也是GreenApple的超类,我们就可以写入:

如果我们想往里面加入Apple的超类,编译器就会警告你:

因为我们不知道它是怎样的超类,所有这样的实例就不允许加入。

从这种形式的类型里获取数据又是怎么样的呢?结果表明,你只能取出Object实例:因为我们不知道超类究竟是什么,编译器唯一能保证的只是它是个Object,因为Object是任何Java类型的超类。

存取原则和PECS法则

总结 ? extends 和 the ? super 通配符的特征,我们可以得出以下结论:

  • 如果你想从一个数据类型里获取数据,使用 ? extends 通配符

  • 如果你想把对象写入一个数据结构里,使用 ? super 通配符

  • 如果你既想存,又想取,那就别用通配符。

这就是Maurice Naftalin在他的《Java Generics and Collections》这本书中所说的存取原则,以及Joshua Bloch在他的《Effective Java》这本书中所说的PECS法则。

Bloch提醒说,这PECS是指”Producer Extends, Consumer Super”,这个更容易记忆和运用。

以上就是Java泛型简明教程的内容,更多相关内容请关注PHP中文网(www.php.cn)!


Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Outils d'IA chauds

Undresser.AI Undress

Undresser.AI Undress

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

AI Clothes Remover

AI Clothes Remover

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

Undress AI Tool

Undress AI Tool

Images de déshabillage gratuites

Clothoff.io

Clothoff.io

Dissolvant de vêtements AI

AI Hentai Generator

AI Hentai Generator

Générez AI Hentai gratuitement.

Article chaud

R.E.P.O. Crystals d'énergie expliqués et ce qu'ils font (cristal jaune)
2 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
Repo: Comment relancer ses coéquipiers
4 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
Hello Kitty Island Adventure: Comment obtenir des graines géantes
4 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
Combien de temps faut-il pour battre Split Fiction?
3 Il y a quelques semaines By DDD

Outils chauds

Bloc-notes++7.3.1

Bloc-notes++7.3.1

Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise

SublimeText3 version chinoise

Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1

Envoyer Studio 13.0.1

Puissant environnement de développement intégré PHP

Dreamweaver CS6

Dreamweaver CS6

Outils de développement Web visuel

SublimeText3 version Mac

SublimeText3 version Mac

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

Racine carrée en Java Racine carrée en Java Aug 30, 2024 pm 04:26 PM

Guide de la racine carrée en Java. Nous discutons ici du fonctionnement de Square Root en Java avec un exemple et son implémentation de code respectivement.

Nombre parfait en Java Nombre parfait en Java Aug 30, 2024 pm 04:28 PM

Guide du nombre parfait en Java. Nous discutons ici de la définition, comment vérifier le nombre parfait en Java ?, des exemples d'implémentation de code.

Générateur de nombres aléatoires en Java Générateur de nombres aléatoires en Java Aug 30, 2024 pm 04:27 PM

Guide du générateur de nombres aléatoires en Java. Nous discutons ici des fonctions en Java avec des exemples et de deux générateurs différents avec d'autres exemples.

Weka en Java Weka en Java Aug 30, 2024 pm 04:28 PM

Guide de Weka en Java. Nous discutons ici de l'introduction, de la façon d'utiliser Weka Java, du type de plate-forme et des avantages avec des exemples.

Numéro Armstrong en Java Numéro Armstrong en Java Aug 30, 2024 pm 04:26 PM

Guide du numéro Armstrong en Java. Nous discutons ici d'une introduction au numéro d'Armstrong en Java ainsi que d'une partie du code.

Numéro de Smith en Java Numéro de Smith en Java Aug 30, 2024 pm 04:28 PM

Guide du nombre de Smith en Java. Nous discutons ici de la définition, comment vérifier le numéro Smith en Java ? exemple avec implémentation de code.

Questions d'entretien chez Java Spring Questions d'entretien chez Java Spring Aug 30, 2024 pm 04:29 PM

Dans cet article, nous avons conservé les questions d'entretien Java Spring les plus posées avec leurs réponses détaillées. Pour que vous puissiez réussir l'interview.

Break or Return of Java 8 Stream Forach? Break or Return of Java 8 Stream Forach? Feb 07, 2025 pm 12:09 PM

Java 8 présente l'API Stream, fournissant un moyen puissant et expressif de traiter les collections de données. Cependant, une question courante lors de l'utilisation du flux est: comment se casser ou revenir d'une opération FOREAK? Les boucles traditionnelles permettent une interruption ou un retour précoce, mais la méthode Foreach de Stream ne prend pas directement en charge cette méthode. Cet article expliquera les raisons et explorera des méthodes alternatives pour la mise en œuvre de terminaison prématurée dans les systèmes de traitement de flux. Lire plus approfondie: Améliorations de l'API Java Stream Comprendre le flux Forach La méthode foreach est une opération terminale qui effectue une opération sur chaque élément du flux. Son intention de conception est

See all articles