Java | Get Started

The JDK contains compiler and development tools; the JVM executes bytecode. In day-to-day development, install a supported JDK and record its version so a teammate and CI build the same source with the same language rules.

Treat this as an explicit contract in code review: name the input, validate it before a side effect, make the resulting state observable in a focused test and keep the rule close to the method that owns it.

javac checks and compiles source into class files. java starts a class with a main method. Treat a compiler error as useful feedback about an incomplete contract, not as something to silence with random edits.

Treat this as an explicit contract in code review: name the input, validate it before a side effect, make the resulting state observable in a focused test and keep the rule close to the method that owns it.

A small program begins at public static void main(String[] args). Keep early examples narrow: read a value, transform it, print an observable result and then add one change at a time.

Treat this as an explicit contract in code review: name the input, validate it before a side effect, make the resulting state observable in a focused test and keep the rule close to the method that owns it.

Source files, compiled output, dependencies and configuration belong in separate predictable locations. A build tool such as Maven or Gradle becomes valuable when it makes those boundaries repeatable rather than when it merely adds abstraction.

Treat this as an explicit contract in code review: name the input, validate it before a side effect, make the resulting state observable in a focused test and keep the rule close to the method that owns it.

A productive Java practice loop is deliberately small. Compile after one change, make the normal output visible, add a boundary case, and then decide whether the next improvement belongs in a method, an object or a test. The goal is not typing more Java syntax; it is building evidence that the rule continues to hold when input, scale and failure behavior change.

• Step 1: make jdk, jre and jvm observable with one normal case, one boundary case and one invalid-input or failure case before expanding the example.
• Step 2: make compile before running observable with one normal case, one boundary case and one invalid-input or failure case before expanding the example.
• Step 3: make one clear entry point observable with one normal case, one boundary case and one invalid-input or failure case before expanding the example.
• Step 4: make project boundaries observable with one normal case, one boundary case and one invalid-input or failure case before expanding the example.

Before accepting a change, ask what values are valid, who owns mutation, how an invalid value is reported, which unit or precision applies, and which test proves the behavior. These questions turn beginner syntax into the habits required for production Java services.

Keep framework concerns outside the small example until the local contract is clear. A controller, database client or queue cannot repair a vague type, a hidden state transition or an undefined failure result; they only make the defect harder to observe.

Start by naming the value the next line depends on. This keeps the lesson input explicit before we apply a transformation or call an external boundary. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    public static void main(String[] args) {
        String lesson = "Java Get Started";
        System.out.println(lesson.toUpperCase());
    }
}

JAVA GET STARTED

Try next: Replace the sample value with one from your own notes, predict the result, and then run it.

Start by naming the value the next line depends on. This keeps the lesson input explicit before we apply a transformation or call an external boundary. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    public static void main(String[] args) {
        String lesson = "Java Get Started";
        System.out.println(lesson.toUpperCase());
    }
}

JAVA GET STARTED

Try next: Replace the sample value with one from your own notes, predict the result, and then run it.

Start by naming the value the next line depends on. This keeps the lesson input explicit before we apply a transformation or call an external boundary. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    public static void main(String[] args) {
        String lesson = "Java Get Started";
        System.out.println(lesson.toUpperCase());
    }
}

JAVA GET STARTED

Try next: Replace the sample value with one from your own notes, predict the result, and then run it.

A small guard makes the allowed and rejected path visible. We want a caller to receive an intentional result instead of discovering an unexplained failure later. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    static boolean accepted(String value) {
        return value != null && !value.isBlank();
    }

    public static void main(String[] args) {
        System.out.println(accepted("Java Get Started"));
    }
}

true

Try next: Try an empty value as well as the normal value and describe why the two outcomes differ.

This step returns a value instead of mixing the rule with display or storage work. That separation gives us a small unit we can run, test, and reuse. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    static int doubleValue(int value) { return value * 2; }

    public static void main(String[] args) {
        System.out.println(doubleValue(6));
    }
}

12

Try next: Call the same rule twice with different inputs and confirm that each result depends only on its input.

Use a named branch where the business rule changes. A future reader should be able to point at the condition and state the result for both sides. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    public static void main(String[] args) {
        int score = 7;
        String result = score >= 5 ? "ready" : "review";
        System.out.println(result);
    }
}

ready

Try next: Change the boundary value by one and explain exactly which branch becomes active.

Collections become safer when we can see which value is read, which value is derived, and whether the original collection remains owned by the caller. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> lessons = List.of("Java Get Started", "boundary");
        System.out.println(String.join(" | ", lessons));
    }
}

Java Get Started | boundary

Try next: Add one more item and predict the derived result before executing the code.

A named outcome is easier to test than an implied side effect. We can now distinguish a successful path from a rejected path without guessing from console noise. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    record Outcome(String status, String lesson) {}

    public static void main(String[] args) {
        Outcome outcome = new Outcome("ready", "Java Get Started");
        System.out.println(outcome.status());
    }
}

ready

Try next: Rename the outcome in your own words while preserving the same success and failure rule.

Work through one value at a time. The point is not to memorize syntax; it is to see how the accumulator or output changes after each repeatable step. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    public static void main(String[] args) {
        int total = 0;
        for (int value : new int[] {1, 2, 3}) total += value;
        System.out.println(total);
    }
}

6

Try next: Use a shorter collection first, then add one value and trace the extra iteration aloud.

The core rule prepares a value, while the outer line decides how to show it. That keeps the result usable by a UI, test, API, or command-line caller. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    static String display(String value) { return "Lesson: " + value; }

    public static void main(String[] args) {
        System.out.println(display("Java Get Started"));
    }
}

Lesson: Java Get Started

Try next: Change only the display text and verify that the underlying rule and result stay unchanged.

A useful example includes the nearest boundary, not only the happy path. We are making the behavior inspectable before a real caller relies on it. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    static int quantity(int value) {
        if (value < 1) throw new IllegalArgumentException("quantity must be positive");
        return value;
    }

    public static void main(String[] args) {
        System.out.println(quantity(1));
    }
}

1

Try next: Try the lowest supported value and then one value just outside the accepted range.

A compact assertion turns the lesson into a repeatable promise. It helps us catch a changed rule before a larger program hides the source of the mistake. We are applying that habit while revisiting Java Get Started.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    public static void main(String[] args) {
        String result = "Java Get Started".toUpperCase();
        if (!result.equals("JAVA GET STARTED")) throw new AssertionError("contract failed");
        System.out.println("contract holds");
    }
}

contract holds

Try next: Deliberately change the expected value once, observe the failed check, and then restore the correct contract.

• Avoid: treating jdk, jre and jvm as a syntax trick while leaving its domain rule, error behavior or ownership implicit.
• Avoid: treating compile before running as a syntax trick while leaving its domain rule, error behavior or ownership implicit.
• Avoid: treating one clear entry point as a syntax trick while leaving its domain rule, error behavior or ownership implicit.
• Avoid: treating project boundaries as a syntax trick while leaving its domain rule, error behavior or ownership implicit.

• State the type, valid range and unit before describing the line of syntax.
• Explain what happens for empty, malformed, null or boundary input and why that outcome is intentional.
• Separate a pure calculation from printing, storage, networking or another outer side effect.
• Name the test that would reveal a regression in the rule, not merely that a line of code executed.
• Describe time, memory and precision costs using the actual types and collection sizes involved.