Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

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.

Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW