I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE COURSE

1. Overview

Every program needs a place to start its execution; talking about Java programs, that’s the main method.
We’re so used to writing the main method during our code sessions, that we don’t even pay attention to its details. In this quick article, we’ll analyze this method and show some other ways of writing it.

2. Common Signature

The most common main method template is:
public static void main(String[] args) { }

That’s the way we’ve learned it, that’s the way the IDE autocompletes the code for us. But that’s not the only form this method can assume, there are some valid variants we can use and not every developer pays attention to this fact.

Before we dive into those method signatures, let’s review the meaning of each keyword of the common signature:

  • public – access modifier, meaning global visibility
  • static – the method can be accessed straight from the class, we don’t have to instantiate an object to have a reference and use it
  • void – means that this method doesn’t return a value
  • main – the name of the method, that’s the identifier JVM looks for when executing a Java program

As for the args parameter, it represents the values received by the method. This is how we pass arguments to the program when we first start it.

The parameter args is an array of Strings. In the following example:

java CommonMainMethodSignature foo bar

we’re executing a Java program called CommonMainMethodSignature and passing 2 arguments: foo and bar. Those values can be accessed inside of the main method as args[0] (having foo as value) and args[1] (having bar as value).

In the next example, we’re checking args to decide whether to load test or production parameters:

public static void main(String[] args) {
    if (args.length > 0) {
        if (args[0].equals("test")) {
            // load test parameters
        } else if (args[0].equals("production")) {
            // load production parameters
        }
    }
}

It’s always good to remember that IDEs can also pass arguments to the program.

3. Different Ways to Write a main() Method

Let’s check some different ways to write the main method. Although they’re not very common, they’re valid signatures.

Note that none of these are specific to the main method, they can be used with any Java method but they are also a valid part of the main method.

The square brackets can be placed near String, as in the common template, or near args on either side:

public static void main(String []args) { }
public static void main(String args[]) { }

Arguments can be represented as varargs:

public static void main(String...args) { }

We can even add strictfp for the main() method, which is used for compatibility between processors when working with floating point values:

public strictfp static void main(String[] args) { }

synchronized and final are also valid keywords for the main method but they won’t have an effect here.

On the other hand, final can be applied on args to prevent the array from being modified:

public static void main(final String[] args) { }

To end these examples, we can also write the main method with all of the above keywords (which, of course, you probably won’t ever use in a practical application):

final static synchronized strictfp void main(final String[] args) { }

4. Having More Than One main() Methods

We can also define more than one main method inside our application.

In fact, some people use it as a primitive test technique to validate individual classes (although test frameworks like JUnit are way more indicated for this activity).

To specify which main method the JVM should execute as the entry point of our application, we use the MANIFEST.MF file. Inside the manifest, we can indicate the main class:

Main-Class: mypackage.ClassWithMainMethod

This is mostly used when creating an executable .jar file. We indicate which class has the main method to start the execution, through the manifest file located at META-INF/MANIFEST.MF (encoded in UTF-8).

5. Conclusion

This tutorial described the details of the main method and some other forms it can assume, even the ones that aren’t very common to most of the developers.

Keep in mind that, although all the examples that we’ve shown are valid in terms of syntax, they just serve the educational purpose and most of the time we’ll stick with the common signature to do our job.

I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE LESSONS