Java Class File Format Versions

By I Wayan Saryada in Basic 0 Comment

A compiled Java .class file starts with a fixed header (0xCAFEBABE), followed by a pair of numbers: minor_version and major_version. The pair (commonly written as major.minor, e.g., 52.0) identifies which Java platform level the bytecode targets. The JVM uses this to decide whether it can load the class. If the class was compiled for a newer platform than the JVM supports, you’ll get UnsupportedClassVersionError.

Why It Matters:

  • Backward compatibility: Newer JVMs can generally run older class files, but not the other way around.
  • Build reproducibility: Ensuring all modules target the same release avoids subtle runtime issues.
  • Tooling alignment: IDEs, build tools, containers, and CI images must agree on the target level to prevent version skew.

Quick mapping highlights:

  • Java 8 → 52.0
  • Java 11 → 55.0
  • Java 17 (LTS) → 61.0
  • Java 21 (LTS) → 65.0
  • Java 22 → 66.0, 23 → 67.0, 24 → 68.0, 25 → 69.0, 26 → 70.0, 27 → 71.0, 28 → 72.0
JDK Version Class File Format Version
1.0 45.0
1.1 45.3
1.2 46.0
1.3 47.0
1.4 48.0
5 49.0
6 50.0
7 51.0
8 52.0
9 53.0
10 54.0
11 55.0
12 56.0
13 57.0
14 58.0
15 59.0
16 60.0
17 61.0
18 62.0
19 63.0
20 64.0
21 65.0
22 66.0
23 67.0
24 68.0
25 69.0
26 70.0
27 71.0
28 72.0

Note:

  • Early JDK branding used 1.x (e.g., 1.5, 1.6) but these correspond to modern names 5, 6, etc. The table above reflects the modern naming for 5+.
  • There was no official 1.9 brand; Java 9 is simply 9 → 53.0 (already shown above).

How to check a class file’s version

  • Using javap (JDK tool): 
    javap -v path/to/Some.class | find "major"

    Look for a line like major version: NN (e.g., 52 for Java 8). For modern compilers, minor is typically 0.

  • Reading the header directly (forensics style):

    1. Confirm magic bytes: CA FE BA BE.
    2. Next 2 bytes: minor_version.
    3. Next 2 bytes: major_version (e.g., 0x003D = 61 → Java 17).

How to compile for a specific Java level

  • Recommended (single flag): 
    javac --release 21 -d out $(find src -name "*.java")

    --release consistently sets language features, APIs, and the class file version.

  • Legacy approach (not preferred, can mismatch APIs):

    javac -source 1.8 -target 1.8 -bootclasspath "%JAVA8_HOME%\\jre\\lib\\rt.jar" -extdirs ""
  • Maven (maven-compiler-plugin): 
    <plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>3.11.0</version>
  <configuration>
      <release>21</release>
  </configuration>
</plugin>
  • Gradle (Groovy DSL): 
    java {
  toolchain {
      languageVersion = JavaLanguageVersion.of(21)
  }
}
// Or explicitly set the target bytecode
tasks.withType(JavaCompile).configureEach {
  options.release = 21
}

Common failure and how to fix

  • Symptom:
    • java.lang.UnsupportedClassVersionError: … has been compiled by a more recent version of the Java Runtime.
  • Causes:
    • Running on an older JRE/JDK than the class file requires.
    • Mixed toolchains or inconsistent --release/target levels in a multi-module build.
  • Fixes:
    • Upgrade the runtime to meet the class file’s major.minor level; or
    • Recompile with an older target using --release <level> that matches your deployment runtime; and
    • Standardize toolchains via Maven/Gradle toolchains and CI images to avoid skew.

Tips and caveats

  • Prefer --release over -source/-target because it also validates against platform APIs for that release.
  • Preview features do not change the class file version; they require --enable-preview at compile and run time, but the mapping still follows the JDK’s version.
  • When publishing libraries, choose the lowest --release that matches your supported runtime matrix to maximize compatibility; consider multi-release JARs if you need newer APIs while keeping a baseline.

How to Simplify Control Flow with Enhanced Switch Statements in Java 25

By I Wayan Saryada in Basic, Java 25 0 Comment

Java 25 introduced Enhanced switch Statements to simplify control flow, making type checks, value comparisons, and complex branching cleaner and more expressive.

Here’s a guide to simplify control flow using this feature:

Key Enhancements in switch

  1. Type Pattern Matching: Directly match and work with variable types in patterns.
  2. Guarded Patterns: Add conditions (when) to patterns for finer control.
  3. Exhaustive Matching: Ensures all possible branches are accounted for (especially useful with sealed classes).
  4. Simplified Null Handling: Handles null without redundant checks.
  5. Nested Patterns: Combine patterns within switch for complex logic.
  6. Constant Matching: Patterns can match constants, combining value comparison and type matching.

How switch is Enhanced

1. Type Pattern Matching

No need for explicit type casting; switch can directly match types and assign to variables.

public static String handleInput(Object input) {
    return switch (input) {
        case String s -> "It's a String: " + s;
        case Integer i -> "It's an Integer: " + (i + 5);
        case Double d -> "It's a Double: " + (d * 2);
        case null -> "Input is null!";
        default -> "Unknown type";
    };
}
  • Why? Simplifies logic by avoiding explicit instanceof checks and casting.

2. Guarded Patterns

Patterns now include when clauses for additional checks within cases.

public static String analyzeNumber(Number number) {
    return switch (number) {
        case Integer i when i > 0 -> "Positive Integer: " + i;
        case Integer i -> "Non-Positive Integer: " + i;
        case Double d when d.isNaN() -> "It's NaN";
        case Double d -> "A Double: " + d;
        default -> "Unknown type of Number";
    };
}
  • Why? Adds flexibility to handle sub-conditions in patterns.

3. Exhaustiveness with sealed Classes

Combining sealed class hierarchies with switch enforces completeness at compile-time by covering all subclasses.

public sealed interface Shape permits Circle, Rectangle {}

public record Circle(double radius) implements Shape {}
public record Rectangle(double width, double height) implements Shape {}

public static String describeShape(Shape shape) {
    return switch (shape) {
        case Circle c -> "Circle with radius: " + c.radius();
        case Rectangle r -> "Rectangle: " + r.width() + "x" + r.height();
    };
}
  • Why? Ensures all cases are handled, or the compiler alerts you of missing subclasses.

4. Null Handling Simplification

Design cases explicitly for null without separate checks.

public static void handleString(String str) {
    switch (str) {
        case null -> System.out.println("String is null!");
        case "Hello" -> System.out.println("Greeting identified!");
        default -> System.out.println("Unrecognized input.");
    }
}
  • Why? Eliminates external if (str == null) checks, merging all logic into switch.

5. Nested Patterns for Complex Scenarios

switch supports nested patterns for deeper matching logic.

public static String processNested(Object obj) {
    return switch (obj) {
        case Circle(double r) when r > 10 -> "Large Circle, radius: " + r;
        case Rectangle(double w, double h) when w == h -> "Square with side: " + w;
        case Rectangle(double w, double h) -> "Rectangle: " + w + "x" + h;
        default -> "Unknown Shape";
    };
}
  • Why? Makes complex decision trees concise and readable.

Advantages of Enhanced switch

  • Cleaner Syntax: Removes verbose if-else or legacy switch cases.
  • More Declarative: Focus on what you’re branching on, not how.
  • Compile-Time Safety: Ensures all branches are accounted for with exhaustive checks.
  • Improved Null Safety: Explicit null cases reduce runtime errors.
  • Seamless with Modern Java Features: Works beautifully with records, sealed classes, and type inference.

When to Use Enhanced switch

  • Type-based control flows where type and values matter (e.g., handling polymorphism elegantly).
  • Complex branching conditions are consolidated into a clean declarative structure.
  • Improved readability and maintainability for large branching logic.

This feature is a step toward making Java code more concise, safer, and expressive!

How to Write Cleaner Code with String Templates in Java

By I Wayan Saryada in Basic, Java 25 0 Comment

String templates in Java 25 introduce a cleaner, more efficient, and safer way to work with strings. They allow embedding expressions inside strings without relying on concatenation or external APIs. Using string templates can lead to code that is easier to understand and maintain.

Here’s how you can write cleaner and more efficient code with string templates in Java 25:

1. Basics of String Templates

String templates allow you to define a string that contains placeholders for expressions. These placeholders are evaluated at runtime. In Java 25, this is done using the STR.""" syntax (or StringTemplate API).

Example:

String name = "John";
int age = 30;

String greeting = STR."""
    Hello, my name is \{name} and I am \{age} years old.
    """;
System.out.println(greeting);

Output:

Hello, my name is John and I am 30 years old.

2. Key Features

  • Dynamic Expressions
    You can embed any expression within the \{} placeholders inside the template.

    int x = 10;
int y = 20;

String result = STR."""
    Sum of x and y is \{x + y}.
    """;
System.out.println(result);
  • Multiline Support
    String templates natively support multiline strings and formatting, making it easier to work with larger templates.

    String paragraph = STR."""
    This is a multiline
    string template with
    expressions like \{"Java " + 25}.
    """;

3. Benefits Over Traditional String Handling

a. Eliminates Boilerplate

Previously, concatenating variables into strings required explicit concatenation or String.format(). This is no longer needed.

// Before Java 25 - verbose
String name = "Alice";
String message = "Hello, " + name + "!";
// or
String message = String.format("Hello, %s!", name);

// Java 25
String message = STR."Hello, \{name}!";

b. Improved Readability

String templates allow templates to resemble the final output, improving readability.

c. Type-Safe

String templates are type-safe, ensuring that runtime errors related to improper formatting are minimized.

4. Compatibility with Existing APIs

String templates can simplify working with APIs like SQL or HTML without extensive external libraries.

Example (SQL):

String tableName = "users";
String query = STR."""
    SELECT * FROM \{tableName}
    WHERE age > 18
    ORDER BY name;
    """;
System.out.println(query);

Example (HTML):

String title = "Welcome";
String template = STR."""
    <html>
        <head><title>\{title}</title></head>
        <body><h1>Hello, \{title}</h1></body>
    </html>
    """;
System.out.println(template);

5. Advanced Use Cases

a. Use with External Formatting Libraries

String templates integrate well with JSON or XML serialization/deserialization.

Example (JSON):

String username = "john_doe";
int userID = 123;

String json = STR."""
    {{
        "username": "\{username}",
        "id": \{userID}
    }}
    """;
System.out.println(json);

b. Avoid Code Injection

String templates are safer, as they encourage proper escaping of user-provided data when combined with API interactions such as SQL or HTML. Proper escaping ensures no code injection vulnerabilities.

6. Custom Formatters

String templates in Java 25 can leverage custom formatters for advanced needs. This allows developers to define how specific types (like dates or numbers) are formatted in the string.

Custom formatting is achieved by extending the template processor.

Example: Formatting a date into a readable format:

import java.time.LocalDate;

LocalDate today = LocalDate.now();

String message = STR."""
   Today's date is \{today.toString()}.
   """;
System.out.println(message);

To include formatting logic, custom processors can modify such outputs.

7. Example: Building APIs with Readable Responses

Here’s an example of using string templates for building responses in web APIs:

public String buildUserResponse(String username, String email) {
    return STR."""
        {
            "username": "\{username}",
            "email": "\{email}"
        }
        """;
}

// Usage
String response = buildUserResponse("alice", "[email protected]");
System.out.println(response);

8. Combining String Templates with Switch Expressions

Java 25 also brings improvements to switch expressions, which can combine well with string templates.

int code = 404;

String message = STR."""
    Status: \{
        switch (code) {
            case 200 -> "Success";
            case 404 -> "Not Found";
            case 500 -> "Server Error";
            default -> "Unknown";
        }
    }
    """;
System.out.println(message);

Summary: Cleaner Code with String Templates

  • Readability: Cleaner and less verbose syntax.
  • Efficiency: Reduces reliance on external formatting libraries or manual concatenation.
  • Safety: Minimized risk of runtime errors and injection vulnerabilities.
  • Integration: Seamlessly used with existing APIs and libraries.

Adopting Java 25 string templates improves the workflow significantly, making your apps cleaner and less error-prone.

How to use record patterns with instanceof in Java 25

By I Wayan Saryada in Basic, Java 25 0 Comment

Java 25 introduces improvements such as record patterns with instanceof, which allow more concise and expressive type matching and data extraction in one step. Here’s a guide on how to use them:

What are record patterns?

A record pattern enables matching and extracting components of a record class, which is essentially a class with immutable data. Record patterns simplify operations by combining type checking and field extraction syntactically.

Using instanceof with Record Patterns

In Java 25, you can use a record pattern directly with instanceof to both:
1. Match the type of the object.
2. Decompose its contents in a single expression.

Example of Record Patterns with instanceof

record Point(int x, int y) {}

public class Main {
    public static void main(String[] args) {
        Object obj = new Point(10, 20);

        // Using instanceof with a record pattern
        if (obj instanceof Point(int x, int y)) {
            System.out.println("Point coordinates: x = " + x + ", y = " + y);
        } else {
            System.out.println("Not a Point object");
        }
    }
}

Explanation

  • obj instanceof Point(int x, int y):
    • Pattern Matching: Verifies if obj is an instance of the Point record.
    • Decomposition: Extracts the x and y fields of the record into variables x and y.

As a result:

  • If obj matches the type, the fields are extracted automatically in the same step.
  • There’s no need to cast obj to Point explicitly or manually call getters.

Nesting Record Patterns

Record patterns can also be nested for more complex records containing other records or collections.

Example: Nested Record Patterns

record Rectangle(Point topLeft, Point bottomRight) {}

public class Main {
    public static void main(String[] args) {
        Object obj = new Rectangle(new Point(0, 0), new Point(10, 10));

        if (obj instanceof Rectangle(Point(int x1, int y1), Point(int x2, int y2))) {
            System.out.println("Rectangle corners: (" + x1 + ", " + y1 + ") to (" + x2 + ", " + y2 + ")");
        } else {
            System.out.println("Not a Rectangle object");
        }
    }
}

Explanation

  • Rectangle(Point(int x1, int y1), Point(int x2, int y2)) is a nested pattern:
    • Matches top-level Rectangle.
    • Decomposes its topLeft and bottomRight fields into Point objects.
    • Further extracts x and y coordinates from each Point.

Benefits

  1. Conciseness: Eliminates the need for explicit casting or redundant getter calls.
  2. Readability: Patterns declaratively show what is being matched and extracted.
  3. Flexibility: Works seamlessly with nested structures.

Good-to-Know Details

  1. Exhaustive Matching: Combine switch with record patterns for exhaustive, cleaner matching: 
    void printShapeInfo(Object shape) {
   switch (shape) {
       case Point(int x, int y) -> System.out.println("Point: (" + x + ", " + y + ")");
       case Rectangle(Point topLeft, Point bottomRight) -> System.out.println("Rectangle with corners: " +
               topLeft + " to " + bottomRight);
       default -> System.out.println("Unknown shape");
   }
}
  2. Null Handling: instanceof with patterns doesn’t match null values directly. An explicit null check is still required.

  3. Restrictions: The immutability of records ensures safety and predictability when decomposing data and matching patterns.

Conclusion

The introduction of record patterns in Java 25 significantly enhances pattern matching and makes working with immutable objects far more intuitive and concise. Whether you’re matching simple records or nested structures, this feature saves you from boilerplate code and improves code readability.

How to use improved pattern matching for switch in Java 25

By I Wayan Saryada in Basic, Java 25 0 Comment

Java 25 introduces an improved feature for pattern matching with switch, further streamlining type checks, instance checks, and value comparisons.

Here’s how you can effectively use the enhanced pattern matching for switch in Java 25:

Key Features

  1. Exhaustive Matching: Ensures that all possible branches are accounted for.
  2. Simplification of Null Handling: Handles null conditions without extra boilerplate.
  3. Nested Patterns in Switch: Allows patterns to be nested for cleaner and more expressive logical flows.
  4. Constant Matching: Can combine constants with patterns.
  5. Sealed Class Support: Works seamlessly with sealed classes, auto-detecting subclasses for exhaustive pattern checks.

Syntax Examples

1. Type Pattern Matching

Allows you to handle specific types directly in a switch.

public static String process(Object obj) {
    return switch (obj) {
        case String s -> "It's a String: " + s;
        case Integer i -> "It's an Integer: " + (i + 10);
        case null -> "It's null!";
        default -> "Unknown type!";
    };
}

2. Guarded Patterns

You can add additional conditions to patterns with when clauses.

public static String process(Number num) {
    return switch (num) {
        case Integer i when i > 0 -> "Positive Integer: " + i;
        case Integer i -> "Other Integer: " + i;
        case Double d -> "Double: " + d;
        default -> "Unknown Number type!";
    };
}

3. Exhaustive Matching with sealed Classes

For sealed class hierarchies, switch ensures all subclasses are accounted for.

public sealed interface Shape permits Circle, Rectangle {}

public record Circle(double radius) implements Shape {}
public record Rectangle(double length, double width) implements Shape {}

public static String shapeInfo(Shape shape) {
    return switch (shape) {
        case Circle c -> "Circle with radius: " + c.radius();
        case Rectangle r -> "Rectangle with dimensions: " + r.length() + " x " + r.width();
    };
}

In this case, if you miss a subclass (like Rectangle), the compiler will throw an exhaustiveness error.

4. Null Handling Simplification

Switch patterns now handle null explicitly or exclude it in non-nullable cases.

public static void handleInput(String input) {
    switch (input) {
        case null -> System.out.println("Input is null!");
        case "SpecificValue" -> System.out.println("Matched SpecificValue");
        default -> System.out.println("Fallback case");
    }
}

Benefits of Improved Pattern Matching

  • Cleaner Code: Avoid type casts and complex if-else chains.
  • More Readable: Logic becomes more declarative and expressive.
  • Compile-Time Safety: Exhaustive checking ensures safer code.
  • Null-Safety: Simplifies handling of null values in branching.

These improvements make switch not just a control-flow statement but a powerful tool for type- and value-based pattern matching.