Every Java program works by storing and manipulating values, and a variable is simply a named location that holds one of those values. Unlike some other languages, Java requires every variable to declare its type upfront, which might feel strict at first but catches a large class of mistakes before the program ever runs.

Declaring a variable

int age = 25;
String name = "Sam";
boolean isActive = true;

Each line follows the same pattern: the type, then the name, then the starting value. Once declared with a type, a variable can never hold a value of a different, incompatible type later in the program.

Primitive types versus objects

Java splits its types into two groups. Primitive types, such as int, double, boolean and char, hold simple values directly and are extremely lightweight. Everything else, including String and any custom class, is a reference type, meaning the variable actually holds a reference pointing to an object stored elsewhere in memory. This distinction explains many small quirks in Java, such as why comparing two String values with == can behave unexpectedly, covered in more depth in the tutorial comparing == and equals in the interview questions section.

Common types

• int: whole numbers, such as 5 or -20, good for counting.
• double: numbers with decimals, such as 3.14, needed whenever a fraction matters, like a price.
• boolean: only ever true or false, used for conditions and flags.
• char: a single character, such as 'A'.
• String: text made of many characters, such as "hello".

Type casting

Sometimes a value needs converting between types. Converting from a smaller type to a larger one, like int to double, happens automatically since no information is lost. Going the other way needs an explicit cast, since it might lose precision:

double price = 9.75;
int wholePart = (int) price;  // 9, the decimal part is discarded

The final keyword

Adding final before a variable declaration prevents it from ever being reassigned after its first value is set, which is useful for values that represent a constant, such as a fixed configuration limit:

final int MAX_USERS = 100;

A tip on naming

Clear variable names make code far easier to read months later. totalPrice communicates its purpose instantly, while a name like tp forces anyone reading the code to go hunting for context. Good naming is a habit that pays off every single time the code is revisited.

Programs rarely do the exact same thing every time; they need to react differently depending on the situation. Java offers if, else and switch as the core tools for making these decisions, and knowing when each fits best makes conditional code far easier to read.

The if statement

if (age >= 18) {
  System.out.println("Adult");
}

The code inside the braces only runs when the condition evaluates to true. If the condition is false, that block is simply skipped.

Adding else and else if

if (score >= 90) {
  grade = "A";
} else if (score >= 80) {
  grade = "B";
} else {
  grade = "C";
}

Java checks each condition from top to bottom and stops at the first one that matches, which is why order matters here: a score of 95 matches the first condition and never even reaches the later checks.

A common mistake

Using a single equals sign instead of two inside a condition is one of the most frequent beginner errors. Writing if (isReady = true) assigns the value true to isReady rather than comparing it, and in Java this specific mistake usually fails to compile when isReady is a boolean, which is one small safety net the language provides compared to some others.

The switch statement

When one value is compared against several fixed options, switch is often cleaner than a long chain of else if statements:

switch (day) {
  case 1: name = "Mon"; break;
  case 2: name = "Tue"; break;
  default: name = "Other";
}

The break keyword stops execution from falling through into the next case; forgetting it is a classic bug where more code runs than intended. The default case runs when nothing else matches, similar to a final else.

Modern switch expressions

Newer versions of Java allow switch to be used as an expression that directly produces a value, using an arrow instead of a colon, which also removes the need for break entirely:

String name = switch (day) {
  case 1 -> "Mon";
  case 2 -> "Tue";
  default -> "Other";
};

The ternary operator

For a simple choice between two values, the ternary operator condenses an entire if-else into one line:

String status = (age >= 18) ? "Adult" : "Minor";

Choosing the right tool

Use if and else for a small number of distinct conditions, especially ones involving comparisons like greater than or less than. Reach for switch once several fixed, specific values are being compared against a single variable, and save the ternary operator for short, simple choices where a full if-else would only add unnecessary length.

Repeating an action without copying the same code over and over is one of the first real superpowers a new programmer gains, and Java provides three main loop types, each suited to a slightly different situation.

The for loop

for (int i = 1; i <= 5; i++) {
  System.out.println(i);
}

A for loop is the natural choice when the number of repetitions is known ahead of time. It has three parts separated by semicolons: a starting value, a condition checked before every pass, and a step that runs after each pass, here incrementing i by one.

The while loop

int count = 0;
while (count < 3) {
  System.out.println(count);
  count++;
}

A while loop fits better when the number of repetitions is not known upfront and instead depends on some condition becoming false, such as reading input until the user chooses to stop.

The do-while loop

A do-while loop is a close relative of while, except it checks its condition after running the block rather than before, guaranteeing the body runs at least once:

int attempts = 0;
do {
  attempts++;
} while (attempts < 1);

The for-each loop

For visiting every item in an array or a collection, the for-each loop reads the most naturally, since there is no index to manage manually:

for (String fruit : fruits) {
  System.out.println(fruit);
}

break and continue

Two keywords let a loop change course early. break exits the loop entirely, useful once a search has already found what it was looking for. continue skips straight to the next repetition without finishing the current one:

for (int i = 0; i < items.size(); i++) {
  if (items.get(i) == null) continue;
  if (items.get(i).equals(target)) break;
}

Nested loops

A loop can contain another loop, commonly used for working through a grid of values, such as rows and columns:

for (int row = 0; row < 3; row++) {
  for (int col = 0; col < 3; col++) {
    System.out.print(row + "," + col + " ");
  }
}

Avoiding endless loops

Every loop needs a way to eventually stop. A while loop whose condition never becomes false, or a for loop whose step never moves the counter toward its limit, runs forever and freezes the program. Whenever a loop behaves unexpectedly, checking that its stopping condition can genuinely be reached is usually the first thing worth verifying.

Choosing between them

Reach for a for loop when the repeat count is known, a while loop when it depends on a changing condition, and a for-each loop whenever the goal is simply to visit every item in a collection without needing its position.

A method is a named, reusable block of code that performs one specific job. Writing logic once as a method and calling it wherever it is needed avoids repetition and gives each step in a program a clear, readable name.

A simple method

public void sayHello() {
  System.out.println("Hello");
}

Calling it is just as simple: sayHello(); runs the code inside exactly as if it had been typed inline, but with a name that explains what it does.

Passing information in with parameters

public void greet(String name) {
  System.out.println("Hi " + name);
}

Calling greet("Ann") prints "Hi Ann". The parameter name acts as a placeholder that receives whatever value is passed in at the call site, and a method can accept several parameters separated by commas.

Returning a result

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

Replacing void with a real type, here int, allows the method to send a value back to whoever called it, which can then be stored or used immediately: int total = add(2, 3);

Overloading: same name, different parameters

Java allows multiple methods to share the same name as long as their parameter lists differ, which is called overloading. This lets related operations read naturally under one shared name:

public int add(int a, int b) { return a + b; }
public double add(double a, double b) { return a + b; }

Variable-length parameter lists

When the exact number of arguments is not known ahead of time, varargs, written with three dots, lets a method accept any number of values of a given type:

public int sum(int... numbers) {
  int total = 0;
  for (int n : numbers) total += n;
  return total;
}

This single method now accepts sum(1, 2), sum(1, 2, 3, 4), or even no arguments at all.

Static versus instance methods

A static method belongs to the class itself and can be called without creating an object, useful for utility operations that do not depend on any particular object's data. An instance method, the more common kind, operates on the specific object it is called on and can access that object's own fields.

Why methods matter

• They eliminate repeated code, since the same logic lives in one place.
• They give each step of a program a clear, descriptive name, so code reads closer to plain language.
• A bug only needs fixing once, in the method itself, rather than everywhere the logic was copied.

As a program grows, the difference between a tangle of repeated logic and a set of small, well-named methods is often the difference between code that is easy to maintain and code that quietly becomes impossible to change safely.

Classes and objects sit at the very centre of how Java code is organised. A class is a blueprint describing a kind of thing, listing what data it holds and what actions it can perform, while an object is one real instance created from that blueprint, with its own actual values.

A class describes something

public class Car {
  String colour;
  int speed;
  void drive() {
    System.out.println("Driving");
  }
}

This class lists two properties, colour and speed, known as fields, and one action, drive, known as a method. On its own, a class defines only the shape of a car, not an actual one.

An object is a real one

Car myCar = new Car();
myCar.colour = "red";
myCar.drive();

The new keyword creates an actual object in memory following the Car blueprint, and myCar is a variable holding a reference to it. Setting myCar.colour only changes that particular object; any other Car object created separately keeps its own independent value.

Many objects from one class

Car car1 = new Car();
Car car2 = new Car();
car1.colour = "red";
car2.colour = "blue";

car1 and car2 are entirely separate objects; changing one never affects the other, even though both came from the same Car class.

Encapsulation: protecting fields with methods

Making fields private and only exposing them through getter and setter methods is a common practice called encapsulation. It lets a class control exactly how its data can be read or changed, which becomes valuable once a field needs validation:

public class Car {
  private int speed;
  public void setSpeed(int speed) {
    if (speed >= 0) this.speed = speed;
  }
  public int getSpeed() {
    return speed;
  }
}

Now speed can never be set to an invalid negative value, a rule that would be impossible to enforce if the field were simply public and freely editable from anywhere.

Modelling the real world

This pattern of classes and objects is how larger applications stay organised. A shopping application might have a Product class and an Order class, each describing its own data and behaviour, with individual Product and Order objects representing the actual items and purchases moving through the system at any given moment.

Why this matters

Almost every other Java concept, from constructors to inheritance to collections of objects, builds directly on this class-and-object foundation, which makes it worth being genuinely comfortable with before moving on to more advanced object-oriented ideas.

A constructor is special code that runs automatically the moment an object is created, and its main job is to set up that object with valid starting values before anything else can use it.

Why constructors exist

Without a constructor, an object starts out with default values, such as zero for numbers or null for objects, and has to be filled in manually afterward, one field at a time. A constructor lets an object arrive fully formed in a single step, the moment it is created.

Writing a constructor

public class Person {
  String name;
  int age;
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

A constructor shares its name with the class and has no return type, not even void. Using it is straightforward:

Person p = new Person("Ann", 30);

What this actually means

Inside the constructor, the parameter and the field are both called name, which would otherwise be ambiguous. Writing this.name specifically means the field belonging to the current object, distinguishing it from the parameter of the same name sitting right next to it. Without this, the line name = name would simply assign the parameter to itself and leave the field untouched.

Constructor overloading

A class can offer several constructors with different parameter lists, letting an object be created in more than one way:

public class Person {
  String name;
  int age;
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  public Person(String name) {
    this(name, 0);
  }
}

The second constructor calls the first using this(name, 0), avoiding repeated setup logic and giving age a sensible default of zero when only a name is supplied.

The default constructor

If a class defines no constructor at all, Java quietly supplies an empty one for free. The moment even one constructor is written by hand, however, that free default disappears, and any other way of creating the object needs its own explicit constructor.

A note on immutability

Constructors are also the foundation of immutable objects, ones whose fields are set once and never changed afterward. Marking fields final and only assigning them inside the constructor guarantees an object cannot be modified after creation, which makes it inherently safer to share across different parts of a program, including across multiple threads.

An array stores a fixed number of values of the same type under a single variable name, which is far more manageable than declaring a separate variable for every value when there are more than just a couple.

Creating an array

int[] scores = {90, 85, 70, 60};

This single array holds four related numbers together, with a size fixed at four the moment it is created.

Reading and changing values

Each item has a position, called an index, and counting always starts at zero:

int first = scores[0];  // 90
int third = scores[2];  // 70
scores[1] = 88;          // change the second value

A common mistake

An array with four items has valid indexes 0 through 3; asking for scores[4] does not exist and throws an ArrayIndexOutOfBoundsException at runtime. This off-by-one mistake, forgetting that the last index is length minus one, catches nearly every beginner at least once.

Looping through an array

for (int s : scores) {
  System.out.println(s);
}
System.out.println("Total items: " + scores.length);

The length field, without parentheses since it is a field and not a method, always reports how many items an array holds.

Arrays of objects

Arrays are not limited to primitives; they can just as easily hold objects, such as a list of Person objects created earlier:

Person[] people = new Person[3];
people[0] = new Person("Ann", 30);

Multidimensional arrays

An array of arrays models a grid or table, useful for things like a small game board or a spreadsheet-style layout:

int[][] grid = new int[3][3];
grid[1][2] = 5;

Useful helpers from the Arrays class

The built-in Arrays utility class provides ready-made operations that avoid writing loops for common tasks, such as sorting or printing an array in a readable form:

Arrays.sort(scores);
System.out.println(Arrays.toString(scores));

Arrays versus lists

Arrays are fast and memory-efficient but cannot grow or shrink once created. When the number of items may change over time, an ArrayList is usually a better fit, trading a small amount of overhead for the convenience of adding and removing items freely, a comparison covered in more depth in the tutorial on Java collections.

Arrays are useful but rigid, since their size is fixed the moment they are created. Java's collections framework solves this with flexible structures that grow and shrink as items are added or removed, and the two used most often are the list and the map.

The list

A list keeps its items in a specific order and grows automatically as needed. ArrayList is the most common implementation:

List<String> names = new ArrayList<>();
names.add("Ann");
names.add("Bob");
String first = names.get(0);
names.remove("Bob");

Looping through a list

for (String name : names) {
  System.out.println(name);
}

The set

A set is similar to a list but never allows duplicate values, which makes it the natural choice whenever uniqueness matters more than order, such as tracking which usernames have already been seen:

Set<String> seen = new HashSet<>();
seen.add("ann");
boolean isDuplicate = !seen.add("ann");  // true, already present

The map

A map stores pairs of a key and a value, and values are looked up by their key rather than by position, much like a dictionary:

Map<String, Integer> ages = new HashMap<>();
ages.put("Ann", 30);
int annAge = ages.get("Ann");
boolean hasBob = ages.containsKey("Bob");

Looping through a map

Iterating a map usually means visiting each key and value pair together, using entrySet:

for (Map.Entry<String, Integer> entry : ages.entrySet()) {
  System.out.println(entry.getKey() + " is " + entry.getValue());
}

Choosing an implementation

• ArrayList suits most list needs, offering fast access by position.
• LinkedList is rarely needed but can help when items are frequently inserted or removed from the middle of a very large list.
• HashMap offers fast lookups but does not guarantee any particular order.
• TreeMap keeps its keys sorted automatically, at a small performance cost compared to HashMap.

A note on autoboxing

Collections can only hold objects, not primitive values directly, which is why Map<String, Integer> uses the object type Integer rather than the primitive int. Java converts between the two automatically, a process called autoboxing, but it is worth knowing that a collection of Integer objects carries slightly more memory overhead than a plain array of int values.

When to use which

Reach for a list when order matters and duplicates are allowed, a set when only uniqueness matters, and a map whenever values need to be looked up by a meaningful key rather than a position, which together cover the overwhelming majority of everyday data-handling needs in Java.

Things go wrong even in correct programs: a file might be missing, a network call might time out, or a calculation might divide by zero. An exception is how Java signals that one of these problems occurred, and handling it properly is what keeps a single failure from crashing the entire program.

The try-catch block

try {
  int result = 10 / divisor;
} catch (ArithmeticException e) {
  System.out.println("Cannot divide by zero");
}

Risky code goes inside try. If it throws an exception, execution jumps immediately into the matching catch block instead of crashing the program, and everything after the failing line inside try is skipped.

The finally block

try {
  // open a file
} catch (Exception e) {
  // handle error
} finally {
  // close the file
}

Code inside finally always runs, whether or not an exception occurred, making it the natural place for cleanup work such as closing a file or a network connection that must happen no matter what.

Try-with-resources

For anything that implements Closeable, such as file streams, a try-with-resources block closes it automatically once the block finishes, removing the need for a manual finally block entirely:

try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
  String line = reader.readLine();
} catch (IOException e) {
  System.out.println("Could not read the file");
}

Checked versus unchecked exceptions

Checked exceptions, like IOException, must be declared or caught, and the compiler enforces this. Unchecked exceptions, which extend RuntimeException, such as ArithmeticException or NullPointerException, are not enforced by the compiler and usually point to a programming mistake rather than an unavoidable external failure.

Catching more than one type

try {
  // risky code
} catch (IOException | SQLException e) {
  System.out.println("A recoverable error occurred: " + e.getMessage());
}

Writing a custom exception

Applications often define their own exception types to represent specific problems clearly, rather than reusing a generic one:

public class InsufficientFundsException extends RuntimeException {
  public InsufficientFundsException(String message) {
    super(message);
  }
}

Catching the right thing

Catching a specific exception type allows a program to respond appropriately to each distinct problem. Catching a broad Exception hides the real cause and makes debugging much harder later, since it treats every possible failure, no matter how different, as the exact same case.

Do not ignore errors

An empty catch block silently swallows a real problem and makes bugs almost impossible to trace afterward. At an absolute minimum, an error should be logged so there is a record that it happened, even if the program can otherwise continue safely.

Inheritance lets one class reuse the fields and methods of another, avoiding the need to rewrite shared behaviour in every related class. A child class automatically receives everything a parent class defines and can add its own extra behaviour on top.

A parent class

public class Animal {
  void eat() {
    System.out.println("Eating");
  }
}

A child class

public class Dog extends Animal {
  void bark() {
    System.out.println("Woof");
  }
}

The extends keyword establishes the relationship. A Dog object automatically has access to eat, inherited from Animal, in addition to its own bark method, without eat ever being written inside Dog itself.

Overriding a method

@Override
void eat() {
  System.out.println("Dog eats enthusiastically");
}

A child class can replace, or override, a parent method with its own version. Marking it with @Override is not strictly required but is strongly recommended, since it lets the compiler catch a typo in the method signature that would otherwise silently create an unrelated new method instead of overriding the intended one.

The super keyword

Sometimes a child class wants to add to the parent behaviour rather than fully replace it. The super keyword calls the parent version of a method from inside the overriding one:

@Override
void eat() {
  super.eat();
  System.out.println("...and wags its tail");
}

Polymorphism

Because a Dog is also an Animal, a variable declared as the parent type can point to a child object, and calling an overridden method automatically runs the child version:

Animal a = new Dog();
a.eat();  // runs Dog's overridden version

This is polymorphism: the same line of code, a.eat(), behaves differently depending on the actual object behind the reference, which becomes powerful once a list holds several different subclasses handled through their shared parent type.

Abstract classes

An abstract class can define a method with no body at all, forcing every subclass to supply its own implementation:

public abstract class Shape {
  abstract double area();
}

An abstract class cannot be instantiated directly with new; it exists purely as a shared base for concrete subclasses to build on.

When to use inheritance

Inheritance fits best when classes share a genuine is-a relationship, such as a Dog truly being an Animal. When the relationship is closer to has-a, such as a Car having an Engine rather than being one, composition, where one class simply holds a reference to another, usually leads to more flexible and less tightly coupled code than forcing an inheritance relationship that does not really fit.