Can We Write Java Programs Without Using the ‘main’ Function?

Despite the fact that the main function is considered the entry point for most standalone Java applications, there are certain scenarios where developers do not explicitly define the main method. This article will explore these scenarios and provide examples of how to achieve this without using the main function.

Static Blocks: An Alternative to the main Function

One of the alternatives to the main function is the use of static blocks. Although a static block is not a replacement for the main method, it can be used to run code when the class is loaded. Static blocks are executed before any instance or any other static methods in the class.

Here is a simple example of a class with a static block:

public class NoMain {
    static {
        ("Static block is executed after loading the class.");
    }
}

When the class is loaded, the static block is executed. This can be useful for initialization tasks that need to be performed only once when the class is loaded, such as setting up resources or executing a one-time action.

JUnit Tests: Running Code Without the main Method

Another scenario where you can write Java code without an explicit main method is when you are writing unit tests with JUnit. JUnit provides annotation-based test methods that do not require a main function to run the tests.

The following is an example of a JUnit test:

@org.junit.Test
public void testAddition() {
    (5, (1   2));
}

In this example, the @Test annotation marks the method as a test method that will be executed by JUnit.

Java Applets: Entry Points without main

Java applets have been largely outdated, but they traditionally did not require a main method. Java applets had their own entry point, which was the init method. Although it is not recommended to use applets in modern applications, understanding this concept can provide insight into alternative entry points.

JavaFX Applications: A Different Entry Point

In JavaFX, a different method, the start method, serves as the entry point. This is a design change from previous versions of Java where the main method was the entry point. The start method is a callback method that must be defined in the main class:

public class MyApplication implements Application {
    @Override
    public void start(Stage primaryStage) {
        ("JavaFX Application");
        Label label  new Label("Hello, World!");
        VBox vBox  new VBox(label);
        (new Scene(vBox, 300, 250));
        ();
    }
    public static void main(String[] args) {
        (args);
    }
}

Here, the start method is the entry point for the JavaFX application. The main method is provided to launch the application using the method.

Conclusion

While a main method is the standard entry point for Java applications, there are alternative methods available. Static blocks, JUnit test methods, and JavaFX's start method all provide ways to execute code without explicitly defining a main method. However, for typical Java applications, a main method is still required to control the flow of execution.

References

Initial Blocks in Java JUnit Tutorial JavaFX Getting Started Tutorial