Class Creation

3.1 Anatomy of a Class

A class is a blueprint. It declares two things:

• Instance variables (a.k.a. fields, attributes) — the data each object holds
• Methods — the actions each object can perform

The skeleton

public class Dog {
    // instance variables — usually private
    private String name;
    private int age;

    // constructor — runs when you say `new Dog(...)`
    public Dog(String n, int a) {
        name = n;
        age = a;
    }

    // methods — usually public
    public String getName() { return name; }
}

public vs private

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog("Rex", 4);
        System.out.println(d.describe());
    }
}

class Dog {
    private String name;
    private int age;

    public Dog(String n, int a) {
        name = n;
        age = a;
    }

    public String describe() {
        return name + " is " + age + " years old";
    }
}

3.2 Constructors

A constructor is a special method that initializes a new object. Rules:

• Same name as the class (case-sensitive)
• No return type — not even void
• Called automatically when you write new ClassName(...)

The default constructor

If you write a class with no constructor at all, Java gives you a free one with no arguments. As soon as you write your own, you lose that freebie.

Overloading — multiple constructors

A class can have several constructors as long as their parameter lists differ.

class Point {
    private int x;
    private int y;

    public Point() {
        x = 0;
        y = 0;
    }

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public String show() {
        return "(" + x + ", " + y + ")";
    }
}

3.3 Accessor Methods (Getters)

If your fields are private, outside code can't read them directly. An accessor (a.k.a. getter) is a public method that returns a field's value.

The naming convention

• getName() for a field name
• getAge() for a field age
• isReady() for a boolean field ready

toString() — the universal accessor

If you override toString(), Java will automatically call it when you print the object or concatenate it with a String.

public String toString() {
    return name + " (" + age + ")";
}

// Now this works:
System.out.println(dog);   // calls dog.toString()

class Dog {
    private String name;
    private int age;

    public Dog(String n, int a) {
        name = n;
        age = a;
    }

    public String getName() { return name; }
    public int    getAge()  { return age; }

    public String toString() {
        return name + ", age " + age;
    }
}

3.4 Mutator Methods (Setters)

A mutator (a.k.a. setter) is a public void method that changes a private field. Setters can also validate the new value.

public void setAge(int a) {
    if (a >= 0) {        // validation
        age = a;
    }
}

Mutators can do work, not just assign

A mutator might compute, increment, or trigger side effects:

public void haveBirthday() {
    age++;
}

class BankAccount {
    private double balance;

    public BankAccount(double initial) {
        balance = initial;
    }

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) balance += amount;
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
}

3.5 Static Variables & Methods

Static members belong to the class, not to any individual object. There's exactly one copy, shared by everyone.

Classic use: a counter shared across all instances

public class Dog {
    private static int dogsCreated = 0;   // ONE copy for the whole class

    public Dog() {
        dogsCreated++;
    }

    public static int getDogsCreated() {
        return dogsCreated;
    }
}

class Robot {
    private String name;
    private static int count = 0;

    public Robot(String n) {
        name = n;
        count++;
    }

    public String getName() {
        return name;
    }

    public static int howMany() {
        return count;
    }
}

3.6 Scope & Access

Scope is the region of code where a variable is visible.

Inner scopes shadow outer ones

If a local variable has the same name as an instance variable, code inside that method sees the local one. The instance one is hidden (you'd need this.x to reach it).

20    // the parameter n shadows the field
10    // this.n reaches the instance variable
99    // the local x is visible here
// uncommenting the last line would fail: x is out of scope

3.7 The this Keyword

Inside an instance method, this refers to the specific object the method was called on. It lets you:

• Disambiguate a field from a parameter with the same name
• Pass the current object to another method
• Call one constructor from another: this(args)

Use 1 — distinguishing field from parameter

public Dog(String name, int age) {
    this.name = name;   // the field   ← the parameter
    this.age  = age;
}

Use 2 — passing yourself along

public void register() {
    Kennel.add(this);   // pass this Dog object to the Kennel
}

Use 3 — chaining constructors

public Point() {
    this(0, 0);         // call Point(int, int) with (0, 0)
}
public Point(int x, int y) {
    this.x = x;
    this.y = y;
}

class Rectangle {
    private int width;
    private int height;

    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public int area() {
        return width * height;
    }

    public boolean isLargerThan(Rectangle other) {
        return this.area() > other.area();
    }
}

🎯 Unit 3 Review Quiz