The entry point of a Java program must be the main method of the standard signature. 1. It must be public so that the JVM can access externally; 2. It must be static because the JVM calls it before creating the class instance; 3. The return type must be void; 4. The parameter must be String[] or String.... If one of these elements is missed or changed, the program will fail to run with an error. Although there can be multiple overloaded main methods, only methods that meet the signature will be recognized by the JVM as the main entry point.

The main method is the entry point of any Java application. If you're writing a Java program that runs from the command line, it needs a main method with the correct signature—otherwise, the JVM won't recognize where to start.

What exactly is the standard signature?

The standard signature looks like this:

 public static void main(String[] args)

You'll see variations sometimes (like String... args or different order of modifiers), but this is what the Java runtime expects by default.

Why does the main method need to be public?

The public keyword means the method is accessible from anywhere. Since the Java Virtual Machine (JVM) starts your program from outside your class, it needs to have access to the main method. If it were private or protected , the JVM wouldn't be able to call it, and your program wouldn't run.

• It must be public
• It must be static
• It must return void
• It must take either String[] or String... as the argument

If any of these conditions aren't met, you'll get a runtime error like:

Error: Main method not found in class MyProgram, please define the main method as:
public static void main(String[] args)

Why is the main method static?

Because the JVM calls main before creating an instance of your class. Since no object exists yet, the method has to be static —that way, it belongs to the class itself rather than any particular instance.

Think of it like this:
Before you can make a car ( new Car() ), someone has to start the factory. That "starting" part is handled by the static main method.

So if you forget the static modifier, the JVM won't consider it the entry point.

What about the parameter list?

You'll often see two forms:

 public static void main(String[] args)

or

 public static void main(String... args)

Both are valid. The first uses an array, the second uses varargs (variable-length arguments). They work the same for the JVM, but:

• String[] args is more common and clearer for beginners.
• String... args allows easier use in some contexts, especially when calling main manually from other code.

Either is fine, but stick with one unless you have a specific reason to switch.

Also, the variable name args isn't special—you could write public static void main(String[] myArgs) —but sticking with the convention ( args ) helps avoid confusion.

Can there be multiple main methods?

Yes! Java supports method overloading, so you can have:

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

But only the one with the exact signature public static void main(String[]) will be recognized by the JVM as the entry point. Others can be called manually like normal methods.

So putting it all together:
To make sure your Java app runs properly, always include a main method with the right signature. It's public so the JVM can reach it, static because no objects exist yet, and take a string array (or vararg) for command-line input.

Basically that's it.

The above is the detailed content of What is the `main` method signature?. For more information, please follow other related articles on the PHP Chinese website!