JDK 25: update notes and example

Author: wesleyegberto

README.md

@@ -16,6 +16,8 @@ A project to explore more about the new features from Java 8 through Java 21.
   * Remove the 32-bit x86 Port
   * Module Import Declarations
   * Compact Source Files and Instance Main Methods
+  * Flexible Constructor Bodies
+  * Structured Concurrency (preview 5)
 
 * [Java 24](java-24/) (Mar, 2025)
   * Generational Shenandoah (experimental)

java-25/FlexibleConstructorBodiesExample.java

@@ -0,0 +1,60 @@
+/*
+ * To run: `java FlexibleConstructorBodiesExample.java`
+ */
+public class FlexibleConstructorBodiesExample {
+
+	public static void main(String[] args) {
+		System.out.println("Pet:\n" + new Dog("Shih Tzu"));
+	}
+}
+
+abstract class Animal {
+	protected final String domain;
+	protected final String kingdom;
+	protected final String phylum;
+	protected final String subphylum;
+	protected final String phylumClass;
+	protected final String family;
+
+	private final String representation;
+
+	protected Animal(String phylum, String subphylum, String phylumClass, String family) {
+		this.domain = "Eukaryota";
+		this.kingdom = "Animalia";
+		this.phylum = phylum;
+		this.subphylum = subphylum;
+		this.phylumClass = phylumClass;
+		this.family = family;
+
+		this.representation = getClassification();
+	}
+
+	public abstract String getClassification();
+
+	public String toString() {
+		return this.representation;
+	}
+}
+
+class Dog extends Animal {
+	private final String order;
+	private final String species;
+	private final String breed;
+
+	Dog(String breed) {
+		// we can perform validation (fail fast)
+		if (breed == null || breed.isBlank()) {
+			throw new IllegalArgumentException("Breed cannot be null or empty");
+		}
+		this.order = "Carnivora";
+		this.species = "Dog";
+		this.breed = breed;
+		super("Chordata", "Vertebrata", "Mammals", "Canidae");
+	}
+
+	public String getClassification() {
+		return "Domain: %s / Kingdom: %s / Phylum: %s / Subphylum: %s / Class: %s / Order: %s/ Species: %s / Breed: %s".formatted(
+			domain, kingdom, phylum, subphylum, phylumClass, order, species, breed
+		);
+	}
+}

java-25/FlexibleConstructorBodiesInnerClassExample.java

@@ -0,0 +1,84 @@
+/*
+ * To run: `java FlexibleConstructorBodiesInnerClassExample .java`
+ */
+public class FlexibleConstructorBodiesInnerClassExample {
+	public static void main(String[] args) {
+		var e1 = new Example1();
+		var i1 = e1.new Inner1();
+
+		var e2 = new Example2();
+
+		var e3 = Example3.VALUE_3;
+	}
+}
+
+class Base {
+	Base() {
+		System.out.println("Base constructor");
+	}
+}
+
+class Example1 {
+	private int counter;
+
+	void hello() {
+		System.out.println("Hello from Example1");
+	}
+
+	class Inner1 extends Base {
+		Inner1() {
+			// allowed cause when a new instance is created, the outer already exists
+			Example1.this.counter++;
+			hello();
+			super();
+			System.out.println("Inner1 constructor");
+		}
+	}
+
+	Example1() {
+		// Error: cannot reference this before supertype constructor has been called
+		// new Inner1();
+
+		super();
+	}
+}
+
+class Example2 {
+	static class Inner2 extends Base {
+		Inner2() {
+			System.out.println("Inner2 constructor");
+		}
+	}
+
+	Example2() {
+		System.out.println("Example2 constructor");
+		new Inner2();
+		super();
+	}
+}
+
+enum Example3 {
+	VALUE_1(1), VALUE_2(2), VALUE_3(3);
+
+	private final int value;
+	private final int valueSquared;
+
+	Example3(int v, int vSquared) {
+		System.out.printf("Enum - %d ^ 2 = %d%n", v, vSquared);
+		this.value = v;
+		this.valueSquared = vSquared;
+	}
+
+	Example3(int v) {
+		var vv = v * v;
+		this(v, vv);
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public int getValueSquared() {
+		return valueSquared;
+	}
+}

java-25/README.md

@@ -6,8 +6,10 @@ To run each example use: `java --enable-preview --source 25 <FileName.java>`
 
 * [502](https://openjdk.org/jeps/502) - Stable Values (Preview)
 * [503](https://openjdk.org/jeps/503) - Remove the 32-bit x86 Port
+* [505](https://openjdk.org/jeps/505) - Structured Concurrency (Fifth Preview)
 * [511](https://openjdk.org/jeps/511) - Module Import Declarations
 * [512](https://openjdk.org/jeps/512) - Compact Source Files and Instance Main Methods
+* [513](https://openjdk.org/jeps/513) - Flexible Constructor Bodies
 
 ## Features
 
@@ -89,6 +91,28 @@ To run each example use: `java --enable-preview --source 25 <FileName.java>`
         * provides methods: `print(Object)`, `println(Object)`, `println()`, `readln(String)` and `readln()`
         * this class uses return from `System.console()` to print and read from the default input and output streams
         * we can use with: `IO.println("Hello World")`
+* **Flexible Constructor Bodies**
+    * promotion to standard without change
+    * allow statements that do not reference the instance being created to appear before an explicit constructor invocation
+    * will allow to use statements that use, transform or verify values before call `super`
+    * the code before the `super` lives in pre-construction context:
+        * can perform any statements that don't use any member of the instance being created (or its hierarchy or outter/inner classes that depends on the instance)
+    * we can:
+        * can access static members
+        * initialize fields in the same class before explicitly invoking a constructor
+            * this will allow a superclass never executes code with use subclass values with their default value (`0`, `false` or `null`)
+        * if the class is an inner class, it can access members of its enclosing class (like `Outer.this.field++`)
+            * the outer class instance already exists
+    * inicialization flow:
+    ```
+    C prologue
+    --> B prologue
+        --> A prologue
+            --> Object constructor body
+        --> A epilogue
+    --> B epilogue
+    C epilogue
+    ```
 
 ## Links