Inférence de type de compilateur Java

1. Sucre syntaxique

Les programmeurs aiment quand un code ou une logique complexe peut être écrit en quelques lignes, ce qui rend le code compact et lisible. Et les créateurs de langages de programmation y contribuent parfois.

Une fonctionnalité de langage astucieuse qui vous permet de prendre un raccourci (écrire moins de code) est appelée sucre syntaxique . Mais, pour être honnête, il y en a très peu à Java.

Les créateurs de Java ont tout fait pour éliminer toute redondance dans Java. Si C++ vous permet de faire quelque chose de 20 façons, alors Java ne vous permet de le faire que d'une seule façon.

Mais ni les programmeurs Java ni les créateurs de Java n'aimaient le manque de liberté. Et parfois, le sucre facilite la vie des gens ordinaires comme vous et moi.

Au fait, vous avez déjà rencontré du sucre syntaxique : autoboxing et unboxing . Comparons:

Integer a = new Integer(5);
int b = a.intValue();

Integer a = 5;
int b = a;

int b = 5;
Integer c = new Integer(b);

int b = 5;
Integer c = b;

Integer a = new Integer(1);
int b = 1;
if (a.intValue() == b)
{
   ...
}

Integer a = 1;
int b = 1;
if (a == b)
{
   ...
}

Au lieu du code long comme à gauche, vous pouvez écrire le code plus compact à droite. Et le compilateur Java intelligent générera la version détaillée du code basée sur la version courte du code. C'est exactement ce qu'est le sucre syntaxique.

2. Inférence du type d'une variable : le varmot clé

Dans Java 11, le compilateur est devenu encore plus intelligent et peut désormais déterminer le type d'une variable déclarée en fonction du type de la valeur qui lui est affectée . En code, ça ressemble à ça :

var name = value;

Où nameest le nom d'une nouvelle variable, valeur est sa valeur initiale et varest un mot-clé utilisé pour déclarer la variable. Le type de la variable name sera le même que le type de la valeur qui lui est assignée.

Exemples:

var i = 1;

int i = 1;

var s = "Hello";

String s = "Hello";

var console = new Scanner(System.in);

Scanner console = new Scanner(System.in);

var list = new ArrayList<String>();

ArrayList<String> list = new ArrayList<String>();

var data = new int[]{1, 2, 3};

int[] data = new int[]{1, 2, 3};

Le compilateur lui-même détermine, ou déduit, le type de la variable en fonction de la valeur qui lui est assignée.

Les programmeurs ont vivement débattu de l'opportunité d'ajouter une telle fonctionnalité au langage. Beaucoup de gens craignaient que cela varne soit abusé et que la lisibilité du code en pâtisse.

Il y a un grain de vérité là-dedans, il est donc préférable de l'utiliser varlà où cela augmente la lisibilité du code. Par exemple, ceux-ci dans deux cas :

Cas 1 : En regardant la valeur attribuée à la variable, le type de la variable est immédiatement clair

var stream = url.getInputStream();

var name = person.getFullName();

Dans ces cas, vous ne devriez pas utiliser var. Eh bien, quel est le type de la variable ?

var result = task.execute();

var status = person.getStatus();

Cas 2 : Le type de la variable n'est pas important pour la compréhension du code

Le code n'a souvent pas besoin d'appeler des méthodes sur une variable, par exemple lorsqu'une variable est simplement utilisée pour stocker temporairement quelque chose. Dans ce cas, l'utilisation varne réduit définitivement pas la lisibilité du code :

var data = stream.getMetaData();
storage.save(data)

Le juste milieu

Je vais maintenant donner trois façons d'écrire le même code. L'utilisation varserait la meilleure option.

dest.writeHeaderInfo(src.getFileMetaInfo());

var headerInfo = src.getFileMetaInfo();
dest.writeHeaderInfo(headerInfo);

FileMetaInfo headerInfo = src.getFileMetaInfo();
dest.writeHeaderInfo(headerInfo);

En passant de la version avec 1 ligne à la version sur 2 lignes, nous avons rendu le code un peu plus lisible en utilisant un nom de variable ( headerInfo). Il est maintenant clair que la méthode renvoie non seulement des méta-informations, mais également des informations d'en-tête.

La troisième version est trop verbeuse. Le fait que headerInfosoit a FileMetaInforessort déjà assez clairement de la getFileMetaInfo()méthode. Le but des méta-informations est beaucoup plus intéressant.

3. Omettre le type avec l'opérateur losange :<>

Même avant l' varapparition de l'opérateur, il y a eu des tentatives pour apprendre au compilateur comment déduire les types de collection. Vous conviendrez que cette notation semble un peu redondante :

ArrayList<String> list = new ArrayList<String>();

À partir de la septième version de Java, lors de l'écriture d'un type de collection, vous pouvez omettre le type des éléments de la collection s'il a été spécifié lors de la déclaration d'une variable. En d'autres termes, le code ci-dessus peut être écrit sous une forme légèrement abrégée :

ArrayList<String> list = new ArrayList<>();

Comme vous pouvez le voir, vous n'avez plus besoin d'écrire String une seconde fois. Pas aussi cool qu'avec l'opérateur var, mais cela semblait être un progrès à l'époque.

Les crochets vides dans le type de collection étaient appelés l' opérateur diamant , puisque les deux crochets ressemblent vaguement à un diamant.

Il n'est pas souhaitable d'utiliser le varmot clé et l' opérateur diamant en même temps :

var list = new ArrayList<>();

Il n'y a aucune information sur le type des éléments stockés dans la collection, et le type de collection sera ArrayList < Object >.

4. Doubles accolades

Vous souvenez-vous de l'initialisation rapide du tableau ?

Nous venons de lister les valeurs entre accolades, comme ceci :

int[] data = new int[] {1, 2, 3, 4, 5, 6, 7};

int[] data = {1, 2, 3, 4, 5, 6, 7};

Les créateurs de Java ont adoré l'idée d'utiliser des accolades pour simplifier l'écriture des éléments d'un tableau. Mais qu'en est-il des collections ?

Les créateurs de Java avaient également suffisamment de créativité pour les collections, leur permettant d'utiliser une astuce avec des accolades doubles.

var list = new ArrayList<String>()
{{
   add("Hello");
   add("How's");
   add("Life?");
}};

var list = new ArrayList<String>();

list.add("Hello");
list.add("How's");
list.add("Life?");

Si le compilateur rencontre du code comme dans l'exemple de gauche, il le convertit en code de droite.

Le code ne devient pas beaucoup plus compact. Les économies ici sont assez insignifiantes : vous n'avez pas à écrire listà chaque fois. Cela peut être utile si le nom de la variable est très long.

Mais si vous rencontrez un code comme celui-ci dans un projet, ne soyez pas surpris 🙂