Java 15: sealed type

Author: wesleyegberto

java-15/README.md

@@ -7,6 +7,14 @@ To run each example use: `java --enable-preview --source 15 <FileName.java>`
 ### Language
 
 * Sealed types
+  * Restrict which types can extend/implement a type
+  * Constraints:
+    * The sealed class and its permitted subclasses must belong to the same module, and, if declared in an unnamed module, the same package.
+    * Every permitted subclass must directly extend the sealed class.
+    * Every permitted subclass must choose a modifier to describe how it continues the sealing initiated by its superclass:
+      * `final`
+      * `sealed`
+      * `non-sealed` (back to a normal class open to extensibility)
 * Pattern matching for `instanceof` (second preview)
 * Text blocks (standard)
 * Records (second preview)

java-15/SealedTypesExample.java

@@ -7,41 +7,58 @@ public static void main(String[] args) {
 		var player = new Player();
 		var entity = player.getCollidingEntity();
 
-		switch (entity) {
-			case Player:
-				player.move();
-				entity.move();
-				break;
-			case Enemy:
-				player.die();
-				break;
-			case Object:
-				object.move();
-				break;
-			// we dont need to do this (nor ifs) - because we restricted the implementations types (we know them)
-			// default:
-			// 	throw IllegalStateException("Unexpected entity");
+		if (entity instanceof Player p) {
+			player.move();
+			p.move();
+		} else if (entity instanceof Enemy e) {
+			player.kill(e);
+		} else if (entity instanceof SceneryObject o) {
+			o.move();
 		}
+		// we dont need to do this (nor ifs) - because we restricted the implementations types (we know them)
+		// else {
+		// 	throw IllegalStateException("Unexpected entity");
+		// }
 	}
 }
 
 /**
  * Sealed types will help us to restrict which types can extend/implement a type.
  * Will allow us to write less verbose polymorphic code.
+ *
+ * Constraints:
+ * - The sealed class and its permitted subclasses must belong to the same module, and, if declared in an unnamed module, the same package.
+ * - Every permitted subclass must directly extend the sealed class.
+ * - Every permitted subclass must choose a modifier to describe how it continues the sealing initiated by its superclass:
+ *     - `final`
+ *     - `sealed`
+ *     - `non-sealed` (back to a normal class open to extensibility)
  */
-sealed abstract class GameEntity
-	permits Player, Enemy, Object {}
+sealed abstract class GameEntity permits Player, Enemy, SceneryObject {
+	public void move() {
+		System.out.println("Moving");
+	}
+
+	public void destroy() {
+		System.out.println("Destroying");
+	}
+}
 
-class Player extends GameEntity {
+final class Player extends GameEntity {
 	/**
 	 * Returns the entity which is colling with the player.
 	 */
 	public GameEntity getCollidingEntity() {
 		// obscure logic
 		return new Enemy();
 	}
+
+	public void kill(GameEntity killedBy) {
+		// obscure death
+		System.out.println("Killing");
+	}
 }
 
-class Enemy extends GameEntity {}
+final class Enemy extends GameEntity {}
 
-class Object extends GameEntity {}
+non-sealed class SceneryObject extends GameEntity {}