{"id":25448,"date":"2021-12-07T17:00:00","date_gmt":"2021-12-07T16:00:00","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=25448"},"modified":"2026-04-15T14:52:47","modified_gmt":"2026-04-15T12:52:47","slug":"java-16-features","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/java\/java-16-features\/","title":{"rendered":"Java 16 Features (mit Beispielen)"},"content":{"rendered":"\n

Mit dem am 16. M\u00e4rz 2021 ver\u00f6ffentlichten Java 16 erreichen zwei neue Sprach-Features aus Project Amber die Produktionsreife: \"Pattern Matching for instanceof\" und Records.<\/p>\n\n\n\n

Insgesamt wurden f\u00fcr dieses Release beeindruckende 17 JDK Enhancement Proposals umgesetzt. <\/p>\n\n\n\n

Ich habe wie immer versucht die Erweiterungen nach Relevanz f\u00fcr die t\u00e4gliche Programmierarbeit zu sortieren. D. h. du findest am Anfang des Artikels die bereits erw\u00e4hnten neuen Sprach-Features, wichtige \u00c4nderungen an der JDK-Klassenbibliothek und neue Tools. Danach folgen Performance-Verbesserungen, Preview- und Incubator-Features und zuletzt sonstige \u00c4nderungen.<\/p>\n\n\n\n

Wie immer verwende ich die englischen Bezeichnungen der JEPs, da eine \u00dcbersetzung ins Deutsche hier eher verwirrt als dass sie einen Mehrwert bringt.<\/p>\n\n\n\n

Pattern Matching for instanceof<\/h2>\n\n\n\n

Kommen wir zur ersten gro\u00dfen Neuerung in Java 16. Nach zwei Preview-Runden wurde \"Pattern Matching for instanceof\" durch JDK Enhancement Proposal 394<\/a> als produktionsreif ver\u00f6ffentlicht.<\/p>\n\n\n\n

Diese nunmehr vierte Spracherweiterung aus Project Amber<\/a> eliminiert die Notwendingkeit von Casts nach einer instanceof<\/code>-Pr\u00fcfung durch eine implizite Typumwandlung.<\/p>\n\n\n\n

Was das bedeutet, erkl\u00e4re ich am besten an einem Beispiel. Der folgende Code pr\u00fcft die Klasse eines Objekts. Ist das Objekt ein String, der au\u00dferdem l\u00e4nger als f\u00fcnf Zeichen ist, wird er in Gro\u00dfbuchstaben umgewandelt und ausgegeben. Ist das Objekt hingegen ein Integer, wird die Zahl quadriert und ausgegeben.<\/p>\n\n\n

Object obj = getObject();\n<\/span><\/span>\n<\/span><\/span>if<\/span> (obj instanceof<\/span> String) {\n<\/span><\/span>  String s = (String) obj;\n<\/span><\/span>  if<\/span> (s.length() > 5<\/span>) {\n<\/span><\/span>    System.out.println(s.toUpperCase());\n<\/span><\/span>  }\n<\/span><\/span>} else<\/span> if<\/span> (obj instanceof<\/span> Integer) {\n<\/span><\/span>  Integer i = (Integer) obj;\n<\/span><\/span>  System.out.println(i * i);\n<\/span><\/span>}\n<\/span><\/span><\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
In den Zeilen 4 und 9 m\u00fcssen wir das Objekt nach String<\/code> bzw. Integer<\/code> casten. Wie haben uns so an diese Schreibweise gew\u00f6hnt, dass wir den notwendigen Boilerplate-Code gar nicht mehr in Frage stellen.<\/p>\n\n\n\n
Wie es seit Java 16 besser geht, zeigt der folgende Code: <\/p>\n\n\n
if<\/span> (obj instanceof<\/span> String s) {          \/\/ <-- implicit cast to String s<\/span>\n<\/span><\/span>  if<\/span> (s.length() > 5<\/span>) {\n<\/span><\/span>    System.out.println(s.toUpperCase());\n<\/span><\/span>  }\n<\/span><\/span>} else<\/span> if<\/span> (obj instanceof<\/span> Integer i) {  \/\/ <-- implicit cast to Integer i<\/span>\n<\/span><\/span>  System.out.println(i * i);\n<\/span><\/span>}\n<\/span><\/span><\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Anstatt explizite Casts zu programmieren, m\u00fcssen wir lediglich einen Variablennamen hinter die instanceof<\/code>-Pr\u00fcfung setzen (Zeilen 1 und 5). Diese Variable ist dann vom in instanceof<\/code> gepr\u00fcften Zieltyp und innerhalb des if<\/code>-Blocks sichtbar.<\/p>\n\n\n\n
Wir k\u00f6nnen noch einen Schritt weitergehen und die ersten beiden if<\/code>-Statements kombinieren:<\/p>\n\n\n
if<\/span> (obj instanceof<\/span> String s && s.length() > 5<\/span>) {\n<\/span><\/span>  System.out.println(s.toUpperCase());\n<\/span><\/span>} else<\/span> if<\/span> (obj instanceof<\/span> Integer i) {\n<\/span><\/span>  System.out.println(i * i);\n<\/span><\/span>}\n<\/span><\/span><\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Der Code ist mit f\u00fcnf statt neun Zeilen nun deutlich pr\u00e4gnanter. Durch Pattern Matching wurde Redundanz eliminiert und die Lesbarkeit erh\u00f6ht.<\/p>\n\n\n\n
Pattern Matching for instanceof \u2013 Scope<\/h4>\n\n\n\n
Eine gematchte Variable ist nur innerhalb des if<\/code>-Blocks bekannt. Das ist logisch, denn nur wenn der if<\/code>-Vergleich positiv ausf\u00fcllt, kann die Variable auf den gew\u00fcnschten Typ gecastet werden.<\/p>\n\n\n\n
Wenn ein Feld mit gleichem Namen innerhalb der Klasse existiert, dann wird dieses Feld durch eine Pattern-Matching-Variable \"geshadowed\". Was das bedeutet, zeigt folgendes Beispiel:<\/p>\n\n\n
public<\/span> class<\/span> PatternMatchingScopeTest<\/span> <\/span>{\n<\/span><\/span>\n<\/span><\/span>  public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n<\/span><\/span>    new<\/span> PatternMatchingScopeTest().processObject(\"Happy Coding!\"<\/span>);\n<\/span><\/span>  }\n<\/span><\/span>\n<\/span><\/span>  private<\/span> String s = \"Hello, world!\"<\/span>;\n<\/span><\/span>\n<\/span><\/span>  private<\/span> void<\/span> processObject<\/span>(Object obj)<\/span> <\/span>{\n<\/span><\/span>    System.out.println(s);           \/\/ Prints \"Hello, world!\"<\/span>\n<\/span><\/span>    if<\/span> (obj instanceof<\/span> String s) {\n<\/span><\/span>      System.out.println(s);         \/\/ Prints \"Happy Coding!\"<\/span>\n<\/span><\/span>      System.out.println(this<\/span>.s);    \/\/ Prints \"Hello, world!\"<\/span>\n<\/span><\/span>    }\n<\/span><\/span>  }\n<\/span><\/span>}\n<\/span><\/span><\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Was gibt dieses Programm aus?<\/p>\n\n\n\n