Java main() Method Explained

Azure Container Apps is a fully managed serverless container service that enables you to build and deploy modern, cloud-native Java applications and microservices at scale. It offers a simplified developer experience while providing the flexibility and portability of containers.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, visit the documentation page.

You can also ask questions and leave feedback on the Azure Container Apps GitHub page.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, you can get started over on the documentation page.

And, you can also ask questions and leave feedback on the Azure Container Apps GitHub page.

Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.

Try a 14-Day Free Trial of Orkes Conductor today.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

Try a 14-Day Free Trial of Orkes Conductor today.

End-to-end testing is a very useful method to make sure that your application works as intended. This highlights issues in the overall functionality of the software, that the unit and integration test stages may miss.

Playwright is an easy-to-use, but powerful tool that automates end-to-end testing, and supports all modern browsers and platforms.

When coupled with LambdaTest (an AI-powered cloud-based test execution platform) it can be further scaled to run the Playwright scripts in parallel across 3000+ browser and device combinations:

>> Automated End-to-End Testing With Playwright

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.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, visit the documentation page.

You can also ask questions and leave feedback on the Azure Container Apps GitHub page.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

Try a 14-Day Free Trial of Orkes Conductor today.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

Try a 14-Day Free Trial of Orkes Conductor today.