Alle Beiträge von Christian Ullenboom

Über Christian Ullenboom

Ich bin Christian Ullenboom und Autor der Bücher ›Java ist auch eine Insel. Einführung, Ausbildung, Praxis‹ und ›Java SE 8 Standard-Bibliothek. Das Handbuch für Java-Entwickler‹. Seit 1997 berate ich Unternehmen im Einsatz von Java. Sun ernannte mich 2005 zum ›Java-Champion‹.

JDK 13 ist in Release Candidate Phase

Laut https://mail.openjdk.java.net/pipermail/jdk-dev/2019-August/003250.html:

Per the JDK 13 schedule [1], we are now in the Release Candidate phase.
The stabilization repository, jdk/jdk13, is open for P1 bug fixes per
the JDK Release Process (JEP 3) [2].  All changes require approval via
the Fix-Request Process [3].

If you’re responsible for any of the bugs on the RC candidate-bug list
[4] then please see JEP 3 for guidance on how to handle them.

We’ll tag the first Release Candidate build shortly.

- Mark


[1] https://openjdk.java.net/projects/jdk/13/#Schedule
[2] https://openjdk.java.net/jeps/3
[3] https://openjdk.java.net/jeps/3#Fix-Request-Process
[4] https://j.mp/jdk-rc

Weiteres unter http://www.tutego.de/java/jdk-13-java-13-openjdk13.html.

Google Guava 28.0 erschienen

Änderungen laut https://github.com/google/guava/releases/tag/v28.0:

  • collect: Added Duration-based overloads to some Queues methods. (21d06cf)
  • net: Added MediaType for „application/geo+json“. (36cd5cf)
  • net: Added a number of constants to HttpHeaders.
  • concurrent: Removed deprecated CheckedFuture and related utilities. (3dd22fe)
  • concurrent: Added Duration-based overloads to many methods.
  • concurrent: Removed @Beta from setFuture. (5ec1360)
  • concurrent: Added deprecated FluentFuture.from(FluentFuture) to point out redundant code. (f9f2807)
  • graph: Added GraphBuilder.immutable(),ValueGraphBuilder.immutable() and NetworkBuilder.immutable() for building immutable graphs in a fluent way.
  • J2ObjC: Fixed crashes from use of ImmutableMap.entrySet(). (74fc49f)

Termine öffentlicher Seminare in Dortmund mit Chr. Ullenboom für Q2 und Q3


Java Grundlagen (›JAVA1‹)

2.–5. Juli 2019 (KW 27), 5.–9. August 2019 (KW 32), 26.–30. August 2019 (KW 35), 16.–20. September 2019 (KW 38), 14.–18. Oktober 2019 (KW 42)



Java für Fortgeschrittene (›JAVA2‹)

15.–19. Juli 2019 (KW 29), 5.–9. August 2019 (KW 32), 26.–30. August 2019 (KW 35), 16.–20. September 2019 (KW 38), 14.–18. Oktober 2019 (KW 42)



Spring Boot (›SPRINGBOOT‹)

27.–29. Mai 2019 (KW 22), 17.–19. Juni 2019 (KW 25), 7.–9. August 2019 (KW 32), 28.–30. August 2019 (KW 35), 16.–18. Oktober 2019 (KW 42)



JavaScript für Web-Entwickler (›JAVASCRIPT‹)

27.–29. August 2019 (KW 35), 30. September–2. Oktober 2019 (KW 40)

Der Restwert-Operator %

Eine Ganzzahldivision muss nicht unbedingt glatt aufgehen, wie im Fall von 9/2. In diesem Fall gibt es den Rest 1. Diesen Rest liefert der Restwert-Operator (engl. remainder operator), oft auch Modulo genannt.[1] Die Operanden können auch negativ sein.

Beispiel: System.out.println( 9 % 2 );            // 1

Die Division und der Restwert richten sich in Java nach einer einfachen Formel: (int)(a/b) × b + (a%b) = a.

Beispiel: Die Gleichung ist erfüllt, wenn wir etwa a = 10 und b = 3 wählen. Es gilt: (int)(10/3) = 3 und 10 % 3 ergibt 1. Dann ergeben 3 * 3 + 1 = 10.

Aus dieser Gleichung folgt, dass beim Restwert das Ergebnis nur dann negativ ist, wenn der Dividend negativ ist; das Ergebnis ist nur dann positiv, wenn der Dividend positiv ist. Es ist leicht einzusehen, dass das Ergebnis der Restwert-Operation immer echt kleiner ist als der Wert des Divisors. Wir haben den gleichen Fall wie bei der Ganzzahldivision, dass ein Divisor mit dem Wert 0 eine ArithmeticException auslöst und bei Fließkommazahlen zum Ergebnis NaN führt.

System.out.println( „+5% +3  = “ + (+5% +3) );   //  2
System.out.println( „+5 / +3 = “ + (+5 / +3) );  //  1

System.out.println( „+5% -3  = “ + (+5% -3) );   //  2
System.out.println( „+5 / -3 = “ + (+5 / -3) );  // -1

System.out.println( „-5% +3  = “ + (-5% +3) );   // -2
System.out.println( „-5 / +3 = “ + (-5 / +3) );  // -1

System.out.println( „-5% -3  = “ + (-5% -3) );   // -2
System.out.println( „-5 / -3 = “ + (-5 / -3) );  //  1

Gewöhnungsbedürftig ist die Tatsache, dass der erste Operand (Dividend) das Vorzeichen des Restes definiert und niemals der zweite (Divisor).

Hinweis: Um mit value % 2 == 1 zu testen, ob value eine ungerade Zahl ist, muss value positiv sein, denn -3 % 2 wertet Java zu –1 aus. Der Test auf ungerade Zahlen wird erst wieder korrekt mit value % 2 != 0.

Restwert für Fließkommazahlen

Der Restwert-Operator ist auch auf Fließkommazahlen anwendbar, und die Operanden können wiederum negativ sein.

Beispiel: Teste, ob eine double-Zahl doch eine Ganzzahl ist: (d % 1) == 0. Wem das zu verrückst ist, der nutzt alternativ d == Math.rint(d).

Restwert für Fließkommazahlen und Math.IEEEremainder( ) *

Über die oben genannte Formel können wir auch bei Fließkommazahlen das Ergebnis einer Restwert-Operation leicht berechnen. Dabei muss beachtet werden, dass sich der Operator nicht so wie unter IEEE 754 verhält. Denn diese Norm schreibt vor, dass die Restwert-Operation den Rest von einer rundenden Division berechnet und nicht von einer abschneidenden. So wäre das Verhalten nicht analog zum Restwert bei Ganzzahlen. Java definiert den Restwert jedoch bei Fließkommazahlen genauso wie den Restwert bei Ganzzahlen. Wünschen wir ein Restwert-Verhalten, wie IEEE 754 es vorschreibt, so können wir die statische Bibliotheksmethode Math.IEEEremainder(…)[2] verwenden.

Auch bei der Restwert-Operation bei Fließkommazahlen werden wir niemals eine Exception erwarten. Eventuelle Fehler werden, wie im IEEE-Standard beschrieben, mit NaN angegeben. Ein Überlauf oder Unterlauf kann zwar vorkommen, aber nicht geprüft werden.

[1] Mathematiker unterscheiden die beiden Begriffe Rest und Modulo, da ein Modulo nicht negativ ist, der Rest in Java aber schon. Das soll uns aber egal sein.

[2] Es gibt auch Methoden, die nicht mit Kleinbuchstaben beginnen, wobei das sehr selten ist und nur in Sonderfällen auftritt. ieeeRemainder() sah für die Autoren nicht nett aus.

Die großen Umbenennungen: Java EE -> Jakarta EE

Quelle: https://blogs.eclipse.org/post/wayne-beaton/renaming-java-ee-specifications-jakarta-ee

  • Replace “Java” with “Jakarta” (e.g. “Java Message Service” becomes “Jakarta Message Service”);
  • Add a space in cases where names are mashed together (e.g. “JavaMail” becomes “Jakarta Mail”);
  • Add “Jakarta” when it is missing (e.g. “Expression Language” becomes “Jakarta Expression Language”); and
  • Rework names to consistently start with “Jakarta” (“Enterprise JavaBeans” becomes “Jakarta Enterprise Beans”).

Das heißt:

  • Jakarta APIs for XML Messaging
  • Jakarta Architecture for XML Binding
  • Jakarta API for XML-based Web Services
  • Jakarta Common Annotations
  • Jakarta Enterprise Beans
  • Jakarta Persistence API
  • Jakarta Contexts and Dependency Injection
  • Jakarta EE Platform
  • Jakarta API for JSON Binding
  • Jakarta Servlet
  • Jakarta API for RESTful Web Services
  • Jakarta Server Faces
  • Jakarta API for JSON Processing
  • Jakarta EE Security API
  • Jakarta Bean Validation
  • Jakarta Mail
  • Jakarta Beans Activation Framework
  • Jakarta Debugging Support for Other Languages
  • Jakarta Server Pages Standard Tag Library
  • Jakarta EE Platform Management
  • Jakarta EE Platform Application Deployment
  • Jakarta API for XML Registries
  • Jakarta API for XML-based RPC
  • Jakarta Enterprise Web Services
  • Jakarta Authorization Contract for Containers
  • Jakarta Web Services Metadata
  • Jakarta Authentication Service Provider Interface for Containers
  • Jakarta Concurrency Utlities
  • Jakarta Server Pages
  • Jakarta Connector Architecture
  • Jakarta Dependency Injection
  • Jakarta Expression Language
  • Jakarta Message Service
  • Jakarta Batch
  • Jakarta API for WebSocket
  • Jakarta Transaction API

JBoss EAP 7.2 mit Java EE 8-Untertützung freigegeben

Details bei Red Hat unter https://www.redhat.com/en/blog/announcing-general-availability-red-hat-jboss-enterprise-application-platform-72

Stichwörter:

  • greater compliance with Java Enterprise Edition (EE) 8
  • JBoss EAP 7.2 is Java EE 8 certified
  • Java EE 8 certification introduces new capabilities designed to improve portability and security of applications and the manipulation of JSON documents
  • enhancements related to the support of HTTP/2
  • JBoss EAP 7.2 also supports OpenJDK 11, Oracle JDK 11, Java SE 11
  • Red Hat offers supportfor OpenJDK 8 until 2023 and OpenJDK 11 until 2024.
  • Eclipse MicroProfile Config, a microservices library to manage application configurable parameters across environments
  • Eclipse MicroProfile REST Client, a microservices library designed to more easily invoke microservices in a type-safe manner
  • Eclipse MicroProfile OpenTracing, a microservices library to trace microservices-based applications
  • Eclipse MicroProfile Health, a microservices library to check the state of microservices-based applications
  • tighter integration with Red Hat OpenShift for clustered applications

 

Immutable-Objekte und Wither-Methoden

Objekte, dessen Zustände nicht verändert werden können, heißen immutable. Die Klassen deklarieren in so einem Fall keine öffentlichen Variablen und auch keine Methoden mit Seiteneffekten, die diese Zustände modifizieren könnten. Setter gibt es folglich nicht, nur vielleicht Getter.

Damit die Objekte ihre Werte bekommen, gibt es unterschiedliche Wege – parametrisierte Konstruktoren sind ein guter Weg. Die Belegungen lassen sich beim Konstruktoraufruf übergeben und so sehr gut direkt in finale Variablen schreiben. In der Java-Bibliothek gibt es eine Reihe solcher Klassen, die keinen parameterlosen Konstruktor besitzen, und nur einige parametrisierte, die Werte erwarten. Die im Konstruktor übergebenen Werte initialisieren das Objekt, und es behält diese Werte sein ganzes Leben lang. Zu den Klassen gehören zum Beispiel Integer, Double, Color, File oder Font.

Immutable-Objekte, die auch die equals(…)-Methode implementieren heißen Werteobjekt (engl. value object).

Wither-Methoden

Auch wenn sich Objekte mit Setten nicht ändern lassen, so soll es doch möglich sein, neue Objekte mit veränderten Zuständen zu erschaffen. Ein Blick auf die Klasse String zeigt zum Beispiel trim() und toUpperCase() – das Ergebnis sind neue Strings.

Um allgemein Zustandsvariablen zu verändern können Wither-Methoden verwendet werden; sie sind ähnlich wie Setter, nur verändern sie keinen Zustand am aktuellen Objekt, sondern führen zu einem neuen Objekt mit dem geänderten Zustand.

Getter Setter Wither
Typ getXXX() void setXXX(Typ xxx) ImmutableTyp withXXX(Typ xxx)

Namenskonvention der Getter, Setter, Wither für eine Property xxx

Dazu ein Beispiel. Ein Raum hat einen Namen und eine Größe. Die Exemplare sollen unveränderbar sein:

class Room {

  private final String name;

  private final int size;




  public Room( String name, int size ) {

    this.name = name;

    this.size = size;

  }




  public String getName() {

    return name;

  }




  public int getSize() {

    return size;

  }




  public Room withName( String name ) {

    return new Room( name, size );

  }




  public Room withSize( int size ) {

    return new Room( this, size );

  }

}