Syntaxe enrobée de sucre, également appelée sucre syntaxique. C'était à l'origine un terme inventé par l'informaticien britannique Peter J. Landin. Le sucre syntaxique fait référence à un certain type de syntaxe. Ce type de syntaxe rend le code concis et lisible grâce à un emballage simple. Il peut être utilisé lors de la compilation en « décompressant le sucre syntaxique » tout en conservant la même syntaxe simple à compiler.
Comme son nom l'indique, le sucre syntaxique est comme une couche de sucre qui rend le code concis. La machine virtuelle ne prend pas en charge ce type de syntaxe. Avant l'exécution de la machine virtuelle, ce type de syntaxe sera compilé en une syntaxe plus populaire et plus simple, mais la fonction reste inchangée.
En java, les sucres syntaxiques couramment utilisés sont les suivants :

Génériques et effacement de type

Installation automatique Boxing et déballage

boucle foreach

Paramètres variables

Compilation conditionnelle

Classe interne

classe d'énumération et commutateur

Déclaration d'assertion

Jetons un coup d'œil à l'utilisation fonctionnelle de chaque sucre syntaxique et à son principe réel un par un

(1) Génériques et effacement de type

Il n'y a pas de générique classes dans la machine virtuelle Java. Chaque type a un type de base correspondant dans la machine virtuelle Java. Ce qui suit est une analyse des génériques et des principes.

Portail d'explication détaillée des classes génériques : http://www.php.cn/java-article-354231.html

(2) Installation automatique Boxing et unboxing

Dans le code Java, nous ne pouvons souvent pas utiliser directement les huit types de base, mais utiliser leurs classes d'empaquetage correspondantes (également appelées wrappers). Ces objets enveloppent les classes Les noms sont également faciles à retenir. : Entier, Long, Octet, Double, Flottant, Caractère, Booléen, Court. L'exemple le plus simple est celui des génériques. Comme le type de base ne peut pas être stocké dans Object après effacement, les classes wrapper doivent être utilisées comme paramètres de type :

List<int> list = new ArrayList<>();//errorList<Integer> list = new ArrayList<>();//ok

Copier après la connexion

Processus d'autoboxing : utilisez-les pour les types de base. Le type d'empaquetage correspondant est. emballé de manière à ce que le type de base ait des caractéristiques d’objet.
Processus de déballage automatique : Contrairement au processus de mise en boîte, le type d'emballage est converti en type de base.

En termes simples, le boxing et le unboxing permettent aux programmeurs de convertir plus facilement entre les classes packagées et les classes de base. Ils enregistrent quelques phrases et simplifient le code. Parfois, il y a une phrase supplémentaire dans le code. la conversion est vraiment ennuyeuse, et les avantages du boxing et du unboxing automatiques sont évidents.

List<Integer> list = new ArrayList<>();list.add(1);list.add(Integer.valueOf(1));//实际操作 自动装箱int n = list.get(0);
int m = list.get(0).intValue();//实际操作 自动拆箱Integer p = 1;
p++; //实际插入一句拆箱，再自增计算，再装箱

Copier après la connexion

Dans les classes d'empaquetage telles que Integer, la méthode égale doit être utilisée pour comparer les valeurs. Sinon, la comparaison consiste à savoir si les adresses des deux objets sont stockées dans la même zone. Utilisez == pour comparer. Selon l'objet empaqueté, le résultat est vrai ou faux.

Integer a = 1000;Integer b = 1000;System.out.println(a==b); 
// 输出：falseSystem.out.println(a.equals(b)); //输出：true

Copier après la connexion

Il convient de mentionner que les classes wrapper sont également un bon endroit pour placer des méthodes statiques telles que la conversion de type :

int x =Integer.parseInt("111"); // x=111

Copier après la connexion

(3) boucle foreach

Java fournit une méthode de boucle super simple, la boucle foreach. En tant que méthode de boucle sans index, la boucle foreach ne peut parcourir que tous les éléments sans être sélective, mais la méthode d'écriture simple est toujours beaucoup plus pratique. Dans une structure de données sans index telle que HashMap, la boucle foreach est meilleure que la boucle for. boucle Bien mieux que la boucle while. Alors, qu’est-ce qui est utilisé pour implémenter la boucle foreach ? La réponse est Itérateur.

for(int i : list){
    System.out.println(i);
}

//实际迭代器实现for (Iterator localIterator = list.iterator(); localIterator.hasNext(); ) { 
    int sub = ((Integer)localIterator.next()).intValue(); 
    System.out.println(sub);}

Copier après la connexion

Il est facile de comprendre que l'itérateur est utilisé pour parcourir tous les éléments, mais la quantité réelle de code augmente beaucoup par rapport à la boucle foreach qui joue un rôle en rendant le code pratique. . , apport indispensable.

(4) Paramètres de longueur variable

Après java1.5, un appel de méthode avec des paramètres variables est fourni, rompant avec le fait que les paramètres ne peuvent être qu'un paramètre fixe numéro. Situation délicate. Cela semble mystérieux, mais nous utilisons la méthode des paramètres de longueur variable presque tous les jours, comme le formatage de chaîne :

public void foo(String str,Object...args){...}//方法原型

System.out.printf("%d",1);
System.out.printf("%d,%s", 12,"a");//方法中的变长参数必须位于最后一个位置

Copier après la connexion

L'essence du paramètre de longueur variable est de remplacer le dernier paramètre de longueur variable par When en faisant Object[], le contenu sera le même encore et encore.

(5) Compilation conditionnelle

La compilation conditionnelle est une machine virtuelle Java qui simplifie le code. Elle supprime le code de branche incorrect en fonction du vrai ou du faux des constantes booléennes. morceau. Cet effet ne peut être obtenu qu'en utilisant une instruction If avec une condition constante. Celui-ci est également facile à comprendre.

if(true)  
{  
    System.out.println("true");  
}  
else {  
    System.out.println("false");  
}  
//实际条件编译System.out.println("true");

Copier après la connexion

(6) Classes internes

Il n'y a pas de classes internes dans la machine virtuelle Toutes les classes internes sont devenues des classes ordinaires grâce à certaines méthodes.

Explication détaillée du portail des classes internes : http://www.php.cn/java-article-354230.html

(7) Classe d'énumération Il existe également des types d'énumération de type C en Java tels que switch

, mais objectivement, ils ne sont pas aussi utiles que c. Les types d'énumération peuvent inclure un nombre limité de valeurs nommées, et des variables de ce type peuvent être déclarées :

package Syntactic;public enum Size {
    S,M,L,XL
}

Size s = Size.S; //声明一个s，值为枚举类型中的S

Copier après la connexion

La classe d'énumération est aussi une sorte de sucre de syntaxe. Il n'y a pas de classe d'énumération dans la machine virtuelle, JVM Je ne le reconnais pas non plus. Tout d'abord, toutes les classes d'énumération héritent de la classe java.lang.Enum. Au moment de la compilation, le compilateur convertira directement la classe d'énumération en une véritable sous-classe d'Enum. Chaque valeur de la classe d'énumération est transformée en instance via le constructeur.

//构造器protected Enum(String name, int ordinal) {...}
//第一个参数为枚举值，第二个参数为这个枚举值默认的顺序
//下面是在编译时，实际操作的将枚举值实例化的过程
new Enum<Size>("S",0);new Enum<Size>("M",1);
new Enum<Size>("L",2);new Enum<Size>("XL",3);

Copier après la connexion

与此同时，既然枚举类型是语法糖，那么也就有switch用枚举值作为判断，也是一种语法糖。既然枚举类型是语法糖，在虚拟机中并不存在这种语法，switch中的枚举自然也是语法糖，那么它的原理是什么呢？

首先我们要分析一下switch能够用什么来判断。1.char、byte、int、short类型，2.枚举类型，3.字符串字面量。在这些之中一定有一种类型是枚举类型实际采用的判断方式。实际上，枚举类型采用的判断方式是int（short）类型。我们刚才说过，在每个枚举类型实例化的过程中都会贴上一个顺序的序号的“标签”。new Enum<Size>("S",0)在编译的过程中，编译器把这个序号作为他们的标记来替换switch中的枚举类型。