J'ai décompilé l'inférence de type de variable locale de Java 10

Cliquez sur "Hollis" ci-dessus pour me suivre, et le contenu passionnant sera présenté immédiatement.
Texte intégral: 2500
Temps de lecture: 5 minutes,
heure de Beijing, le 21 mars, Oracle a officiellement annoncé la sortie officielle de Java 10. Il s'agit de la première version officielle après le cycle de version majeur de Java. Concernant Java 10, l’une des nouvelles fonctionnalités qui mérite l’attention des programmeurs est probablement l’inférence de type à variable locale.

Après le lancement de Java 10, de nombreux articles sont également parus, nous expliquant quelles sont les fonctionnalités disponibles et comment utiliser l'inférence de type de variable locale. Cependant, pour savoir pourquoi, il faut savoir pourquoi.

Après la sortie de Java 10, j'ai téléchargé cette version de Jdk et l'ai installée sur mon ordinateur pour la première fois, puis j'ai écrit un morceau de code et essayé de le décompiler, et j'ai vraiment ressenti à quel point l'inférence de variable locale est. Cet article parle brièvement de mes sentiments.

principe

Concernant l'utilisation de l'inférence de type variable locale, je l'ai introduit dans mon "Java 10 sortira ce mois-ci, cela changera la façon dont vous écrivez le code". Il peut être utilisé dans les scénarios suivants:

public class VarDemo {

   public static void main(String[] args) {
       //初始化局部变量  
       var string = "hollis";
       //初始化局部变量  
       var stringList = new ArrayList<String>();
       stringList.add("hollis");
       stringList.add("chuang");
       stringList.add("weChat:hollis");
       stringList.add("blog:http://www.hollischuang.com");
       //增强for循环的索引
       for (var s : stringList){
           System.out.println(s);
       }
       //传统for循环的局部变量定义
       for (var i = 0; i < stringList.size(); i++){
           System.out.println(stringList.get(i));
       }
   }
}

Ensuite, utilisez la commande javac de java 10 pour compiler:

/Library/Java/JavaVirtualMachines/jdk-10.jdk/Contents/Home/bin/javac VarDemo.java

Générez le fichier VarDemo.class, nous décompilons VarDemo.class. Décompilez avec jad pour obtenir le code suivant:


public class VarDemo
{
   public static void main(String args[])
   {
       String s = "hollis";
       ArrayList arraylist = new ArrayList();
       arraylist.add("hollis");
       arraylist.add("chuang");
       arraylist.add("weChat:hollis");
       arraylist.add("blog:http://www.hollischuang.com");
       String s1;
       for(Iterator iterator = arraylist.iterator(); iterator.hasNext(); System.out.println(s1))
           s1 = (String)iterator.next();

       for(int i = 0; i < arraylist.size(); i++)
           System.out.println((String)arraylist.get(i));

   }
}

Ce code nous est très familier, il s'agit du code écrit avant Java 10 lorsqu'il n'y a pas d'inférence de type de variable locale. La relation correspondante du code est la suivante:

本地变量类型推断写法  正常写法
var string = "hollis";  String string = "hollis";
var stringList = new ArrayList();   ArrayList stringList = new ArrayList();
for (var s : stringList)    for (String s : stringList)
for (var i = 0; i < stringList.size(); i++) for (int i = 0; i < stringList.size(); i++)

ArrayList arraylist = new ArrayList(); 其实是
ArrayList<String> stringList = new ArrayList<String>();解糖后，类型擦除后的写法。

for(Iterator iterator = arraylist.iterator(); iterator.hasNext(); System.out.println(s1)) 其实是 for (String s : stringList) 这种for循环解糖后的写法。

Par conséquent, l'inférence de type de variable locale est également un sucre syntaxique fourni aux développeurs par Java 10. Bien que nous utilisions var dans le code pour définir, mais pour la machine virtuelle, il ne reconnaît pas cette var. Dans le processus de compilation du fichier java dans un fichier de classe, il résoudra le sucre et utilisera le type réel de la variable pour remplacer le var ( Tels que l'utilisation de la chaîne String pour remplacer la chaîne var). Pour la machine virtuelle, il n'est pas nécessaire d'apporter des modifications de compatibilité à var, car son cycle de vie se termine dans la phase de compilation. Le seul changement est que le compilateur doit ajouter une opération supplémentaire de résolution de sucre sur var pendant le processus de compilation.

Les étudiants intéressés peuvent écrire deux morceaux de code, un avec var et un sans var, puis comparer le bytecode compilé. Vous constaterez que c'est vraiment exactement la même chose. La figure ci-dessous est le résultat de ma comparaison avec l'outil diff.
J'ai décompilé l'inférence de type de variable locale de Java 10


语法糖（Syntactic Sugar），也称糖衣语法，是由英国计算机学家 Peter.J.Landin 发明的一个术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。简而言之，语法糖让程序更加简洁，有更高的可读性。

Quelle est la différence avec JavaScript

Beaucoup de gens savent qu'en JavaScript, la définition des variables est déclarée en utilisant var. Donc, dès que l'inférence de type de variable locale de Java 10 est sortie, quelqu'un a dit, n'est-ce pas une copie de JavaScript? N'est-ce pas la même chose que var dans JS?

En fait, c'est vraiment différent.

Tout d'abord, JavaScript est un langage faiblement typé (ou dynamiquement typé), c'est-à-dire que le type de variable est incertain. Vous pouvez utiliser la syntaxe "5" -4 en JavaScript, et son résultat est le nombre 1, où la chaîne et le nombre sont calculés. Si vous ne le croyez pas, ouvrez la console de votre navigateur et essayez-le:
J'ai décompilé l'inférence de type de variable locale de Java 10

Cependant, bien que var puisse être utilisé pour déclarer des variables en Java, il s'agit toujours d'un langage fortement typé. Grâce au code décompilé ci-dessus, nous savons déjà que var n'est qu'un sucre syntaxique fourni par Java aux développeurs.Enfin, après compilation, le type d'objet défini par var doit être défini comme le type inféré par le compilateur.

Cela affectera-t-il la lisibilité?

L'inférence de type de variable locale est probablement la plus critiquée pour sa lisibilité, car avant, lorsque nous définissons une variable, nous devons clairement spécifier son type, donc lorsque vous lisez le code, vous pouvez connaître son type en regardant son type déclaré. , Mais après tout, utilisez var, ce sera misérable. Il ne fait aucun doute que cela perdra une partie de la lisibilité. Cependant, l'utilisation de var pour déclarer des objets dans le code apporte également de nombreux avantages, tels qu'un code plus concis.

Avant qu'une nouvelle chose ne sorte, il y aura toujours toutes sortes de malaises. Maintenant, tout le monde sent que cette chose affecte aussi mon efficacité dans la lecture du code. Tout comme lorsque Taobao Mall vient de changer son nom pour Tmall, tout le monde pensait que c'était un nom fantôme. J'ai l'habitude d'écouter maintenant, tu penses que c'est plutôt bien?

Si tout le monde utilise var pour déclarer des variables, le nom de la variable devient plus important. À ce moment-là, tout le monde accordera plus d'attention à la lisibilité des noms de variables. De plus, je pense que dans un proche avenir, les principaux IDE lanceront la fonction de type inféré des variables d'affichage intelligentes. Par conséquent, à tous égards, certaines lacunes peuvent être comblées.

En bref, j'embrasse plus activement la fonction d'inférence de type variable locale.

En pensant

Enfin, je voudrais poser une autre question à laquelle tout le monde devrait réfléchir: l'inférence de type de variable locale semble être assez facile à utiliser, et puisque Java a décidé de la publier dans la nouvelle version, pourquoi devrait-elle limiter son utilisation? Les quelques scénarios connus dans lesquels var peut être utilisé pour déclarer des variables consistent à initialiser des variables locales, à améliorer l'index de la boucle for et à définir les variables locales de la boucle for traditionnelle. Il existe également plusieurs scénarios qui ne prennent pas en charge cette utilisation, tels que:
paramètres de méthode
Le constructeur de paramètre
renvoie le type d'
objets de variable de membre de méthode
donc ma question est, pourquoi ces restrictions Java, quelle considération est-ce? Les étudiants fiables sont récompensés. Tirez-vous sur ma planète de la connaissance gratuitement. Des discussions et des réponses sur cette partie des questions de réflexion seront également menées sur Knowledge Planet.

J'ai décompilé l'inférence de type de variable locale de Java 10

J'ai décompilé l'inférence de type de variable locale de Java 10

-MORE | Articles plus passionnants-

Si vous voyez cela, vous aimez cet article.

Ensuite, appuyez et maintenez le code QR pour suivre Hollis

Je suppose que tu aimes