Classic main, javac and .class files

Before JDK 25, every Java program started from the same method declaration, public static void main(String[] args), usually in a public class named after its file. That classic form still runs on every JDK, it is how almost all existing code and textbooks start a program, and it is what online judges compile. This lesson explains each word of it, then the two-step way of running it: javac -d out Hello.java compiles the source into a class file in the folder out, and java -cp out Hello runs that class from the class path. It ends with the rules that the JDK 25 launcher follows when a class offers more than one main method.

Every word of the classic main has a job

Here is a classic program. It does one thing more than the compact files of the last lesson: it prints the arguments given to it on the command line.

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello from a classic main");
        System.out.println("Arguments received: " + args.length);
        for (String arg : args) {
            System.out.println("  " + arg);
        }
    }
}

Read the two declarations word by word:

• public class Hello declares a class named Hello that code anywhere may use. A public top-level class must live in a file with the same name, here Hello.java.
• public, in front of main, lets the launcher, which is outside the class, call the method.
• static makes the method belong to the class itself, so it can be called without creating an object first.
• void says that the method returns no value.
• main is the name the launcher looks for.
• String[] args is the one parameter: an array of strings that holds the command-line argumentscommand-line arguments: The words typed after the class name, as in java -cp out Hello Asha Pune. The launcher passes them to main as the array String[] args, which is empty, never null, when there are none., and is empty when there are none.

System.out.println is the classic way to print a line: System.out is the standard output stream, and println writes a value and ends the line. It does the same job as IO.println, and you will meet both. The for loop prints each argument in turn; module 3 explains loops. Step through one launch of this class with two arguments, and see what the launcher needs each word for:

A public class needs a file of its own name

The compiler insists on the first rule of the list above. This file declares a public class Greeting but is called Mismatch.java:

// A public class in a file with another name.
public class Greeting {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

from session import run

run("javac -d out Mismatch.java", expect_failure=["javac -d out Mismatch.java"])

# JDK in use: openjdk version "25.0.4.1" LTS
$ javac -d out Mismatch.java
Mismatch.java:2: error: class Greeting is public, should be declared in a file named Greeting.java
public class Greeting {
       ^
1 error
[exit status 1]

The Java Language Specification allows a compiler that stores code in files to enforce this, and javac does, which is why every public class lives in a file of its own named after it. Classes that are not public may share a file.

javac writes a class file once, and java runs it from the class path

The source launcher of the last lesson compiles in memory every time. For anything you run more than once, compile once with javac, keep the class file, and run it as often as you like:

from session import run

# Compile once into out, then run the class three times with different arguments.
run("""
javac -d out Hello.java
find out -type f
java -cp out Hello
java -cp out Hello Asha Pune
java -cp out Hello "New Delhi"
""")

# JDK in use: openjdk version "25.0.4.1" LTS
$ javac -d out Hello.java
$ find out -type f
out/Hello.class
$ java -cp out Hello
Hello from a classic main
Arguments received: 0
$ java -cp out Hello Asha Pune
Hello from a classic main
Arguments received: 2
  Asha
  Pune
$ java -cp out Hello "New Delhi"
Hello from a classic main
Arguments received: 1
  New Delhi

• javac -d out Hello.java compiles the file and writes the class into the folder out, creating the folder if needed. Silence means success.
• java -cp out Hello runs it. -cp, short for --class-path, lists where the JVM should look for classes, the class pathclass path: The folders and JAR files in which the JVM looks for classes, given with -cp or --class-path. Without it, and without a CLASSPATH environment variable, it is the current folder.; without it (and without a CLASSPATH environment variable), the class path is the current folder. Notice that you name the class, Hello, not the file: no .java and no .class.
• Words after the class name become the elements of args. Quotes keep "New Delhi" together as one argument, and with no arguments args.length is 0, not an error.

A class in a package runs by its full name

Real programs put their classes in packagespackage: A named group of classes, such as com.example.shop, declared on the first line of a source file. javac -d stores its class files in folders that follow the name, and java runs such a class by its full name., named groups such as com.example.shop, declared on the first line of the file. javac -d then builds a folder for each part of the package name, and java needs the class’s full name:

package com.example.shop;

public class App {
    public static void main(String[] args) {
        System.out.println("Running " + App.class.getName());
    }
}

from session import run

# A class in a package: javac -d builds the matching folders, and java needs the class's full name.
run("""
javac -d out src/com/example/shop/App.java
find out -type f
java -cp out com.example.shop.App
java -cp out App
""", expect_failure=["java -cp out App"])

# JDK in use: openjdk version "25.0.4.1" LTS
$ javac -d out src/com/example/shop/App.java
$ find out -type f
out/com/example/shop/App.class
$ java -cp out com.example.shop.App
Running com.example.shop.App
$ java -cp out App
Error: Could not find or load main class App
Caused by: java.lang.ClassNotFoundException: App
[exit status 1]

The class file landed in out/com/example/shop/App.class, and the class’s full name, com.example.shop.App, ran it. The short name App fails with Could not find or load main class App, because the class path folder out holds no App.class at its top. Step through the same session, from the package name to the folders and back:

The source file sits in matching folders under src too, the usual layout of Java projects; build tools such as Maven and Gradle use the same idea, with the package folders under src/main/java.

JDK 25 picks main by its parameters, and older JDKs want the classic one

Since JDK 25, the launcher accepts more kinds of main method than the classic one, which is what made compact source files possible. The Java Language Specification (§12.1.4) and JEP 512 give the rules:

1. A method qualifies when it is named main, returns void, is not private, and has either one String[] parameter or none. It may be static or an instance method, and it no longer has to be public.
2. If the class has a qualifying main with a String[] parameter, the launcher chooses that one; only when there is none does it choose a main without parameters.
3. A static method is called directly. For an instance method, the launcher first creates an object of the class, which needs a constructor without parameters that is not private, and then calls main on it.

This class offers both kinds, in the less obvious combination:

// Two candidate main methods in one class: which one does the launcher choose?
class Shop {
    static void main() {
        System.out.println("static main() without parameters");
    }

    void main(String[] args) {
        System.out.println("instance main(String[]) with " + args.length + " argument(s)");
    }
}

from session import run

# JDK 25 picks the main that takes String[]; JDK 21 accepts only public static void main(String[]).
run("""
javac -d out Shop.java
java -cp out Shop one two
javac --release 21 -d out21 Shop.java
""")
run("java -cp out21 Shop", jdk="21", expect_failure=["java -cp out21 Shop"])

# JDK in use: openjdk version "25.0.4.1" LTS
$ javac -d out Shop.java
$ java -cp out Shop one two
instance main(String[]) with 2 argument(s)
$ javac --release 21 -d out21 Shop.java
# JDK in use: openjdk version "21.0.12.1" LTS
$ java -cp out21 Shop
Error: Main method not found in class Shop, please define the main method as:
   public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application
[exit status 1]

JDK 25 ran the instance method main(String[]), even though the other main is static: the parameter list decides, not the word static. The same class compiled for Java 21 and run on JDK 21 does not start at all, because before JDK 25 the launcher accepted only public static void main(String[] args) and says so in its error message. So when code must also run on older JDKs, write the classic signature. Step through the three rules on Shop:

Almost every Java program written before JDK 25 starts from the classic main, and that is most of the Java you will read. The systems that judge programs automatically work with it too: they compile your file with javac and run the class with java, exactly as above. The online judge Kattis, for example, documents that it compiles Java with javac 25.0.3 and runs your main class from the class path, and the ICPC World Finals programming environment lists OpenJDK 21.0.4, a JDK on which a compact source file does not compile.

Practise: join the arguments

Complete Main.java so that it prints its command-line arguments on one line, joined by |, or the text (no arguments) when it receives none. With the arguments one two it prints one | two; with "New Delhi" Pune it prints New Delhi | Pune.

// Exercise: print the command-line arguments joined by " | ", or "(no arguments)" when there are none.
// Compile with: javac -d out Main.java    Run with: java -cp out Main one two
public class Main {
    public static void main(String[] args) {
        System.out.println("TODO");
    }
}

The session compiles the class and runs three sample tests, each comparing the output with the expected line through diff, as in the last lesson’s exercise. As given, main prints TODO, so all three fail:

from session import run

# The sample tests: run the class with three argument lists and compare each output with the expected line.
run("""
javac -d out Main.java
java -cp out Main > got.txt; diff expected-none.txt got.txt && echo PASS
java -cp out Main one two > got.txt; diff expected-two.txt got.txt && echo PASS
java -cp out Main "New Delhi" Pune > got.txt; diff expected-space.txt got.txt && echo PASS
""", expect_failure=[
    "java -cp out Main > got.txt; diff expected-none.txt got.txt && echo PASS",
    "java -cp out Main one two > got.txt; diff expected-two.txt got.txt && echo PASS",
    'java -cp out Main "New Delhi" Pune > got.txt; diff expected-space.txt got.txt && echo PASS',
])

# JDK in use: openjdk version "25.0.4.1" LTS
$ javac -d out Main.java
$ java -cp out Main > got.txt; diff expected-none.txt got.txt && echo PASS
1c1
< (no arguments)
---
> TODO
[exit status 1]
$ java -cp out Main one two > got.txt; diff expected-two.txt got.txt && echo PASS
1c1
< one | two
---
> TODO
[exit status 1]
$ java -cp out Main "New Delhi" Pune > got.txt; diff expected-space.txt got.txt && echo PASS
1c1
< New Delhi | Pune
---
> TODO
[exit status 1]

First hint: String.join(" | ", args) joins the elements of an array with a separator, and args.length == 0 is true when there are no arguments. Remember to compile again with javac after every change, or the old class file runs.

Once all three tests pass, test yourself on the four ideas of this lesson. Each answer you give is explained on the spot, and the next question comes from the idea where you need it most:

Interview questions

Fresher · What does each word of public static void main(String[] args) mean?

public lets code outside the class, including the launcher, call the method. static makes it belong to the class rather than to an object, so it can run before any object exists. void means it returns nothing; a program reports failure through an exception or System.exit, not a return value. main is the name the launcher searches for, and String[] args receives the command-line arguments, an empty array when there are none. A good answer adds what JDK 25 changed: under JEP 512 the launcher also accepts main methods that are not public or static or have no parameters, preferring one with a String[] parameter. Older JDKs, and many judges, still expect exactly this classic signature.

Key takeaways

• The classic entry point is public static void main(String[] args) in a class, and a public top-level class must be in a file of the same name.
• javac -d out Hello.java writes out/Hello.class, and java -cp out Hello runs the class, named without an extension, with args holding the command-line arguments, empty and never null when there are none.
• A class in a package lands in matching folders and runs by its full name, such as com.example.shop.App.
• JDK 25 chooses a main with a String[] parameter over one without, static or not, while JDKs before 25, and judges that run them, accept only the classic signature.