1. Sealed Classes

• Description: Sealed classes allow developers to restrict which classes can extend or implement a given class or interface. This provides a more controlled inheritance hierarchy.
• Use Case:
  • Define closed hierarchies for business logic, ensuring only specific subclasses are allowed.
  • Useful in modeling scenarios like a Payment hierarchy with subclasses such as CreditCardPayment, PaypalPayment, etc.
• Code Example:

public sealed class Payment permits CreditCardPayment, PaypalPayment {
   public abstract void process();
}

public final class CreditCardPayment extends Payment {
   @Override
   public void process() {
       // Implementation
   }
}

public final class PaypalPayment extends Payment {
   @Override
   public void process() {
       // Implementation
   }
}

Explanation of the Example:

1. sealed Keyword:
   • The Payment class is declared as sealed, restricting which classes can extend it.
   • The permits clause specifies the allowed subclasses: CreditCardPayment and PaypalPayment.
2. Final Subclasses:
   • Both CreditCardPayment and PaypalPayment are declared final, meaning no other class can extend them.
3. Benefits:
   • Clear, restricted hierarchy.
   • Better control over the design of the inheritance tree.
   • Improves readability and maintains a closed set of known implementations.

2. Pattern Matching for Switch (Preview)

• Description: Enhanced switch statements now support pattern matching, simplifying type-checking and extraction logic.
• Use Case:
  • Handle various types of objects in a single, concise block.
  • Improve readability and maintainability of complex decision logic.
• Code Example:

public static String formatValue(Object value) {
   return switch (value) {
       case Integer i -> "Integer: " + i;
       case String s -> "String: " + s;
       case null -> "Null value";
       default -> "Unknown type";
   };
}

Pattern Matching for switch was introduced as a preview feature in Java 17 but fully implemented and finalized in Java 19. The transition from a preview feature to a fully implemented feature in Java 19 reflects several improvements and enhancements that were made based on developer feedback and additional language design considerations.

Reasons for Full Implementation in Java 19:

1. Improved Language Design and Feedback:
   • When preview features are introduced in earlier versions (like Java 17), they are experimental and intended for developers to try out and provide feedback. This feedback is crucial in refining the feature before it becomes fully integrated.
   • After observing how the feature was being used in practice, the Java language team incorporated improvements, fixed bugs, and addressed limitations based on real-world usage.
2. Enhanced Pattern Matching Features:
   • Java 19 fully supports pattern matching for switch and integrates it more smoothly into the language, making it easier to use and more powerful. Some key improvements include:
     • Support for additional patterns like instanceof with type patterns, more advanced guards, and type checking.
     • Better handling of complex patterns, making it more useful in real-world scenarios.
     • Cleaner syntax: Reduces boilerplate code and allows for more concise, readable switch statements.
3. Language Consistency and Completeness:
   • Java 19 introduced additional enhancements, such as better handling of sealed classes with pattern matching in switch, which were part of other Java features (e.g., sealed classes in Java 17).
   • The Pattern Matching for switch feature in Java 19 brings language consistency, making it easier for developers to express patterns in their code without needing to mix multiple language features (like instanceof and switch).
4. Support for Multiple Pattern Types:
   • Java 19 allows developers to match multiple patterns in a single case. This provides more flexibility, allowing developers to express logic more succinctly.
   • For example, you can match both String and Integer types within the same case label, which was not as straightforward in earlier versions.
5. Performance Optimizations:
   • Along with new features and syntax, Java 19 includes optimizations for performance, making the feature faster and more efficient in terms of both memory usage and execution speed. This is important when dealing with complex pattern matching logic in production systems.

Key Differences Between Java 17 (Preview) and Java 19 (Full Implementation):

In Java 17 (Preview):

• Limited pattern matching: Supported only type patterns and certain simple guards (e.g., instanceof checks).
• Preview mode: As a preview feature, the syntax and behavior were subject to change, and it required enabling preview features with the --enable-preview flag.
• No support for complex patterns: More complex patterns, such as matching against multiple conditions or pattern nesting, were not supported.

In Java 19 (Full Implementation):

• Full support for pattern matching: Includes multiple pattern types, such as type patterns, object patterns, and the ability to combine patterns using logical operators.
• More powerful and expressive: Developers can now use complex patterns with switch expressions without additional boilerplate code, improving readability and maintainability.
• Better performance and reliability: Improved optimizations have been made for the feature, making it faster and more stable in production environments.

Example of Pattern Matching for switch in Java 19:

In Java 19, the switch statement has been enhanced to support full pattern matching. Here's an example:

public class PatternMatchingSwitchExample {
   public static void main(String[] args) {
       Object obj = "Hello";

       String result = switch (obj) {
           case Integer i -> "Integer: " + i;
           case String s -> "String: " + s;
           case null -> "Null value";  // Handling null
           default -> "Unknown type";
       };

       System.out.println(result);
   }
}
 

3. Text Blocks

• Description: Introduced in Java 15 and part of Java 17, text blocks simplify handling of multi-line strings.
• Use Case:
  • Write cleaner code for SQL queries, JSON, XML, or HTML templates.
  • Improve readability and reduce boilerplate code.
• Code Example:

package org.niteshsynergy.java17;

public class Demo03TextBlocks {

     public static void main(String[] args) {
         // Example 1: SQL Query
         String sqlQuery = """
                 SELECT id, name, email
                 FROM users
                 WHERE status = 'active'
                 ORDER BY created_at DESC;
                 """;
         System.out.println("SQL Query:");
         System.out.println(sqlQuery);

         // Example 2: JSON String
         String jsonExample = """
                 {
                     "name": "John Doe",
                     "age": 30,
                     "email": "johndoe@example.com",
                     "roles": ["user", "admin"]
                 }
                 """;
         System.out.println("JSON Example:");
         System.out.println(jsonExample);

         // Example 3: HTML Template
         String htmlTemplate = """
                 <!DOCTYPE html>
                 <html>
                 <head>
                     <title>Sample Page</title>
                 </head>
                 <body>
                     <h1>Welcome to Text Blocks</h1>
                     <p>This is a sample page using text blocks.</p>
                 </body>
                 </html>
                 """;
         System.out.println("HTML Template:");
         System.out.println(htmlTemplate);
     }
}

4. New macOS Rendering Pipeline (JEP 382)

• Description: The new rendering pipeline replaces Apple's deprecated OpenGL.
• Use Case:
  • Ensures compatibility and performance improvements for GUI applications on macOS.
• Complex Project Application:
  • Enterprise-grade GUI applications for data visualization.

Key Benefits of JEP 382:

1. Improved Graphics Performance: The Metal-based pipeline offers better performance and efficiency compared to the older OpenGL pipeline.
2. Better Support for Modern macOS Hardware: Metal is optimized for macOS's hardware, leading to smoother graphics rendering.
3. JavaFX Improvements: Applications that rely on JavaFX for GUI rendering will benefit from this new pipeline, as Metal provides more efficient rendering paths.
4. Removal of OpenGL Dependency: The older OpenGL-based pipeline was deprecated, and this transition ensures that Java stays up to date with Apple's API ecosystem.

5. Enhanced Random Number Generators (JEP 356)

• Description: New interfaces and classes for random number generation, such as RandomGenerator and support for stream-based programming.
• Use Case:
  • Cryptography, simulations, gaming, or data sampling.
• Code Example:

import java.util.random.RandomGenerator;
import java.util.random.RandomGeneratorFactory;

public class EnhancedRandomExample {

   public static void main(String[] args) {
       // Using the RandomGenerator interface
       RandomGenerator randomGenerator = RandomGenerator.of("Xoshiro256PlusPlus");
       
       // Generate random numbers
       System.out.println("Random int: " + randomGenerator.nextInt());
       System.out.println("Random double: " + randomGenerator.nextDouble());
       System.out.println("Random long: " + randomGenerator.nextLong());

       // Generate a stream of random integers
       System.out.println("Stream of random integers:");
       randomGenerator.ints(5, 1, 100).forEach(System.out::println);

       // Using RandomGeneratorFactory to explore available generators
       System.out.println("\nAvailable Random Generators:");
       RandomGeneratorFactory.all().forEach(factory -> {
           System.out.println(factory.name());
       });

       // Using a jumpable generator
       RandomGenerator.JumpableGenerator jumpableGenerator =
               RandomGenerator.of("Xoroshiro128Plus") instanceof RandomGenerator.JumpableGenerator
                       ? (RandomGenerator.JumpableGenerator) RandomGenerator.of("Xoroshiro128Plus")
                       : null;

       if (jumpableGenerator != null) {
           System.out.println("\nRandom number from JumpableGenerator: " + jumpableGenerator.nextInt());
           jumpableGenerator.jump();
           System.out.println("Random number after jump: " + jumpableGenerator.nextInt());
       }
   }
}
 

Explanation:

1. Using RandomGenerator Interface:
   • Create an instance of a specific random generator (Xoshiro256PlusPlus in this case).
   • Call methods like nextInt(), nextDouble(), or nextLong() for random numbers.
2. Stream Generation:
   • Use methods like ints() to generate a stream of random integers.
3. Explore Available Generators:
   • Use RandomGeneratorFactory.all() to list all available generators.
4. Jumpable Generators:
   • A jumpable generator can "jump" ahead in the sequence for reproducibility or performance.

6. Removal of Deprecated Features

• Description:
  • Deprecated features like RMI Activation, Applet API, and others have been removed, ensuring a cleaner ecosystem.
• Use Case:
  • Encourages migration to modern alternatives like web technologies.

7. Foreign Function & Memory API (Preview)

• Description: Enables Java applications to interoperate with code and data outside the JVM safely.
• Use Case:
  • Integrate with C libraries for performance-critical applications like machine learning or multimedia processing.
• Code Example:

try (MemorySegment segment = MemorySegment.allocateNative(1024)) {
   MemoryAccess.setIntAtOffset(segment, 0, 42);
   int value = MemoryAccess.getIntAtOffset(segment, 0);
   System.out.println(value);
}
 Foreign Function & Memory API (Preview), introduced in Java 16 as a preview feature and refined in later versions, provides a way for Java programs to interact with native code (such as C or C++ libraries) and manage memory outside of the Java heap. It was designed to replace the old Java Native Interface (JNI) and Direct ByteBuffers with a safer, more efficient, and easier-to-use API.

The goal of this API is to allow Java programs to interface with native code in a way that is more straightforward and avoids the complexities of traditional JNI.

Key Components:

1. Foreign Function Access: Allows Java code to invoke functions written in native languages (e.g., C, C++) directly.
2. Memory Access: Provides the ability to allocate and access memory outside the Java heap, which can be useful for performance-critical applications.
3. No JVM Garbage Collection: Native memory is managed manually, meaning it won't be collected by the JVM's garbage collector.
4. Safe Access: The API is designed to be safer and easier to use than older native memory access methods.

Full Implementation Example of the Foreign Function & Memory API:

Let's walk through a simple example where Java interacts with native code (using C) and accesses memory outside the heap. We will demonstrate using this preview feature to allocate memory, write to it, and read from it using the Foreign Memory Access API.

Note: Make sure you are using Java 16 or later and enable preview features.

Example: Calling a Native Function

1. Native Code (C Code): We'll write a simple C function and call it from Java.

C Code (Library) - nativeLib.c

#include <stdio.h>

void sayHello() {
   printf("Hello from native code!\n");
}

int addNumbers(int a, int b) {
   return a + b;
}

Compile the C code into a shared library:
gcc -shared -o libnativeLib.dylib -fPIC nativeLib.c
 

This command compiles the C code into a shared library that can be loaded by the Java program.

Java Code Using the Foreign Function & Memory API

Here’s a Java program that interacts with the native code:

Java Code - ForeignFunctionExample.java

import java.lang.foreign.*;
import java.lang.invoke.*;
import java.nio.file.*;
import java.util.*;

public class ForeignFunctionExample {
   // Define the layout for a function (using C signatures)
   private static final MemoryLayout ADD_NUMBERS_LAYOUT = MemoryLayout.ofStruct(
       ValueLayout.JAVA_INT, // return type: int
       ValueLayout.JAVA_INT, // first parameter: int
       ValueLayout.JAVA_INT  // second parameter: int
   );

   public static void main(String[] args) {
       // Load the shared library (on macOS, assuming .dylib format)
       Path nativeLibPath = Path.of("libnativeLib.dylib");

       // Access the foreign function from the native library
       try (var scope = MemoryScope.openConfined()) {
           // Load the native library
           var linker = Linker.nativeLinker();
           var symbol = linker.lookup(nativeLibPath, "addNumbers");

           // Create a function handle for 'addNumbers'
           MethodHandle addNumbersHandle = MethodHandles.lookup()
               .findStatic(symbol, "addNumbers", MethodType.methodType(int.class, int.class, int.class));

           // Call the native function
           try {
               int result = (int) addNumbersHandle.invoke(5, 10);
               System.out.println("Sum from native code: " + result);
           } catch (Throwable throwable) {
               throwable.printStackTrace();
           }
       } catch (Throwable e) {
           e.printStackTrace();
       }
   }
}
 

Explanation of the Code:

1. Loading the Native Library: The Linker.nativeLinker() method is used to load the native shared library and access the function symbols defined in the library (in this case, addNumbers).
2. Creating the Function Handle: We use MethodHandles.lookup() to create a MethodHandle for the native function. The method signature is specified using MethodType.
3. Calling the Native Function: The native function is called using the MethodHandle.invoke() method.

Foreign Memory API Usage:

If you want to allocate and manipulate native memory (outside the Java heap), you can use the MemorySegment and MemoryAccess classes, which are part of the Foreign Memory API.

Example of Allocating and Writing to Native Memory:

import java.lang.foreign.*;

public class MemoryAccessExample {
   public static void main(String[] args) {
       try (var scope = MemoryScope.openConfined()) {
           // Allocate native memory
           MemorySegment segment = MemorySegment.allocateNative(4);  // Allocating 4 bytes (e.g., for an integer)

           // Write to the memory segment
           MemoryAccess.setInt(segment, 0, 42);  // Write the value 42 at the start of the segment

           // Read from the memory segment
           int value = MemoryAccess.getInt(segment, 0);
           System.out.println("Value from native memory: " + value);  // Should print 42
       }
   }
}
 

Explanation of the Memory Access Example:

• Allocating Native Memory: The MemorySegment.allocateNative() method allocates memory outside of the Java heap (native memory).
• Writing to Native Memory: The MemoryAccess.setInt() method writes the integer value 42 into the allocated memory.
• Reading from Native Memory: The MemoryAccess.getInt() method reads the value from the native memory segment.

8. Deprecating Finalization (JEP 421)

• Description: Finalization is deprecated to prepare for its removal, encouraging use of alternative resource management techniques like try-with-resources.
• Use Case:
  • Avoid reliance on unpredictable garbage collection for resource cleanup.

9. Context-Specific Deserialization Filters

• Description: Simplifies configuration of deserialization filters for security.
• Use Case:
  • Protect against deserialization vulnerabilities in distributed systems.

import com.niteshsynergy.java17

import java.io.*;
import java.util.logging.*;

public class ContextSpecificDeserializationFilter {

   // Define a custom filter for deserialization
   public static final ObjectInputFilter MY_FILTER = new ObjectInputFilter() {
       @Override
       public Status checkInput(ObjectInputFilter.FilterInfo filterInfo) {
           // Example: only allow objects of type "String"
           if (filterInfo.serialClass() != null && filterInfo.serialClass() == String.class) {
               return Status.ALLOWED;
           }
           return Status.REJECTED;
       }
   };

   public static void main(String[] args) {
       // Example object to serialize and deserialize
       String originalObject = "This is a safe object.";

       // Serialize the object
       try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("serialized_object.ser"))) {
           oos.writeObject(originalObject);
           System.out.println("Object serialized successfully!");
       } catch (IOException e) {
           e.printStackTrace();
       }

       // Deserialize the object using the custom filter
       try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("serialized_object.ser"))) {
           // Apply the filter when deserializing
           ois.setObjectInputFilter(MY_FILTER);
           Object deserializedObject = ois.readObject();

           if (deserializedObject instanceof String) {
               System.out.println("Deserialized Object: " + deserializedObject);
           } else {
               System.out.println("Rejected object during deserialization.");
           }
       } catch (IOException | ClassNotFoundException e) {
           e.printStackTrace();
       }
   }
}
 

Explanation of the Code:

1. Serialization Filter Definition (MY_FILTER):
   • A filter is defined to check the class type of the object being deserialized.
   • In this example, only String objects are allowed to be deserialized. If any other class is encountered, the object is rejected.
2. Serialization:
   • An object (String originalObject) is serialized into a file serialized_object.ser using ObjectOutputStream.
3. Deserialization with Context-Specific Filter:
   • When reading the object back from the file using ObjectInputStream, the filter MY_FILTER is applied using the setObjectInputFilter method.
   • The filter rejects any non-String objects during deserialization.
4. Result:
   • If the deserialized object is a String, it is printed.
   • If it is not a String or if the filter rejects it, a message indicating rejection is printed.

Complex Project Implementation

Let’s consider a financial application leveraging Java 17 features:

Features Used:

• Sealed Classes for modeling transaction types.
• Pattern Matching for Switch for processing various event types.
• Text Blocks for generating SQL and JSON responses.
• RandomGenerator for generating secure IDs.
• Foreign Memory API for handling large datasets.

Sample Code:

public sealed interface Transaction permits Deposit, Withdrawal, Transfer {}

public final class Deposit implements Transaction {
   private final double amount;
   public Deposit(double amount) { this.amount = amount; }
}

public final class Withdrawal implements Transaction {
   private final double amount;
   public Withdrawal(double amount) { this.amount = amount; }
}

public final class Transfer implements Transaction {
   private final double amount;
   private final String account;
   public Transfer(double amount, String account) {
       this.amount = amount;
       this.account = account;
   }
}

public static void handleTransaction(Transaction tx) {
   switch (tx) {
       case Deposit d -> System.out.println("Processing deposit: " + d.amount);
       case Withdrawal w -> System.out.println("Processing withdrawal: " + w.amount);
       case Transfer t -> System.out.println("Transferring " + t.amount + " to " + t.account);
       default -> throw new IllegalArgumentException("Unknown transaction");
   }
}
 

             Want to donate ? Pay → https://razorpay.me/@niteshsynergy