Syntax Basics

Java is statically typed, and all code lives inside classes. Statements end with semicolons and blocks are wrapped in braces. This chapter covers classes and the main method, variables and var, methods, branching and loops, switch expressions, and working with strings.

Classes and main

A class bundles state (fields) with behavior (methods). A runnable program needs one class with a main method. The static keyword means the method belongs to the class itself, so it can be called without creating an object first.

package com.example.basics;

public class Greeter {
    private final String greeting; // field

    public Greeter(String greeting) { // constructor
        this.greeting = greeting;
    }

    public String greet(String name) { // instance method
        return greeting + ", " + name;
    }

    public static void main(String[] args) {
        Greeter greeter = new Greeter("Hello");
        System.out.println(greeter.greet("Java"));
    }
}

There are four access levels: public (visible everywhere), protected (same package plus subclasses), package-private (no modifier at all), and private (only inside the class). The usual habit is to keep fields private and expose only the methods callers actually need.

Variables and var

You declare a variable with a type and a name. For local variables you can write var and let the compiler infer the type from the initializer. This is not dynamic typing: the inferred type is fixed for the life of the variable. Mark a variable final to prevent reassignment.

int count = 10;
double ratio = 0.75;
boolean done = false;
String title = "Java";

var names = new java.util.ArrayList<String>(); // inferred as ArrayList<String>
names.add("Duke");

final int max = 100;
// max = 200; // compile error: cannot assign a value to final variable

var only works for local variables, not for fields or method parameters. It shines when the type is long and already obvious from the right-hand side.

Methods

A method declaration lists a return type, a name, and parameters; use void when nothing is returned. Overloading lets you define several methods with the same name as long as their parameter lists differ. Java always passes arguments by value; for objects, the value being copied is the reference.

public class MathUtil {
    static int add(int a, int b) {
        return a + b;
    }

    static double add(double a, double b) { // overload
        return a + b;
    }

    static int sum(int... values) { // varargs
        int total = 0;
        for (int v : values) total += v;
        return total;
    }
}

Branching and loops

The usual suspects are all here: /, the classic , the enhanced for-each loop, , and . Use to leave a loop early and to skip to the next iteration.