Java Basics & Setup: Your First Program

Welcome to the very beginning. This lesson assumes you have never written a line of code in your life, and that is exactly the right place to start. By the end you will understand what Java actually is, how the pieces (JDK, JRE, JVM) fit together, how to install everything on your own machine, and you will have written, compiled, and run a real Java program that prints to the screen, stores data in variables, and reads what you type. We go slowly and explain the why behind every step, because the people who struggle later are almost always the ones who skipped the foundations. And because this is a course for testers, we finish by explaining why Java is the language most Selenium automation is written in—so you know this groundwork pays off directly.

What is Java?

Java is a programming language—a structured way of writing instructions that a computer can carry out. You write those instructions as plain text (called source code), and a chain of tools turns them into something the machine runs. Java was created in the mid-1990s and is still, decades later, one of the most popular languages in the world. It powers banking systems, Android apps, huge enterprise back-ends, and—importantly for us—a very large share of the world’s automated software tests.

Java’s most famous promise is “write once, run anywhere”. Code you write on a Windows laptop runs unchanged on a Mac, a Linux server, or a cloud build machine. That portability is not magic; it comes from a clever design we will unpack in a moment. Java is also statically typed (you declare what kind of data each variable holds, and the compiler checks it before the program runs) and object-oriented (code is organised into reusable building blocks called classes and objects—the subject of Module 4). For now, just hold onto one idea: Java catches a lot of your mistakes before the program ever runs, which is exactly the kind of safety a tester appreciates.

JVM, JRE, and JDK: three letters that confuse everyone

These three acronyms trip up nearly every beginner, so let us settle them clearly, from the inside out.

• JVM — Java Virtual Machine. This is the engine that actually runs Java programs. When you compile your code, it does not turn into Windows-specific or Mac-specific instructions; it turns into an in-between format called bytecode. The JVM reads that bytecode and executes it on whatever platform it is installed on. There is a different JVM built for Windows, for Mac, for Linux—but they all understand the same bytecode. That is the secret behind “write once, run anywhere”.
• JRE — Java Runtime Environment. This is the JVM plus the standard libraries (ready-made code for things like text, dates, and collections) that programs need to run. If all you wanted to do was run an existing Java program, the JRE would be enough.
• JDK — Java Development Kit. This is the JRE plus the tools you need to create Java programs—most importantly the compiler (javac), which turns your source code into bytecode. Because we are writing code, the JDK is what you install. It contains everything else inside it.

Installing the JDK

Let us get a working Java on your machine. You only need to do this once.

1. Download a JDK. A good, free choice is Eclipse Temurin (from Adoptium) or Oracle JDK. Pick a long-term support (LTS) version such as Java 17 or Java 21—these are stable and widely supported by Selenium.
2. Run the installer and accept the defaults. On Windows, allow it to set the JAVA_HOME environment variable and add Java to your PATH if the installer offers—this lets you run Java from any terminal.
3. Verify it worked. Open a terminal (Command Prompt, PowerShell, or Terminal) and type the command below. You should see a version number printed back.

java -version
javac -version

If both commands print a version (for example openjdk version "21.0.2"), your JDK is installed correctly. java runs programs; javac compiles them—seeing both confirms you have the full development kit, not just the runtime.

Installing an IDE

You can write Java in Notepad, but nobody does. An IDE (Integrated Development Environment) is a specialised editor that highlights your code, auto-completes as you type, flags mistakes instantly, and runs your program with one click. The two most popular for Java are:

• IntelliJ IDEA (Community Edition is free). This is the most popular choice in the test-automation world and what most Selenium tutorials use. Its autocomplete and error detection are excellent for beginners.
• Eclipse (free and open source). A long-standing, capable IDE still used in many companies.

Either is fine; this course uses examples that work in both. Download one, install it, and when it asks, point it at the JDK you just installed (most IDEs detect it automatically). Then create a new Java project to get started.

Your first program

Create a new file called Hello.java and type this exactly. The file name must match the class name (Hello)—that is a firm Java rule.

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

Click Run in your IDE. You should see Hello, QALaunch! appear in the console at the bottom. Congratulations—you are a programmer. Now let us understand every piece, because this skeleton appears in almost every Java program you will ever write:

• public class Hello { ... } — A class is a container for your code. Everything in Java lives inside a class. This one is named Hello, matching the file name.
• public static void main(String[] args) — This is the main method, the single entry point where the program starts running. When you hit Run, the JVM looks for exactly this line and begins here. The exact wording matters; we will decode static, void, and parameters in later modules. For now, treat it as the fixed “start here” sign.
• System.out.println("...") — This prints a line of text to the console. println means “print line” (it adds a line break after); its cousin System.out.print prints without the line break.
• The semicolon ; ends a statement, like a full stop ends a sentence. Forgetting it is the most common beginner error.

Comments

Comments are notes for humans that the computer ignores completely. Use them to explain why code does something. Java has two kinds:

// This is a single-line comment. Everything after // on this line is ignored.

/* This is a block comment.
   It can span multiple lines. */

System.out.println("Running");  // comments can also sit after code

Variables and primitive data types

A variable is a named box that stores a value. In Java you must declare what type of value a box holds before you use it. Java has eight built-in primitive types—the simplest, most basic kinds of data. Here are the ones you will actually use day to day:

int score = 95;            // whole numbers (integers)
long bigNumber = 9000000000L;  // very large whole numbers (note the L)
double price = 19.99;      // decimal numbers (the default for decimals)
float rate = 3.5f;         // decimal numbers, less precise than double (note the f)
boolean isPassing = true;  // only two values: true or false
char grade = 'A';          // a single character, in single quotes

The pattern is always the same: type, name, equals sign, value, semicolon. The remaining primitives—byte and short—are rarely needed by beginners. The one you will reach for most in testing is boolean, because assertions ultimately boil down to true-or-false questions: did the page title match? Is the button enabled?

Strings

A String is a piece of text—a sequence of characters like a word, a sentence, or a URL. Strings are so common they feel like a primitive, but technically String is a class (note the capital S). You write string literals in double quotes (single quotes are only for a single char).

String name = "Priya";
String url = "https://the-internet.herokuapp.com";

// Joining strings together is called concatenation, using +
String greeting = "Hello, " + name + "!";
System.out.println(greeting);          // Hello, Priya!

// Strings have useful built-in methods:
System.out.println(name.length());     // 5
System.out.println(name.toUpperCase()); // PRIYA
System.out.println(url.contains("heroku")); // true

That last method, contains, returns a boolean—and it is exactly the kind of check you will write constantly when verifying that a web page shows the right text.

Type casting

Sometimes you need to convert a value from one type to another. This is called casting. Converting a smaller type into a larger one (say int into double) is safe and automatic—this is widening. Going the other way (double into int) can lose information, so Java forces you to say so explicitly with a cast in parentheses—this is narrowing.

int whole = 10;
double asDecimal = whole;        // automatic widening: 10.0

double pi = 3.99;
int truncated = (int) pi;        // explicit narrowing cast: 3 (decimals dropped, not rounded)

System.out.println(asDecimal);   // 10.0
System.out.println(truncated);   // 3

Notice that casting a double to an int simply chops off the decimal part—it does not round. That surprise catches people out, so remember it.

Reading input with Scanner

Programs become interactive when they can read what the user types. Java’s Scanner class does this. To use it, you first import it (bring it in from Java’s standard library), then create one that reads from System.in (the keyboard).

import java.util.Scanner;   // put this at the very top of the file

public class Greeter {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("What is your name? ");
        String name = scanner.nextLine();      // reads a whole line of text

        System.out.print("What is your age? ");
        int age = scanner.nextInt();           // reads a whole number

        System.out.println("Hi " + name + ", next year you will be " + (age + 1));

        scanner.close();   // tidy up when finished
    }
}

Key Scanner methods: nextLine() reads a full line of text, next() reads a single word, nextInt() reads a whole number, and nextDouble() reads a decimal. A classic gotcha: mixing nextInt() and nextLine() can leave a stray line break behind—if a later nextLine() seems to be skipped, that is why, and an extra scanner.nextLine() to consume the leftover fixes it.

Why Java for Selenium automation?

You might wonder why a testing course starts with Java at all. Here is the honest, practical answer. Selenium—the dominant tool for automating web browsers—offers official support for several languages, but Java has by far the largest testing ecosystem around it. The vast majority of job postings for automation engineers list Java; the most tutorials, Stack Overflow answers, and sample frameworks are in Java; and the key testing tools (TestNG, JUnit, Maven, Cucumber, RestAssured) are mature and first-class in the Java world. Java’s static typing also means many mistakes are caught at compile time rather than mid-test-run, which makes large automation suites more reliable. In short: learning Java well is the single highest-leverage investment you can make as a web-automation tester, and everything you learned today—variables, types, strings, input—is used in every single Selenium test you will ever write.

char letter = 'A';
int code = letter;                // 65
char next = (char) (letter + 1);  // 'B'
System.out.println(code + " " + next);   // 65 B