Understanding public static void main(String[] args) in Java with Simple Examples

 

Understanding public static void main(String[] args)

The Heart of Every Java Program

Introduction

Java is a powerful programming language, and everything starts with one key method — public static void main(String[] args). It's not just a line of code. It's the entry point of every Java application.

When you run your program, Java looks for this method first. Let's break it down piece by piece — in a way that even beginners can understand!

🔍 Complete Breakdown of public static void main(String[] args)

Let's understand this powerful line by breaking it into parts.

🔑 public

The word public means that this method is accessible from anywhere — even from outside the class.

Why must main be public?

Because Java's runtime (JVM) must be able to access it. If it's not public, the JVM can't find it — and you'll get a runtime error.

🔧 static

The keyword static means this method belongs to the class, not to an object.

Why is main static?

Because the JVM calls the main method before any object of the class is created. So it must be static, or Java won't know how to call it.

🚫 void

This tells Java that the method does not return any value.

Why doesn't main return anything?

Because it's the starting point — it's only meant to execute code, not send back a value.

🧠 main

This is the name of the method. Java knows that main() is where your program begins.

Can we rename main()?

No. The JVM looks specifically for a method named main. Change it, and your program won't run.

📥 String[] args

This is an array of strings that stores command-line arguments.

What are command-line arguments?

They are inputs you can pass to the program while running it from the terminal.

Example: Accessing args

public class Demo {
    public static void main(String[] args) {
        System.out.println("First argument: " + args[0]);
    }
}

Run from terminal:

java Demo Hello

Output:

First argument: Hello

🧪 Is the Signature Fixed?

Can I change the order?

Nope. You must write it as public static void main(String[] args) — order matters!

Valid Signature Examples

public static void main(String args[])   // ✅ OK
static public void main(String[] args)   // ✅ OK

Invalid Signature Examples

private static void main(String[] args)  // ❌ JVM can't access
public void main(String[] args)          // ❌ Not static

🔎 Real-Life Example with Output

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

Output:

Hello, world!

Running with Arguments

public class Greet {
    public static void main(String[] args) {
        System.out.println("Hello " + args[0]);
    }
}

Run Command:

java Greet John

Output:

Hello John

⚠ Common Errors with main()

1. Missing main()

public class MyClass {
    // no main method
}

Output:

Error: Main method not found

2. Wrong Signature

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

Output:

Error: Main method not found

🧪 Variations of main()

1. String args[] vs String[] args

Both are the same — Java allows both styles.

2. Can we overload main()?

Yes! But only the exact signature is called by JVM.

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

3. Can we use varargs?

Yes! This is also allowed:

public static void main(String... args) {
    System.out.println("Using varargs!");
}

🔍 Importance of Each Part

Part	Meaning
public	Accessible to JVM
static	Called without object
void	No return value
main	Program entry point
String[] args	Command-line input

📘 Summary Table for Quick Revision

Keyword	Role
public	Makes it accessible
static	Allows calling without object
void	No return value
main	JVM starts here
String[] args	Command-line arguments

✅ Conclusion

Now you know what public static void main(String[] args) actually means! It's not just a boring line to copy-paste — it's the brain of your Java program. Every word in it has a purpose.

From making it accessible (public), to ensuring the JVM can run it (static), to accepting inputs (String[] args) — it's a well-designed method built to start your Java journey.

❓ FAQs

1. Can we have multiple main methods in the same class?

Yes, you can overload them. But only the standard one is called automatically.

2. Is String[] args compulsory?

Technically yes, but you can avoid using it if you don't need command-line input.

3. Why is main method static in Java?

So JVM can call it without creating an object.

4. Can we write main() without public?

No. The JVM won't be able to access it.

5. What happens if main is private?

Your program will compile but fail at runtime with a "main method not found" error.