Java Introduction: What It Is, How It Runs, Your First Program

Java is one of the most widely used programming languages for backend services, Android apps, enterprise software and coding interviews. Before you can write anything useful, though, you need a clear mental model of what happens between typing code and seeing it run. This lesson gives you that model and ends with a working program on your machine.

What is Java?

Java is a general-purpose, object-oriented, statically typed language. Statically typed means every variable has a type that is checked before the program runs, so a whole category of mistakes is caught at compile time instead of in production. Object-oriented means programs are organised around classes and objects, which you will meet in Java Classes and Objects.

Java's famous promise is "write once, run anywhere". When you compile a Java file, the compiler does not produce machine code for your specific processor. It produces bytecode, a compact instruction set stored in .class files. A program called the Java Virtual Machine (JVM) reads that bytecode and executes it. Because there is a JVM for Windows, macOS and Linux, the same .class file runs on all of them without recompiling.

JDK, JRE and JVM: what is the difference?

These three acronyms confuse almost every beginner. They are layers, each sitting inside the next one.

Installing Java and checking it works

Download a JDK (for example Eclipse Temurin or Oracle JDK) for your operating system, install it, then open a new terminal and check both tools. You need javac (the compiler) and java (the launcher) to be found.

javac -version
java -version

javac 17.0.9
java version "17.0.9" 2023-10-17 LTS

Your exact version numbers will differ, and that is fine as long as both commands print something. If the terminal says 'javac' is not recognized (Windows) or command not found (macOS/Linux), the JDK is either not installed or its bin folder is not on your PATH.

Your first Java program

Create a file called HelloWorld.java and type exactly the following. The file name must match the public class name, including capital letters.

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

Hello, World!

Every part of that program has a job:

• public class HelloWorld declares a class. In Java, all code lives inside a class.
• public static void main(String[] args) is the entry point. The JVM looks for a method with exactly this signature and starts there. static means it can run without creating an object first, and void means it returns nothing.
• String[] args holds any command-line arguments you pass in.
• System.out.println(...) prints text followed by a newline. Every statement ends with a semicolon.

Compile first, then run

Java is a two-step process. javac turns your source file into bytecode, and java hands that bytecode to the JVM. Notice that you compile with the file name (HelloWorld.java) but run with the class name (HelloWorld, no extension).

javac HelloWorld.java
java HelloWorld

Hello, World!

After the first command you will find a new HelloWorld.class file next to your source. That is the bytecode. Since Java 11 you can also skip the visible compile step for single-file programs with java HelloWorld.java, which compiles in memory and runs immediately. It is handy for experiments, but understanding the two real steps helps you read compiler errors.

Printing, comments and escape characters

print keeps the cursor on the same line, println moves to the next one. Comments are ignored by the compiler and exist for humans. Escape sequences start with a backslash and let you print characters that would otherwise break the string. The last two lines show a classic gotcha: + works left to right, so "Total: " + 40 + 2 builds a string first and glues 2 on the end.

public class Welcome {
    public static void main(String[] args) {
        // A single-line comment: the compiler ignores it
        System.out.print("Loading");
        System.out.print("...");
        System.out.println(" done");

        /* A block comment
           can span several lines */
        System.out.println("Name:\tAsha");
        System.out.println("Quote: \"Practice daily\"");
        System.out.println("Line one\nLine two");
        System.out.println("Total: " + 40 + 2);
        System.out.println("Total: " + (40 + 2));
    }
}

Loading... done
Name:	Asha
Quote: "Practice daily"
Line one
Line two
Total: 402
Total: 42

Passing input with command-line arguments

The args array in main receives whatever you type after the class name. This is the simplest way to make a program react to input before you learn about Scanner or files.

public class Greeter {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Hello, stranger! Pass your name as an argument.");
        } else {
            System.out.println("Hello, " + args[0] + "!");
        }
    }
}

$ java Greeter
Hello, stranger! Pass your name as an argument.

$ java Greeter Asha
Hello, Asha!

Common mistakes

• File name does not match the public class. Saving HelloWorld code as hello.java gives error: class HelloWorld is public, should be declared in a file named HelloWorld.java.
• Wrong capitalisation. Writing system.out.println or string instead of System and String produces error: package system does not exist or cannot find symbol. Java is case-sensitive.
• Missing semicolon. The compiler reports error: ';' expected and points at the end of the previous line.
• Running with the extension. java HelloWorld.class fails with Error: Could not find or load main class HelloWorld.class. Use java HelloWorld.
• Misspelling `main`. If the signature is not exactly public static void main(String[] args), you get Error: Main method not found in class HelloWorld.

How this shows up in interviews and real projects

Interviewers often ask the JDK/JRE/JVM question as a warm-up, and "why is Java platform independent?" is really the bytecode-and-JVM idea from this lesson. In real projects you rarely run javac by hand. Build tools such as Maven or Gradle and IDEs do it for you, but the same compile-then-run pipeline sits underneath, so understanding it makes build errors far less mysterious. When you are ready to apply what you learn, browse open roles to see what employers list under Java.