Java Compact Source Files and Instance main Methods

Java 25 finalizes compact source files and instance main methods, making small Java programs easier to write while keeping the full language available as programs grow.

A compact source file can omit an explicit top-level class declaration. Java implicitly provides the surrounding class, so beginners and small command-line programs can start with a simple main method.

Traditional Java Entry Point

For many years, the familiar Java entry point looked like this:

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

This form is still valid and remains appropriate for many applications.

Compact Source File

Java 25 allows a source file to contain methods and fields without explicitly declaring the surrounding top-level class.

Example:

void main() {
    String name = "Java 25";
    System.out.println("Hello from " + name);
}

Output:

Hello from Java 25

Compact source files and expanded main-method forms are final in Java 25 and no longer require preview flags.

Instance main Methods

The main method no longer has to be static in Java 25. A candidate main method can be an instance method, and it may have either no parameters or a String[] parameter.

class Greeting {
    void main() {
        System.out.println("Instance main method");
    }
}

When necessary, the Java launcher creates an instance and invokes the candidate instance main method.

More Flexible Access Modifiers

A candidate main method does not have to be public. Package access or protected access can also be valid.

class Demo {
    static void main() {
        System.out.println("No public modifier required");
    }
}

Valid Main Method Shapes

Java 25 greatly expands the forms that can be used as an application entry point.

Compact Source Files Still Use Java

A compact source file is not a separate scripting language. It is still Java and can declare methods, fields, member classes, and member interfaces.

String message = "Ready";

void showMessage() {
    System.out.println(message);
}

void main() {
    showMessage();
}

As a program becomes larger, it can be moved into normal class declarations without changing languages or tools.

Implicit Class Behavior

A compact compilation unit implicitly declares a top-level class. That class is placed in an unnamed package and receives the members declared in the source file.

This design keeps the syntax small for simple programs while preserving normal Java execution semantics behind the scenes.

Running a Compact Source File

A compact source file can be launched using Java source-file mode.

java Hello.java

The launcher compiles the source in memory and invokes a candidate main method.

Why This Matters for Beginners

For a first program, the older entry point introduces several concepts at once: a class declaration, public access, static methods, arrays, and command-line arguments. Compact source files let learners focus first on statements, variables, methods, and basic control flow.

Those class and object concepts can then be introduced when they become relevant.

Common Mistakes

• Using Java 24 or earlier without preview support: the final form described here is a Java 25 feature.
• Thinking traditional main methods are removed: existing public static void main(String[] args) programs continue to work.
• Assuming compact files cannot grow: they can contain additional methods, fields, and nested types.
• Confusing compact source files with JavaScript-style scripts: normal Java typing and language rules still apply.

When to Keep the Traditional Form

Explicit class declarations remain useful when the class itself is part of the program design, when frameworks expect a named application class, or when the source file contains a reusable public type. Compact source files are most valuable for small programs, examples, learning exercises, and focused utilities.

Conclusion

Java 25 makes small Java programs much less verbose by finalizing compact source files and instance main methods. Beginners can write a useful program with a simple void main(), while experienced developers keep full compatibility with traditional class-based entry points.