hello, world

the picture

make a file called Main.java, put three lines in it, run it:

void main() {
    IO.println("hello, world");
}

hello, world

$ java Main.java
hello, world

that's a real, complete java program. no class, no public, no static. it's called a compact source file, and it became a final feature in java 25 (JEP 512).

for almost 30 years before that, the first program anyone wrote in java looked like five lines of ceremony around one line of work. you'll still see that version in every book, tutorial and codebase, so you need to read it fluently. the good news: it's the same program. the extra words each do one small job.

from void main() to public static void main

void main() {
    IO.println("hello, world");
}

so when you see public static void main(String[] args), read it as: "a method anyone can call (public), that doesn't need an object (static), returns nothing (void), is called main, and receives the command-line words (String[] args)".

public class Main {
    public static void main(String[] args) {
        System.out.println(args.length + " args: " + String.join(", ", args));
    }
}

$ java Main.java one two "three four"
3 args: one, two, three four

the shell splits on spaces (quotes keep words together), and args is just a String[] array holding what's left after the class name.

public class Main {
    public static void main(String[] args) {
        System.out.println(args.length);
    }
}

which main runs

a class can have more than one method called main. the launcher (the java command) has a fixed rule for which one it calls.

class Main {
    void main() { ... }}

the full rule from JEP 512: if the class has a main(String[]) (declared or inherited), run that. otherwise, if it has a main(), run that. otherwise, error. if the chosen one isn't static, the launcher calls the class's no-argument constructor first, then calls main on that object.

what a compact file gives you

a compact source file isn't a toy mode. it's normal java with three things done for you:

• a class around everything. fields and methods you write at the top level become members of a class named after the file. it's final and you can't refer to it by name.
• import module java.base. every public class in java.util, java.io, java.time, java.math and friends is already imported. List, Map, ArrayList, LocalDate: just use them.
• IO. IO.println, IO.print and IO.readln live in java.lang, so they're available everywhere (in normal classes too).

String greeting = "hi";
 
void main() {
    IO.println(greeting + " from " + getClass().getName());
    IO.println(List.of(1, 2, 3));
}

hi from Main
[1, 2, 3]

greeting is a field, main is an instance method, and getClass().getName() proves there really is a class called Main under there. List worked without an import. ask the class file itself and it agrees:

$ javac Main.java && javap -p Main
Compiled from "Main.java"
final class Main {
  java.lang.String greeting;
  Main();
  void main();
}

when a compact file grows up, you don't rewrite it: wrap it in class Main { ... }, add imports for whatever you used, done.