Un bref tutoriel sur les génériques Java

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);

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);

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> {
...
}

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);

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)

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.");

Si nous essayons de charger un autre type d'objet dans List, le compilateur affichera une erreur :

str.add(1); // 不能编译

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);

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);
}

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);
}

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;
}

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 :

在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;

泛型类型的子类型

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

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

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

List<Apple> apples = ...;
List<Fruit> fruits = apples;

下面的同样也不允许：

List<Apple> apples;
List<Fruit> fruits = ...;
apples = fruits;

为什么？一个苹果是一个水果，为什么一箱苹果不能是一箱水果？

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

List<Apple> apples = ...;
List<Fruit> fruits = apples;
fruits.add(new Strawberry());

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

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

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

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

Apple[] apples = ...;
Fruit[] fruits = apples;

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

Apple[] apples = new Apple[1];
Fruit[] fruits = apples;
fruits[0] = new Strawberry();

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

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

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

void sort(Object[] o);

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

通配符

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

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

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

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

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

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

List<Apple> apples = new ArrayList<Apple>();
List<? extends Fruit> fruits = apples;

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

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

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

List<Fruit> fruits = new ArrayList<Fruit>();
List<? super Apple> = fruits;

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

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

? extends

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

Apple[] apples = new Apple[1];
Fruit[] fruits = apples;
fruits[0] = new Strawberry();

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

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

List<Apple> apples = new ArrayList<Apple>();
List<? extends Fruit> fruits = apples;
fruits.add(new Strawberry());

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

fruits.add(new Fruit());

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

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

Fruit get = fruits.get(0);

? super

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

List<Fruit> fruits = new ArrayList<Fruit>();
List<? super Apple> = fruits;

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

fruits.add(new Apple());
fruits.add(new GreenApple());

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

fruits.add(new Fruit());
fruits.add(new Object());

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

从这种形式的类型里获取数据又是怎么样的呢？结果表明，你只能取出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）！