How do I Read User Input in a Compact Java 25 Program?

By Wayan in Basic, Java 25 0 Comment

Java 25 (via JEP 512: Compact Source Files and Instance Main Methods, finalized in Java 25) makes reading user input dramatically simpler. You no longer need a class declaration, a public static void main(String[] args) signature, or even System.out.println / Scanner boilerplate.

The New IO Class

Java 25 introduces the java.lang.IO class, which is automatically imported in compact source files. It provides three convenient static methods:

Method Purpose
IO.print(x) Print without newline
IO.println(x) Print with newline
IO.readln(prompt) Print a prompt and read a line from stdin

Compact Example

Here’s a compact Java 25 program that reads user input:

void main() {
    String username = IO.readln("Username: ");
    String password = IO.readln("Password: ");
    int result = Integer.parseInt(IO.readln("What is 2 + 2: "));

    if (username.equals("admin") && password.equals("secret") && result == 4) {
        IO.println("Welcome to Java Application");
    } else {
        IO.println("Invalid username or password, access denied!");
    }
}

Key Points

  • No class declaration required — the file becomes an implicitly declared class.
  • No String[] args — you can just write void main().
  • No import statements — java.base and java.lang.IO are auto-imported.
  • No Scanner — IO.readln(...) handles the prompt and line read in one call.
  • The method can be void main() or void main(String[] args); static is optional.

Running It

Save the code as Login.java and run it directly (no compile step needed):

java Login.java

When You Still Need Scanner

IO.readln only returns String. If you need typed input like int, double, etc., you either:

  1. Parse it yourself (as shown above with Integer.parseInt), or
  2. Fall back to java.util.Scanner for its nextInt(), nextDouble(), etc.

For most simple interactive programs, IO.readln + parsing is the cleanest approach in Java 25.

How do I Use an Instance main Method in Java 25?

By Wayan in Basic, Java 25 0 Comment

Java 25 finalizes JEP 512: Compact Source Files and Instance Main Methods, which was previewed in earlier JDK releases. This feature makes Java far more approachable for beginners and reduces boilerplate for small programs and scripts.

What Changed?

Traditionally, every Java program required this ceremony:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

With Java 25, the main method no longer needs to be:

  • public
  • static
  • Declared with a String[] args parameter

The New Rules

The JVM launcher now looks for a main method in this order of preference:

  1. static void main(String[] args) — traditional form
  2. static void main() — no parameters
  3. void main(String[] args) — instance method with args
  4. void main() — instance method, no args simplest form

If an instance main method is found, the JVM will implicitly create an instance of the enclosing class using its no-argument constructor, then invoke main on it.

Example 1: The Simplest Instance main

public class Hello {
    void main() {
        System.out.println("Hello from an instance main!");
    }
}

That’s the entire program. No static, no String[] args, no public.

Run it with:

java Hello.java

Example 2: Instance main With Fields and Helper Methods

Because main is now an instance method, it can freely use instance fields and call other instance methods without needing static everywhere:

public class Greeter {
    private final String greeting = "Hello";

    void main() {
        greet("Java 25");
        greet("Developers");
    }

    void greet(String name) {
        System.out.println(greeting + ", " + name + "!");
    }
}

Notice that greet is also a plain instance method — no static modifier needed.

Example 3: Combined With Compact Source Files

Java 25 also allows you to omit the enclosing class entirely (Compact Source File):

void main() {
    System.out.println("No class declaration required!");
}

Save this as Demo.java and run:

java Demo.java

The compiler implicitly wraps the code in a synthetic class for you.

Example 4: Instance main With Arguments

If you still need command-line arguments, just declare them:

public class Echo {
    void main(String[] args) {
        for (String arg : args) {
            System.out.println("Argument: " + arg);
        }
    }
}

Requirements & Caveats

  • The enclosing class must have an accessible no-argument constructor (the default one is fine if you don’t declare any constructor).
  • The class cannot be abstract.
  • If both a static and an instance main exist, the static one wins (per the resolution order above).
  • The instance main method cannot be private. It must be at least package-private.
  • To run a single source file directly (java Foo.java), you don’t need to compile first — the launcher handles it.

Why This Matters

  • Lower barrier for beginners — no need to explain public, static, String[] args, or classes on day one.
  • Cleaner scripts — small utilities and experiments become much more concise.
  • Smoother learning curve — students can gradually introduce classes, static, and access modifiers as they progress, rather than all at once.

Quick Comparison

Style Java ≤ 20 Java 25
public static void main(String[] args) ✅ Required ✅ Still works
static void main() ❌ ✅
void main(String[] args) ❌ ✅
void main() ❌ ✅
No class declaration ❌ ✅ (Compact Source File)

Instance main methods, combined with compact source files, make Java 25 one of the most beginner-friendly releases in the language’s history — while remaining fully backward compatible with every existing Java program.

How do I Run My First Java 25 Program Without Creating a Class?

By Wayan in Basic, Java 25 0 Comment

Java 25 makes it official: you can now write and run a program without declaring a class, without public static void main(String[] args), and even without import statements for common APIs. This feature is called Compact Source Files and Instance Main Methods (JEP 512, finalized in Java 25).

Let’s walk through it step by step.

1. Prerequisites

  • JDK 25 installed and available on your PATH
  • Verify with:
java --version
javac --version

Both should report version 25.

2. Write the Program

Create a plain text file named Hello.java. That’s it — no class, no public static, no ceremony:

void main() {
    IO.println("Hello, Java 25!");
}

A few things worth noticing:

  • There is no class declaration. The compiler wraps the code in an implicitly declared class for you.
  • main is an instance method (not static) and takes no arguments (the String[] args parameter is optional now).
  • IO.println(...) comes from the new java.io.IO class, which is auto-imported in compact source files — no System.out.println and no import needed.

3. Run It Directly with java

Since JDK 11, you can run a single-file source program directly. In Java 25, this works beautifully with the new compact form:

java Hello.java

Expected output:

Hello, Java 25!

No javac step is required. The launcher compiles the file in memory and runs it.

4. A Slightly Richer Example

You can still read input, do logic, and use any Java API — just without the boilerplate:

void main() {
    var name = IO.readln("What is your name? ");
    IO.println("Welcome, " + name + "!");

    for (int i = 1; i <= 3; i++) {
        IO.println("Count: " + i);
    }
}

Run it the same way:

java Hello.java

5. When You Outgrow It

Compact source files are meant for learning, scripting, and quick experiments. When your program grows, you can gradually add:

  1. A String[] args parameter to main when you need CLI arguments.
  2. Additional methods and fields directly in the file (they become members of the implicit class).
  3. Finally, an explicit class declaration — at which point you have a regular Java source file.

The transition is smooth because the language rules are a strict superset of traditional Java.

6. Common Pitfalls

Issue Cause Fix
error: class ... is public, should be declared in a file named ... You added public to a helper class in the same file Remove public — the implicit class is unnamed
IO cannot be resolved You’re not on JDK 25 (or using an older preview flag) Upgrade to JDK 25; no --enable-preview needed anymore
main not found Wrong signature (e.g., returns int) Use void main() or void main(String[] args)

Summary

To run your first Java 25 program without creating a class:

  1. Install JDK 25.
  2. Create Hello.java containing just a void main() method.
  3. Use IO.println(...) — no imports needed.
  4. Run it with java Hello.java.

This is the shortest path from “I have JDK installed” to “my program is running” that Java has ever offered — perfect for beginners and for quick prototypes alike.

How do I understand the evolution of Java from Java 8 to Java 25?

By Wayan in Basic, Java 0 Comment

Understanding Java’s Evolution from Java 8 to Java 25

A good way to understand Java’s evolution from Java 8 to Java 25 is to view it in phases:

  1. Java 8 established modern Java’s functional-programming foundation.
  2. Java 9–11 reshaped the platform and release model.
  3. Java 12–17 modernized the language with records, pattern matching, text blocks, and sealed classes.
  4. Java 18–21 improved concurrency, APIs, and developer ergonomics.
  5. Java 22–25 continue the move toward simpler, safer, more expressive Java.

1. Java 8: The Baseline of Modern Java

Java 8, released in 2014, is often considered the beginning of “modern Java.”

Major features:

  • Lambda expressions
  • Functional interfaces
  • Stream API
  • Default methods in interfaces
  • Optional
  • New Date and Time API
  • CompletableFuture
  • Method references

Example:

List<String> names = List.of("Alice", "Bob", "Charlie");

List<String> filtered = names.stream()
        .filter(name -> name.startsWith("A"))
        .toList();

Java 8 changed Java from being mostly object-oriented and imperative to supporting a much more functional style.

2. Java 9–11: Platform Modernization

Java 9

Java 9 introduced one of the largest structural changes in Java’s history:

  • Java Platform Module System, also called JPMS or Project Jigsaw
  • JShell
  • Collection factory methods
  • Private methods in interfaces
  • Improved Stream API

Example:

List<String> names = List.of("Alice", "Bob");
Set<Integer> numbers = Set.of(1, 2, 3);
Map<String, Integer> scores = Map.of("Alice", 10, "Bob", 20);

The module system allowed applications and libraries to define explicit dependencies:

module com.example.app {
    requires java.sql;
    exports com.example.app.api;
}

Java 10

Java 10 introduced:

  • Local-variable type inference with var
  • Application Class-Data Sharing improvements
  • Garbage collector interface improvements

Example:

var message = "Hello, Java";
var count = 42;

Important: var does not make Java dynamically typed. The type is still determined at compile time.

Java 11

Java 11 was a major LTS release.

Notable features:

  • HTTP Client API standardized
  • String utility methods
  • var in lambda parameters
  • Single-file source-code execution
  • Removal of several Java EE and CORBA modules from the JDK

Example:

var client = java.net.http.HttpClient.newHttpClient();

var request = java.net.http.HttpRequest.newBuilder()
        .uri(java.net.URI.create("https://example.com"))
        .build();

var response = client.send(
        request,
        java.net.http.HttpResponse.BodyHandlers.ofString()
);

3. Java 12–17: Language Expressiveness

This period brought many language features that made Java more concise and expressive.

Switch Expressions

Standardized in Java 14.

String result = switch (status) {
    case 200 -> "OK";
    case 404 -> "Not Found";
    case 500 -> "Server Error";
    default -> "Unknown";
};

This made switch usable as an expression and reduced accidental fall-through bugs.

Text Blocks

Standardized in Java 15.

String json = """
        {
          "name": "Alice",
          "active": true
        }
        """;

Text blocks made multiline strings much easier to write, especially for JSON, SQL, HTML, and test data.

Records

Standardized in Java 16.

public record User(Long id, String name, String email) {
}

A record automatically provides:

  • Constructor
  • Accessor methods
  • equals
  • hashCode
  • toString

Records are ideal for immutable data carriers, DTOs, API responses, and value-like objects.

Pattern Matching for instanceof

Standardized in Java 16.

Before:

if (obj instanceof String) {
    String text = (String) obj;
    System.out.println(text.toUpperCase());
}

After:

if (obj instanceof String text) {
    System.out.println(text.toUpperCase());
}

This reduces boilerplate and makes type checks safer.

Sealed Classes

Standardized in Java 17.

public sealed interface Payment permits CardPayment, CashPayment {
}

public final class CardPayment implements Payment {
}

public final class CashPayment implements Payment {
}

Sealed classes let you restrict which classes can extend or implement a type. This is useful for domain modeling, state machines, and exhaustive pattern matching.

Java 17 is also an LTS release and became a major upgrade target for many Java 8 and Java 11 applications.

4. Java 18–21: Runtime, Concurrency, and API Improvements

Java 18

Notable changes:

  • UTF-8 became the default charset
  • Simple web server command-line tool
  • Code snippets in Java API documentation

Java 19–20

These releases continued incubating and previewing major platform improvements, especially around:

  • Virtual threads
  • Structured concurrency
  • Pattern matching
  • Foreign Function & Memory API

Java 21

Java 21 is another major LTS release.

Important features:

  • Virtual threads
  • Sequenced collections
  • Pattern matching for switch
  • Record patterns
  • String templates as preview
  • Unnamed patterns and variables as preview
  • Structured concurrency as preview
  • Scoped values as preview

Virtual Threads

Virtual threads are one of the biggest Java platform changes since lambdas.

They make thread-per-request programming scalable:

try (var executor = java.util.concurrent.Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> {
        System.out.println("Running in a virtual thread");
    });
}

Virtual threads are especially important for server-side applications, web services, database calls, and blocking I/O workloads.

They do not automatically make CPU-heavy code faster, but they greatly improve scalability for many I/O-bound applications.

Sequenced Collections

Java 21 introduced interfaces for collections with a defined encounter order:

  • SequencedCollection
  • SequencedSet
  • SequencedMap

Example:

SequencedCollection<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");

String first = names.getFirst();
String last = names.getLast();

This regularized APIs for getting first and last elements across ordered collections.

5. Java 22–25: Continued Simplification and Modernization

Java 22, 23, 24, and 25 continue the six-month release cadence, building on earlier preview and incubator features.

Important ongoing areas include:

  • More powerful pattern matching
  • Improvements to unnamed variables and patterns
  • Class-file API work
  • Foreign Function & Memory API maturation
  • Stream gatherers
  • Structured concurrency
  • Scoped values
  • Better startup, monitoring, and runtime performance
  • More convenient entry points for beginner-friendly Java programs

The broad direction is clear: Java is becoming more concise, more expressive, better suited for cloud-native systems, and more approachable without abandoning its strong compatibility model.

LTS Releases Matter

From Java 8 to Java 25, the most important versions for many teams are the LTS releases:

Version Why It Matters
Java 8 Functional programming baseline; still widely used historically
Java 11 First major post-Java-8 LTS; HTTP Client; modular-era cleanup
Java 17 Records, sealed classes, pattern matching, strong modernization point
Java 21 Virtual threads, sequenced collections, advanced pattern matching
Java 25 Next LTS line after Java 21

If you are maintaining enterprise applications, understanding the path 8 → 11 → 17 → 21 → 25 is usually more useful than studying every interim version equally.

Big Themes Across Java 8 to Java 25

1. Less Boilerplate

Java has steadily reduced ceremony:

  • Lambdas
  • var
  • Records
  • Pattern matching
  • Switch expressions
  • Text blocks
  • Compact source files and simpler entry points

Example progression:

public record Customer(String name, String email) {
}

Compared to pre-record Java, this can replace dozens of lines of boilerplate.

2. Better Domain Modeling

Modern Java gives you stronger modeling tools:

  • Records for immutable data
  • Sealed classes for restricted hierarchies
  • Pattern matching for safe decomposition
  • Enhanced switch for exhaustive handling

Example:

sealed interface OrderStatus permits Pending, Paid, Cancelled {
}

record Pending() implements OrderStatus {
}

record Paid(String transactionId) implements OrderStatus {
}

record Cancelled(String reason) implements OrderStatus {
}

This style is useful when modeling finite states or domain events.

3. Better Concurrency

Java 8 gave developers:

  • CompletableFuture
  • Parallel streams

Java 21+ adds:

  • Virtual threads
  • Structured concurrency
  • Scoped values

The shift is from complex asynchronous programming toward simpler blocking-style code that scales better.

4. Better APIs

Across these releases, Java improved many everyday APIs:

  • Collections
  • Strings
  • Files
  • HTTP
  • Date/time
  • Random number generation
  • Foreign memory access
  • Cryptography
  • Monitoring and diagnostics

Examples:

boolean blank = "   ".isBlank();
String repeated = "Java ".repeat(3);
List<String> lines = "a\nb\nc".lines().toList();

5. Strong Compatibility, but Not No Change

Java is famous for backward compatibility. Most old Java code still runs on newer JVMs.

However, migration can still involve work:

  • Removed Java EE modules after Java 8
  • Stronger encapsulation of JDK internals
  • Dependency updates
  • Build tool updates
  • Framework compatibility
  • Reflection and proxy behavior changes
  • Container base image updates

This is especially relevant when moving from Java 8 to Java 17, 21, or 25.

Bytecode and Runtime Compatibility

Each Java version produces a corresponding class-file version. A newer JVM usually runs older class files, but an older JVM cannot run newer class files.

For example:

Java Version Class File Version
Java 8 52
Java 11 55
Java 17 61
Java 21 65
Java 25 69

So if code is compiled for Java 25, it generally requires a Java 25-compatible runtime.

To compile for a specific platform level, prefer:

javac --release 21 Example.java

The --release flag is safer than only using -source and -target because it also limits the available standard-library APIs to that Java version.

Practical Migration Path

If you are coming from Java 8, a practical learning and migration path is:

  1. Java 8 → 11
    • Learn modules conceptually, even if you do not modularize.
    • Replace removed Java EE dependencies explicitly.
    • Update build tools and libraries.
  2. Java 11 → 17
    • Adopt records where appropriate.
    • Use text blocks for multiline strings.
    • Use switch expressions.
    • Learn sealed classes and pattern matching.
  3. Java 17 → 21
    • Evaluate virtual threads.
    • Learn sequenced collections.
    • Use pattern matching for switch.
    • Review framework support.
  4. Java 21 → 25
    • Track finalized features from preview/incubator APIs.
    • Revisit concurrency patterns.
    • Update CI, containers, build plugins, and runtime images.

Mental Model

Think of the evolution like this:

Java 8  = functional Java arrives
Java 9  = modular Java begins
Java 11 = post-Java-8 LTS baseline
Java 17 = modern language Java
Java 21 = modern concurrency Java
Java 25 = next-generation LTS consolidation

Or more simply:

Java evolved from a verbose, class-heavy enterprise language into a more concise, expressive, cloud-ready platform while preserving strong backward compatibility.

What to Focus on First

If your goal is practical fluency, focus on these in order:

  1. Streams and lambdas
  2. var
  3. Modern collection factories
  4. Text blocks
  5. Switch expressions
  6. Records
  7. Pattern matching
  8. Sealed classes
  9. Virtual threads
  10. Modern build/runtime compatibility using --release

That path gives you the clearest understanding of how Java changed from Java 8 to Java 25.

Java Class File Format Versions

By Wayan 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.