{"title":"First Java Program","description":"","content":"The fastest way to feel comfortable with Java is to write a tiny program, compile it, and run it end-to-end. This lesson walks through that exact loop using a small e-commerce program we'll keep returning to throughout the course. You'll learn what each line means, how to name the file, and what to do when the compiler complains.\n\n---\n\n# Writing the Source\n\nOpen a plain text editor or your IDE and create a file named `HelloShop.java`. Type the program below exactly as shown, including the capitalization:\n\n\n```java\npublic class HelloShop {\n public static void main(String[] args) {\n System.out.println(\"Welcome to MyShop\");\n System.out.println(\"Today's featured product: Wireless Headphones\");\n }\n}\n```\n\n\nThat's the whole program. It defines a class called `HelloShop`, declares a `main` method inside it, and prints two lines. We'll grow `HelloShop` into a small storefront over the next several sections by adding products, prices, a cart, and orders. For now it just prints.\n\nA few things before we break it down:\n\n- Java is case-sensitive. `System` and `system` are different names, and only the first one is the class you want.\n- Every statement ends with a semicolon.\n- The braces `{` and `}` come in pairs. The outer pair belongs to the class, the inner pair belongs to the method.\n\n---\n\n# Anatomy of the Program\n\nLet's read the program line by line. None of these pieces are decorative, so it helps to know what each one buys you.\n\n### `public class HelloShop`\n\nThis line declares a class named `HelloShop`. In Java, every piece of code lives inside a class, even the entry point of the program. The keyword `class` introduces a new type, and `HelloShop` is the name we picked.\n\nThe `public` keyword in front of `class` means this class is visible from anywhere. You can have at most one `public` class per source file, and the file name must match that class.\n\n### The Brace Structure\n\nThe two pairs of curly braces define two nested scopes:\n\n- The outer braces `{ ... }` after `class HelloShop` enclose the body of the class. Everything that belongs to the class lives between them.\n- The inner braces `{ ... }` after `main(...)` enclose the body of the method. The statements that run when the program starts live between them.\n\nIndenting the inner block by four spaces (or one tab) is convention. Java treats whitespace flexibly, but consistent indentation matters for readability.\n\n### `public static void main(String[] args)`\n\nEach keyword in this signature has a specific job. Here's how the parts of the line fit together:\n\n\n```mermaid\nflowchart LR\n A[public]:::cyan --> B[static]:::orange\n B --> C[void]:::green\n C --> D[main]:::teal\n D --> E[\"String[] args\"]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nReading left to right:\n\n- **`public`** is an access modifier. It says the method is visible from outside the class. The JVM needs to call `main` from outside, so it has to be public.\n- **`static`** means the method belongs to the class itself, not to an individual object. The JVM calls `main` before any objects exist, so it cannot rely on having an instance to call the method on.\n- **`void`** is the return type. `void` means the method returns nothing. When the program is done, control just leaves `main`, no value flows back.\n- **`main`** is the method name. The JVM looks for a method with exactly this name when it starts your program. Rename it to `Main` or `start` and the JVM won't find an entry point.\n- **`String[] args`** is the parameter list. It's an array of `String` values that holds the command-line arguments you pass when you run the program. If you run `java HelloShop coupon10 freeship`, then `args[0]` is `\"coupon10\"` and `args[1]` is `\"freeship\"`. This lesson doesn't use `args`, but the JVM still requires the parameter to be there.\n\nTogether, `public static void main(String[] args)` is the exact signature the JVM looks for as the entry point of a standalone Java application. Change any of those five pieces and the program won't start.\n\n### `System.out.println(\"Welcome to MyShop\")`\n\nThis is the line that actually does something visible. Reading it from left to right:\n\n- `System` is a class from the standard library.\n- `out` is a field on `System` that represents the standard output stream, which is your terminal in most setups.\n- `println` is a method on `out` that prints whatever you pass to it and then moves to a new line.\n\nThe string `\"Welcome to MyShop\"` is the argument we hand to `println`. The double quotes mark it as a `String` literal. The semicolon at the end finishes the statement.\n\nThe second `println` works exactly the same way, just with a different message. Two statements, two lines of output.\n\n---\n\n# Saving the File\n\nThe file must be named `HelloShop.java`. The rule is: when a class is declared `public`, the file name must match the class name exactly, plus the `.java` extension. Both capitalization and spelling matter.\n\n\n| Class declaration | Required file name |\n| ------------------------- | ------------------ |\n| `public class HelloShop` | `HelloShop.java` |\n| `public class CartTotal` | `CartTotal.java` |\n| `public class OrderList` | `OrderList.java` |\n\n\nIf you save the file as `helloshop.java` or `Helloshop.java`, the compiler refuses to compile it and reports an error along these lines:\n\n\n```shell\nHelloShop.java:1: error: class HelloShop is public, should be declared in a file named HelloShop.java\npublic class HelloShop {\n ^\n```\n\n\nThe fix is to rename the file so the name matches the public class.\n\n---\n\n# Compiling with `javac`\n\nJava source files are not directly runnable. You first compile them into bytecode that the JVM can execute. The tool that does this is `javac`, the Java compiler that ships with the JDK.\n\nOpen a terminal, change into the directory that contains `HelloShop.java`, and run:\n\n\n```shell\njavac HelloShop.java\n```\n\n\nIf everything is correct, `javac` produces no output and creates a new file named `HelloShop.class` in the same directory. That `.class` file holds the bytecode. You can verify it's there:\n\n\n```shell\nls\n```\n\n\nThe full pipeline from source to output looks like this:\n\n\n```mermaid\nflowchart LR\n A[HelloShop.java
source code]:::cyan --> B[javac
compiler]:::orange\n B --> C[HelloShop.class
bytecode]:::teal\n C --> D[java
launcher]:::orange\n D --> E[JVM]:::green\n E --> F[Terminal output]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\n`javac` and the JVM are doing real work internally: parsing the source, checking types, generating bytecode, then loading and verifying that bytecode at run time. For now, treat `javac` as a black box that turns `.java` into `.class`.\n\n---\n\n# Running with `java`\n\nOnce you have `HelloShop.class`, you run the program with the `java` launcher. From the same directory:\n\n\n```shell\njava HelloShop\n```\n\n\nTwo small rules apply here:\n\n- You pass the **class name**, not a file name. So it's `java HelloShop`, not `java HelloShop.class` and not `java HelloShop.java`. The launcher already knows it's looking for bytecode.\n- You have to be in the directory that contains `HelloShop.class` (or otherwise tell `java` where to look). If you run `java HelloShop` from your home directory but the class file lives in `~/projects/myshop`, the launcher won't find it.\n\nIf you pass command-line arguments, they show up in the `args` array inside `main`. For example:\n\n\n```shell\njava HelloShop coupon10 freeship\n```\n\n\nIn that invocation, `args[0]` is `\"coupon10\"` and `args[1]` is `\"freeship\"`. The program above ignores `args`, so the output is the same either way.\n\nA quick note on newer Java versions: since Java 11, you can also run a single-file program directly with `java HelloShop.java`, and the JDK compiles and runs it in one step. That's handy for tiny scripts, but the `javac` then `java` flow is the standard one for larger projects.\n\n---\n\n# Running It in an IDE\n\nThe terminal flow shows what's really happening, but day-to-day work is mostly done in an IDE. IntelliJ IDEA Community Edition is a good free option, and it handles the compile-and-run cycle for you.\n\nInside IntelliJ:\n\n1. Create a new project, pick **Java** as the language, and select the JDK you installed earlier.\n2. In the project's `src` folder, create a new Java class named `HelloShop`. IntelliJ creates a `HelloShop.java` file with a skeleton in it.\n3. Replace the skeleton with the program from the top of this lesson.\n4. Look at the gutter to the left of the `main` method. A small green triangle appears next to the line `public static void main(String[] args)`. Click it and choose **Run 'HelloShop.main()'**.\n5. IntelliJ compiles the file, runs the class, and shows the output in the **Run** tool window at the bottom of the screen.\n\nThe output matches the terminal flow. Internally, IntelliJ called `javac` and then `java`. The IDE also re-runs the build whenever the file changes, so there's no need to invoke `javac` manually each time.\n\nVS Code and Eclipse work similarly: open the project, find the `main` method, click the run action next to it. The mechanics are the same, only the buttons move.\n\n---\n\n# Common Errors and Fixes\n\nMost beginner errors come from typos or layout mistakes, not from misunderstanding Java. Here are the common ones and how to read the compiler's message.\n\n### Mismatched file name\n\n**What's wrong with this code?**\n\nThe source is correct, but the file is saved as `helloshop.java`:\n\n\n```java\npublic class HelloShop {\n public static void main(String[] args) {\n System.out.println(\"Welcome to MyShop\");\n }\n}\n```\n\n\nWhen you run `javac helloshop.java`, the compiler reports an error like:\n\n\n```shell\nhelloshop.java:1: error: class HelloShop is public, should be declared in a file named HelloShop.java\npublic class HelloShop {\n ^\n1 error\n```\n\n\n**Fix:** Rename the file to `HelloShop.java` so it matches the public class name, then recompile.\n\n### Misspelled `System`\n\n**What's wrong with this code?**\n\n\n```java\npublic class HelloShop {\n public static void main(String[] args) {\n Sytem.out.println(\"Welcome to MyShop\");\n }\n}\n```\n\n\n`Sytem` is missing an `s`. The compiler doesn't know what `Sytem` is, so it reports:\n\n\n```shell\nHelloShop.java:3: error: cannot find symbol\n Sytem.out.println(\"Welcome to MyShop\");\n ^\n symbol: variable Sytem\n location: class HelloShop\n1 error\n```\n\n\n**Fix:** Correct the spelling:\n\n\n```java\npublic class HelloShop {\n public static void main(String[] args) {\n System.out.println(\"Welcome to MyShop\");\n }\n}\n```\n\n\n\"`cannot find symbol`\" is one of the most common error messages in Java. It almost always means a typo in a class name, method name, or variable name. Read the line, find the symbol the compiler is pointing at, and check the spelling and capitalization.\n\n### Missing semicolon\n\n**What's wrong with this code?**\n\n\n```java\npublic class HelloShop {\n public static void main(String[] args) {\n System.out.println(\"Welcome to MyShop\")\n }\n}\n```\n\n\nThere's no semicolon after the `println` call. The compiler reports an error like:\n\n\n```shell\nHelloShop.java:3: error: ';' expected\n System.out.println(\"Welcome to MyShop\")\n ^\n1 error\n```\n\n\n**Fix:** Add the missing semicolon at the end of the statement:\n\n\n```java\nSystem.out.println(\"Welcome to MyShop\");\n```\n\n\nJava uses semicolons to mark the end of statements. Forgetting one is a common slip when starting out.\n\n### Typo in the `main` signature\n\nIf the JVM can't find a method matching `public static void main(String[] args)`, it can't start your program. For example, writing `Main` with a capital `M`:\n\n\n```java\npublic class HelloShop {\n public static void Main(String[] args) {\n System.out.println(\"Welcome to MyShop\");\n }\n}\n```\n\n\nThis compiles fine, because `Main` is a perfectly legal method name. But when you run `java HelloShop`, the JVM reports something like:\n\n\n```shell\nError: Main method not found in class HelloShop, please define the main method as:\n public static void main(String[] args)\n```\n\n\n**Fix:** Rename `Main` back to `main`, lowercase. Other variations cause the same problem: missing `static`, the wrong return type, or the wrong parameter list.\n\n### Wrong arguments to `java`\n\nIf you run the program incorrectly, you don't get a compiler error, you get a launcher error. Two common slips:\n\nRunning it with the `.class` extension:\n\n\n```shell\njava HelloShop.class\n```\n\n\nThis produces an error like:\n\n\n```shell\nError: Could not find or load main class HelloShop.class\n```\n\n\nThe launcher took `HelloShop.class` as a class name and looked for a class literally called `HelloShop.class`, which doesn't exist.\n\nRunning it from the wrong directory:\n\n\n```shell\ncd ~\njava HelloShop\n```\n\n\nIf `HelloShop.class` lives in `~/projects/myshop` but you're in `~`, the launcher can't find it. You get a similar error:\n\n\n```shell\nError: Could not find or load main class HelloShop\n```\n\n\n**Fix:** Pass the class name without an extension, and run the command from the directory that holds the `.class` file:\n\n\n```shell\ncd ~/projects/myshop\njava HelloShop\n```\n","pageType":"java"}

First Java Program

Get Premium