Améliorations des méthodes d'inférence de type cible générique dans Java 8

1. Une compréhension simple des génériques

Les génériques sont une nouvelle fonctionnalité de Java SE 1.5. L'essence des génériques est un type paramétré, ce qui signifie que le type de données utilisé est spécifié en tant que paramètre. Le point populaire est "type variable". Les variables de ce type peuvent être utilisées dans la création de classes, d'interfaces et de méthodes.

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 = new ArrayList<Apple>();box.add(new Apple());Apple apple =box.get(0);

Le code ci-dessus a été exprimé 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 :

Apple apple = (Apple)box.get(0);

2. L'embarras des génériques

Le plus grand avantage des génériques est qu'ils offrent une sécurité de type de programme tout en étant rétrocompatibles . Mais il y a aussi un embarras, c'est-à-dire que le type du générique doit être spécifié à chaque fois qu'il est défini. Non seulement cela semble un peu verbeux de le spécifier explicitement, mais le plus important est que de nombreux programmeurs ne le connaissent pas. génériques, ils ne peuvent donc souvent pas donner les paramètres de type corrects, désormais le compilateur déduit automatiquement les types de paramètres des génériques, ce qui peut réduire de telles situations et améliorer la lisibilité du code.

3. Améliorations de l'inférence de type générique dans Java 7

Lors de l'utilisation de types génériques dans les versions précédentes, vous devez ajouter des types génériques des deux côtés lors de la déclaration et de l'attribution de valeurs. Par exemple :

Map<String, String> myMap = new HashMap<String, String>();

Vous pensez peut-être : j'ai déjà spécifié le type de paramètre lors de la déclaration de la variable, pourquoi dois-je le spécifier à nouveau lors de l'initialisation de l'objet ? Heureusement, dans Java SE 7, cette méthode a été améliorée. Vous pouvez désormais déclarer et attribuer des valeurs à l'aide de l'instruction suivante :

Map<String, String> myMap = new HashMap<>(); //注意后面的"<>"

Dans cette instruction, le compilateur utilisera le type générique lorsque la variable est déclaré. Le type est automatiquement déduit du type générique lors de l'instanciation du HashMap. Encore une fois, assurez-vous de faire attention au "<>" après le nouveau HashMap. Seul l'ajout de ce "<>" signifie une inférence de type automatique, sinon il s'agira d'un HashMap de type non générique et utilisez le compilateur pour. compilez le code source. Un avertissement sera donné.

Cependant : l'inférence de type de Java SE 7 lors de la création d'instances génériques est limitée : ce n'est que lorsque le type paramétré du constructeur est explicitement déclaré dans le contexte que l'inférence de type peut être utilisée, sinon cela ne fonctionnera pas. Par exemple : L'exemple suivant ne peut pas être compilé correctement dans Java 7 (mais il peut maintenant être compilé dans Java 8, car le type de génériques est automatiquement déduit en fonction des paramètres de la méthode) :

List<String> list = new ArrayList<>();
list.add("A");// 由于addAll期望获得Collection<? extends String>类型的参数，因此下面的语句无法通过
list.addAll(new ArrayList<>());

4. Inférence de type générique dans Java 8 Il y a deux améliorations principales à

inférence de type cible générique dans Java8 :

1 Prise en charge de l'inférence de types cibles génériques via le contexte de méthode
2. les types cibles dans les liens d'appel de méthode. L'inférence de type est passée à la dernière méthode
Jetons un coup d'œil à l'exemple sur le site officiel :

class List<E> {
   static <Z> List<Z> nil() { ... };
   static <Z> List<Z> cons(Z head, List<Z> tail) { ... };
   E head() { ... }
}

Selon les caractéristiques de JEP101, lorsque nous appelons le méthode ci-dessus, nous pouvons écrire comme ceci

//通过方法赋值的目标参数来自动推断泛型的类型
List<String> l = List.nil();
//而不是显示的指定类型
//List<String> l = List.<String>nil();
//通过前面方法参数类型推断泛型的类型
List.cons(42, List.nil());
//而不是显示的指定类型
//List.cons(42, List.<Integer>nil());

5.Résumé

Ce qui précède est le contenu des fonctionnalités de JEP101. En tant que représentant du langage statique, Java peut être considéré comme ayant un tout à fait. système de type riche. Le problème de la conversion entre les types dérange tous les programmeurs Java. La déduction automatique des types via le compilateur peut légèrement atténuer le problème d'une conversion de type trop complexe. Bien qu'il s'agisse d'une petite amélioration, cela aura certainement un impact énorme sur nos programmeurs qui écrivent du code tous les jours. Au moins, ils se sentiront plus heureux ~~ Peut-être que dans Java 9, nous aurons un type var universel, comme js ou Like somedynamic. langages​​de scala^_^

Pour plus d'articles liés aux améliorations de la méthode d'inférence de type cible générique dans Java 8, veuillez faire attention au site Web PHP chinois !