Implicitly Declared Classes and Instance Main Methods in Java

1. Overview

In recent versions of Java, the Oracle team has been focusing on making the Java language more accessible for newbie programmers. As part of that, the Oracle team has introduced implicit classes and instance main methods as a preview feature, which will eliminate the need to use constructs that typical newbie programmers are not familiar with.

In Java 23, the Oracle team has a few proposed enhancements for implicit classes and instance main methods, which will further simplify the learning curve for newbie programmers.

In this article, we’ll briefly discuss implicit classes, instance main methods, and the new proposed enhancements in JDK 23.

2. Before JDK 23

Implicit classes (or unnamed classes) and instance main methods were initially introduced in Java 21 as preview features.

Traditionally, Java requires developers to explicitly define classes to encapsulate the member variables and methods. This can be cumbersome, especially if we’re writing small programs with straightforward logic.

Developers must also declare the main method with the static keyword and method arguments, which serve as the entry point for applications. These constructs often confuse beginner programmers and limit the visibility of member variables.

With the introduction of implicit classes, developers can now write code without class declaration. The compiler will automatically generate the class behind the scenes so that developers can focus on the code’s core logic.

The instance main methods feature lets developers define the main method within a class instance. This means that developers can now access instance variables and methods directly, which will allow us to write more complex code within the main method.

Also, it doesn’t require the methods to be static or to have a String[] parameter, which makes it easy for beginners to get started.

3. Enhancements in Java 23

New enhancements were proposed in Java 23 to make the language more welcoming for beginners. Let’s briefly understand them in this section.

3.1. Interacting With the Console

Many beginner programmers often want to write programs that involve interacting with the console, like writing text on the console and taking console input, for example. However, to accomplish this, they need to write complex sentences that are mysterious for beginners.

For example, code that’s as simple as taking input from the user and displaying it requires us to write the following code:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.print("Please enter your name: ");
            String name = reader.readLine();
            System.out.println("Hello " + name);
        } catch (IOException ioe) {
            System.err.println("An error occurred while reading input: " + ioe.getMessage());
        }
    }
}

The above code looks mysterious to beginners and can lead to many questions like What is BufferedReader and InputStreamReader? What is try, catch? What is an IOException?

With the proposed enhancement, the following methods are readily available for us to use in the body of every implicit class:

public static void println(Object object);
public static void print(Object obj);
public static String readln(String prompt);

To achieve this, Java introduces a new top-level class in the java.io package named IO. It declares the above three static methods for textual I/O with the console and nothing else. Every implicitly declared class automatically imports these static methods, as if the below declaration were included:

import static java.io.IO.*;

The new class java.io.IO is a preview API in JDK 23.

With this, we can write the above code more concisely:

void main() {
    String name = readln("Please enter your name: ");
    print("Hello "+name);
}

To run the above code, we need to compile and run the program by enabling the preview flag. For that, go to the directory where your source file is residing, and then execute two commands:

javac --source 23 --enable-preview .\Test.java

java --source 23 --enable-preview Test

3.2. Automatic Import of the java.base Module

To write any meaningful code in Java, we need to import other packages into our code. For beginners, however, these import statements look strange and can be another source of confusion.

The new proposal is to further simplify the code by making all public top-level classes and interfaces of the packages exported by the java.base module available for use in the body of every implicit class.

This will allow the programmers to use these classes/interfaces without having to have explicit import statements. These classes would be imported implicitly on demand. Popular APIs in commonly used packages such as java.io, java.math, and java.util are thus immediately usable, without any fuss.

Earlier, the Oracle team proposed a new import declaration in the format “import module M,” which imports, on demand, all of the public top-level classes and interfaces of the packages exported by module M.

Implicitly declared classes implicitly import the java.base module, as if the declaration import module java.base appears at the start of every source file containing an implicit class.

4. Conclusion

We’ve seen how implicit classes and instance main methods can significantly improve the beginner programmer experience while also adding value to experienced programmers who can now write cleaner and more readable code.