Classes, Objects & Encapsulation

Anatomy of a Class

public class Student {
    // === Fields ===
    private String name;
    private int    age;
    private static int totalStudents = 0;     // shared by all instances
    // === Constructors ===
    public Student(String name, int age) {
        this.name = name;
        this.age  = age;
        totalStudents++;
    }
    public Student(String name) {
        this(name, 18);          // delegate to the other constructor
    }
    // === Instance methods ===
    public String greet() {
        return "Hi, I'm " + name + " (" + age + ")";
    }
    // === Static method ===
    public static int howMany() { return totalStudents; }
    // === Getters / setters ===
    public String getName() { return name; }
    public int    getAge()  { return age; }
    public void   setAge(int age) {
        if (age < 0) throw new IllegalArgumentException();
        this.age = age;
    }
    // === toString — for debugging / logging ===
    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + "}";
    }
}

new & the Object Lifecycle

Student s = new Student("Asha", 19);

1. Allocate memory on the heap. 2. Set fields to their defaults (0, null, false). 3. Run the constructor (with any explicit field initialisers first). 4. Return the reference.

When no references point to the object, the garbage collector reclaims its memory.

this

this is the implicit reference to the current instance. Used:

• To disambiguate field vs parameter: this.x = x.
• To call another constructor: this(args) — must be the first statement.
• To return self for fluent chaining: return this.

Constructors

• Same name as the class, no return type.
• A class with no explicit constructor gets a free default no-arg constructor.
• Once you write any constructor, the default disappears — define a no-arg explicitly if you still want one.
• Multiple constructors via overloading; chain with this(...).

public Box() { this(0, 0, 0); }
public Box(int s) { this(s, s, s); }
public Box(int w, int h, int d) { /* full ctor */ }

Access Modifiers

Default rule: fields private, methods public unless you have a reason.

Static — Class-Level

public class MathUtil {
    public static final double PI = 3.14159;
    public static double square(double x) { return x * x; }
}
MathUtil.square(5);          // no instance needed

• static fields are shared across all instances (and live forever).
• static methods can't access this or non-static fields.
• Use for utilities, constants and factory methods.

Encapsulation in Practice

Without encapsulation:

public class Counter {
    public int count;
}
c.count = -50;     // breaks invariant: counts shouldn't be negative

With encapsulation:

public class Counter {
    private int count;
    public void inc() { count++; }
    public int  get() { return count; }
}

The class now controls how its state changes — it can validate, log, fire events.

> Convention: getters return the value, setters validate and assign. Records remove this boilerplate when state should be immutable.

toString, equals, hashCode

Override toString() for readable logging:

@Override
public String toString() {
    return "Point(" + x + ", " + y + ")";
}

For value equality, override BOTH equals and hashCode — they go together. IntelliJ / VS Code generate them for you (Alt+Insert / right-click → Generate). Or use a record.

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Point p)) return false;       // pattern match (Java 16+)
    return Double.compare(p.x, x) == 0 && Double.compare(p.y, y) == 0;
}
@Override
public int hashCode() {
    return Objects.hash(x, y);
}

Records — Skip the Boilerplate (Java 14+)

public record Point(double x, double y) {}
public record User(String name, int age, List<String> tags) {}

A record is:

• Implicitly final.
• All fields are private final.
• Auto-generates: canonical constructor, accessors (x() not getX()), equals, hashCode, toString.
• Can have additional methods, static factories and a compact constructor for validation:

public record Email(String value) {
    public Email {
        if (value == null || !value.contains("@"))
            throw new IllegalArgumentException();
        value = value.trim().toLowerCase();   // normalise
    }
}

> Use records for immutable data carriers (DTOs, return values, keys). Use full classes when you need mutable state, framework hooks, or inheritance.

Inner & Nested Classes (preview)

public class Outer {
    private int value = 10;
    class Inner { int read() { return value; } }              // inner — needs Outer instance
    static class Nested { int compute() { return 42; } }       // static — independent
}

Plus records, enums, anonymous classes, and (Java 16+) local records inside methods. Deeper coverage is the OOP topic.

Common Mistakes

You can now design your own types. Phase 2 done. Phase 3 next: inheritance and the OOP toolkit.