Compact Source Files and Instance Main Methods in Java

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.