Detaillierte Erläuterung der mit Zucker überzogenen Java-Syntax (Syntactic Sugar)

Mit Zucker überzogene Syntax, auch syntaktischer Zucker genannt. Es handelte sich ursprünglich um einen Begriff, der vom britischen Informatiker Peter J. Landin erfunden wurde. Syntaktischer Zucker bezieht sich auf eine bestimmte Art von Syntax, die den Code durch einfaches Packen prägnant und lesbar macht. Er kann beim Kompilieren verwendet werden, indem die gleiche einfache Syntax beibehalten wird.
Wie der Name schon sagt, ist syntaktischer Zucker wie eine Zuckerschicht, die den Code prägnant macht. Die virtuelle Maschine unterstützt diese Art von Syntax nicht. Bevor die virtuelle Maschine ausgeführt wird, wird diese Art von Syntax in eine gängigere und einfachere Syntax kompiliert, die Funktion bleibt jedoch unverändert.
In Java sind die am häufigsten verwendeten syntaktischen Zucker die folgenden:

1. Generika und Typlöschung

2. Automatische Installation Boxing und Unboxing

3. foreach-Schleife

4. Variable Parameter

5. Bedingte Kompilierung

6. Innere Klasse

7. Enum-Klasse und Schalter

8. Assertion-Anweisung

Werfen wir einen Blick nacheinander auf die funktionale Verwendung jedes Syntaxzuckers und sein tatsächliches Prinzip

(1) Generika und Typlöschung

Es gibt keine Generika Klassen in der Java Virtual Machine haben einen entsprechenden Basistyp in der Java Virtual Machine. Das Folgende ist eine Analyse von Generika und Prinzipien.

Detailliertes Erklärungsportal für generische Klassen: http://www.php.cn/java-article-354231.html

(2) Automatische Installation Einpacken und Auspacken

Im Java-Code können wir die acht Grundtypen oft nicht direkt verwenden, sondern die entsprechenden Verpackungsklassen (auch Wrapper genannt) verwenden. Die Namen dieser Objekte sind auch leicht zu merken : Integer, Long, Byte, Double, Float, Character, Boolean, Short. Das einfachste Beispiel sind Generika. Da Basistypen nach dem Löschen nicht in Object gespeichert werden können, müssen Wrapper-Klassen als Typparameter verwendet werden:

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

Autoboxing-Prozess: Verwenden Sie sie für Basistypen. Der entsprechende Verpackungstyp wird gepackt sodass der Grundtyp Objekteigenschaften aufweist.
Automatischer Unboxing-Prozess: Im Gegensatz zum Boxing-Prozess wird der Verpackungstyp in einen Basistyp umgewandelt.

Laienhaft ausgedrückt: Das Einpacken und Auspacken erleichtert Programmierern die Konvertierung zwischen gepackten Klassen und Basisklassen. Sie sparen ein paar Sätze und vereinfachen den Code Die Konvertierung ist wirklich nervig und die Vorteile des automatischen Ein- und Auspackens liegen auf der Hand.

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++; //实际插入一句拆箱，再自增计算，再装箱

In Verpackungsklassen wie Integer muss die Methode equal zum Vergleichen von Werten verwendet werden. Andernfalls erfolgt der Vergleich, ob die Adressen der beiden Objekte im selben Bereich gespeichert sind. Verwenden Sie == zum Vergleichen. Abhängig vom zu packenden Objekt ist das Ergebnis entweder wahr oder falsch.

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

Es ist erwähnenswert, dass Wrapper-Klassen auch ein guter Ort sind, um statische Methoden wie die Typkonvertierung zu platzieren:

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

(3) foreach-Schleife

Java bietet eine supereinfache Schleifenmethode, die foreach-Schleife. Als Schleifenmethode ohne Index kann die foreach-Schleife nur alle Elemente durchlaufen, ohne selektiv zu sein, aber die einfache Schreibmethode ist immer noch viel praktischer. In einer Datenstruktur ohne Index wie HashMap ist die foreach-Schleife besser als die for Schleife. Viel besser als while-Schleife. Was wird also mit der foreach-Schleife implementiert? Die Antwort ist Iterator.

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

Es ist leicht herauszufinden, dass der Iterator zum Durchlaufen aller Elemente verwendet wird, aber die tatsächliche Menge an Code nimmt im Vergleich zur foreach-Schleife erheblich zu. Syntaxzucker spielt eine Rolle bei der Vereinfachung des Codes . , unverzichtbarer Beitrag.

(4) Parameter variabler Länge

Nach Java1.5 wird ein Methodenaufruf mit variablen Parametern bereitgestellt, wodurch die Tatsache aufgehoben wird, dass die Parameter nur fest sein können Nummer. Peinliche Situation. Es klingt mysteriös, aber wir verwenden fast jeden Tag die Methode mit Parametern variabler Länge, wie zum Beispiel die Zeichenfolgenformatierung:

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

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

Das Wesen des Parameters variabler Länge besteht darin, den letzten Parameter variabler Länge durch When zu ersetzen Wenn Sie Object[] ausführen, wird der Inhalt immer wieder derselbe sein.

(5) Bedingte Kompilierung

Bedingte Kompilierung ist eine Java Virtual Machine, die den Code vereinfacht. Sie entfernt fehlerhaften Verzweigungscode basierend auf dem Wahr oder Falsch von booleschen Konstanten. Stück. Dieser Effekt kann nur durch die Verwendung einer If-Anweisung mit einer konstanten Bedingung erreicht werden. Auch dieser ist leicht zu verstehen.

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

(6) Interne Klassen

Es gibt keine internen Klassen in der virtuellen Maschine. Alle internen Klassen sind durch bestimmte Methoden zu gewöhnlichen Klassen geworden.

Detaillierte Erläuterung des internen Klassenportals: http://www.php.cn/java-article-354230.html

(7) Aufzählungsklasse Es gibt auch C++-ähnliche Aufzählungstypen in Java wie switch

, aber objektiv gesehen sind sie nicht so einfach zu verwenden wie in C++. Aufzählungstypen können eine begrenzte Anzahl benannter Werte enthalten, und Variablen dieses Typs können deklariert werden:

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

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

Die Aufzählungsklasse ist auch eine Art syntaktischer Zucker. In der virtuellen Maschine gibt es keine Aufzählungsklasse. JVM Erkenne es auch nicht. Zunächst erben alle Aufzählungsklassen von der Klasse java.lang.Enum. Zur Kompilierungszeit konvertiert der Compiler die Aufzählungsklasse direkt in eine echte Unterklasse von Aufzählung. Jeder Wert in der Aufzählungsklasse wird durch den Konstruktor in eine Instanz umgewandelt.

//构造器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);

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

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

（八）断言语句

断言语句是在java的测试阶段普遍使用的一种语句，在1.4版本发布，而其本身也是一种语法糖。

（九）总结

在java中有很多糖衣语法，这些语法在不改变功能的情况下方便了我们的工作，提高了我们的效率。对于这些语法的内部实际处理虽然不一定用得到，但是有些了解还是很好的。语法糖是指那种在虚拟机中不存在但是我们可以这样编写代码的语法，并不一定只有上述的几种，但是上述是其中较为常用的。

 以上就是java糖衣语法（Syntactic Sugar）详解的内容，更多相关内容请关注PHP中文网（www.php.cn）！