Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Introduction

Introduced as a preview feature in Java 21 and standardized in Java 25, compact source files and instance main method make Java more accessible for beginners. The introduction of these are crucial steps forward in making Java a more beginner-friendly programming language.

In this tutorial, we’ll explore these new features and understand how they make the learning curve smoother for students or beginners.

2. Writing a Basic Java Program

Traditionally, for beginners, writing their first Java program was a little more complicated than in other programming languages. A basic Java program required the declaration of a public class. This class encloses a public static void main(String[] args) method, serving as the entry point of the program.

All of this is just to write a “Hello world” in the console:

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

The new compact source files and instance main method features simplify the code above:

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

In the code above, we didn’t define the class. Just a main() method without an argument and a simple println() method. Additionally, we utilize the built-in new IO class, which includes print and read features. The new IO class eliminates the need for the System.out.println() method.

3. Instance Main Methods

The introduction of instance main() methods allows us to utilize a more dynamic approach to initializing our applications.

3.1. Understanding Instance Main Methods

This has changed the way Java programs declare their entry points. In fact, Java earlier required the presence of a static main() method with a String[] parameter in the public class, as we saw in the previous section.

This new protocol is more lenient. It enables the use of main() methods with varied access levels: public, protected, or default (package).

Also, it doesn’t require the methods to be static or to have a String[] parameter:

class HelloWorld {
    void main() {
        IO.println("Hello, World!");
    }
}

3.2. Choosing a Launch Protocol

The refined launch protocol chooses a starting point for our program, taking into account both availability and access level.

Instance main() methods should always have a non-private access level. Moreover, the launch protocol follows a specific order to decide which method to use:

  1.  a static void main(String[] args) method declared in the launched class
  2.  a static void main() method declared in the launched class
  3.  a void main(String[] args) instance method declared in the launched class or inherited from a superclass
  4.  a void main() instance method

When a class declares an instance main() method and inherits a standard static main() method, the system invokes the standard static main method.

For example, let’s suppose we have a superclass HelloWorldSuper, that implements a long-established main() method:

public class HelloWorldSuper {
    public static void main(String[] args) {
        System.out.println("Hello from the superclass");
    }
}

This superclass is extended by a HelloWorldChild class:

public class HelloWorldChild extends HelloWorldSuper {
    void main() {
        IO.println("Hello, World!");
    }
}

Let’s compile the superclass and run the child through the command line:

javac HelloWorldSuper.java
java HelloWorldChild

We’ll get the following output in the console:

Hello from the superclass

4. Compact Source Files

Compact source files are a significant feature designed to simplify the learning curve for beginners. It allows methods, fields, and classes to exist without explicit class declarations.

Typically, in Java, every class exists within a package and every package within a module. However, a compact source file exists in the unnamed package and the unnamed module. These classes are final and can only extend the Object class without implementing any interface.

Given all this, we can declare the main() method without declaring the class explicitly in the code:

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

Using these two new features, we managed to turn the program into a very simple one that can be much easier to understand by any person who starts programming in Java.

A compact source file is almost exactly like an explicitly declared class. Other methods or variables are interpreted as members of the compact source file, so we can add them to our class:

private String getMessage() {
    return "Hello, World!";
}
void main() {
    IO.println(getMessage());
}

Despite their simplicity and flexibility, compact source files have inherent limitations.

Direct constructions or references by name are impossible, and they don’t define any API accessible from other classes. This inaccessibility also causes the Javadoc tool to falter when generating API documentation for such classes. However, future Java releases may adjust and enhance these behaviors.

5. Simple Console I/O in Compact Source Files

Moving on, beginners often write programs that interact with the console. Especially, programs that accept user input and use it within the application. Traditionally, this can be done using classes such as Scanner or BufferedReader. While both classes are effective, they tend to require verbose code for simple tasks.

Java 23 introduces a simple I/O class for basic console input and output, later finalized in Java 25. With this API, we can read console input in a single line of code using the readln() method:

void main() {
    String name = IO.readln("Please enter your first name: ");
    IO.print("Nice to meet you, ");
    IO.println(name);
}

In the code above, we prompt the user for their first name using the IO.readln() method and store the response in the name variable. Finally, we display a greeting that includes the user’s name using the print() and println() methods.

Notably, the simple I/O class resides in the java.lang package, hence it doesn’t require an explicit import statement.

These additions makes Java more approachable for beginners, especially when building simple command-line applications.

6. The java.base Module

Furthermore, in compact files, the java.base module is automatically available. The module is the fundamental Java module and contains many core classes and interfaces that beginners frequently use.

For instance, the List interface is part of the java.util package, which is exported by the java.base module. In a regular source file, we’d need an explicit import statement to use List. However, in compact source files, this import isn’t required because java.base is implicitly available:

void main() {
    List<String> authors = List.of("James", "Alex", "John", "Alex", "Daniel", "Eugen");
    for (String name : authors) {
        IO.println(name + ": " + name.length());
    }
}

In the code above, we define the list of authors without explicitly importing the List class.

This approach allows beginners to work with commonly used data structures early on, without needing to fully understand modules or import statements.

7. Conclusion

In this article, we learned that Java 25 standardizes the compact source files and instance main() methods, which has made significant progress in enhancing user experience, especially for those at the beginning of their programming journey. Additionally, we saw how to use the simplified I/O classes and use complex data structures without an import statement.

By simplifying the structural aspects of programming, these features allow novices to focus on logical thinking and problem-solving more quickly.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW