Single-File Source Execution

## The problem it solves Traditionally, running even a one-line Java program takes **two steps**: 1. **Compile** the human-readable source (`Hello.java`) into bytecode with the *compiler*: `javac Hello.java`. This writes a `Hello.class` file to disk. *Bytecode* is the intermediate instruction format the Java Virtual Machine (the *JVM* — the program that actually runs Java) understands. 2. **Run** the bytecode with the *launcher*: `java Hello`. For a beginner or for a quick script, that ceremony is friction. **JEP 330** ("JEP" = JDK Enhancement Proposal, the design-document process for changes to Java) shipped in **Java 11** to remove it. ## What the feature does If you give the `java` launcher a file name that ends in `.java` (instead of a *class name*), it switches into **source-file mode**: ``` java Hello.java ``` Under the hood it: - Reads the source file. - Compiles it **in memory** using the built-in compiler — **no `.class` file is written to disk**. - Loads the resulting class and invokes its `main` method. So one command replaces the compile-then-run pair. The decision is based on **the file extension / form of the first argument**: if it ends in `.java`, source mode; otherwise it's treated as a class name (or a JAR via `-jar`). ## Arguments Everything **after** the source file name is handed to the program as its `args`: ``` java Hello.java alice bob ``` Here `alice` and `bob` become `args[0]` and `args[1]` in `public static void main(String[] args)`. ## Shebang / script-like usage Because it's a single command, you can make a Java file behave like a shell script on Unix-like systems by adding a *shebang* line (the `#!` first line that tells the OS which interpreter to run). You launch it with an explicit `--source` flag because the file has no `.java` extension: ``` #!/path/to/bin/java --source 21 public class Hello { public static void main(String[] a){ System.out.println("hi"); } } ``` Make it executable (`chmod +x hello`) and run `./hello`. The `--source <version>` flag tells the launcher which language level to compile against and is **required** when the file extension isn't `.java`. ## Limitations (important) - **Exactly one source file.** The feature compiles only the file you name. It cannot do *separate compilation* — i.e. compile several source files that reference each other. If your `Hello.java` references another class defined in `Util.java`, source mode won't compile `Util.java` for you; you'd need ordinary `javac`/`java` or a build tool. (You *can* define multiple classes **inside** the single file — only the first/declared public class with `main` is the entry point in older versions; later Java relaxed which class can be the entry.) - **No `.class` output**, so it's not how you build/ship an application. - It can still **use libraries** on the classpath via `--class-path`/`-cp`, but it won't compile your own multi-file project. ## Where it fits Java's lightweight-usage story has two complementary tools: - **JShell** (Java 9): an interactive REPL ("Read-Eval-Print Loop") where you type expressions and see results immediately — great for experimenting line by line. - **Single-file execution** (Java 11): run a *whole small program* in one shot, ideal for scripts and teaching. Later, **JEP 445/463/477/512** ("implicitly declared classes and instance main methods", finalized in Java 25) reduced the boilerplate even further so a beginner can write just a `main` body without an explicit `class` or `String[] args`, which combines naturally with single-file execution.