Encapsulation: private fields, getters, setters

Protect your data

• Encapsulation means hiding an object's data and only changing it through methods.
• private blocks direct access from unrelated outside code. It does not validate values: constructors and mutating methods must enforce the object’s rules themselves.
• The main tools are the words private and public.

private fields

• Mark instance variables private so code in unrelated classes cannot touch them directly.
• Methods inside the same class can still use them.
• This is the normal style for AP CSA: fields are private. The first example deliberately accepts a negative start; main is in the same class, so it can read that private field. It prints -50.0, exposing the missing validation.

public class BankAccount {
    private double balance;   // hidden from outside code

    public BankAccount(double start) {
        this.balance = start;
    }
    public static void main(String[] args) {
        BankAccount account = new BankAccount(-50);
        System.out.println(account.balance); // -50.0: private alone does not validate
    }
}

Accessors (getters)

• A field is private, so we add a public method to read it.
• A method that returns a field is called an accessor or getter.
• It usually starts with get, like getBalance().

public class BankAccount {
    private double balance;

    public BankAccount(double start) {
        this.balance = start;
    }

    public double getBalance() {
        return this.balance;
    }
    public static void main(String[] args) {
        BankAccount account = new BankAccount(100);
        System.out.println(account.getBalance()); // 100.0
    }
}

Mutators (setters)

• A method that changes object state is a mutator. A setter is one kind, usually setting a field to a supplied value; deposit is a mutator that adds to the balance.
• It can check the new value first and refuse a bad one.
• Below, the constructor rejects a negative start and deposit ignores nonpositive amounts. These examples assume finite double values; the checks shown enforce the stated rules, not every possible banking requirement.

public class BankAccount {
    private double balance;

    public BankAccount(double start) {
        if (start < 0) {
            throw new IllegalArgumentException("Start must be nonnegative");
        }
        this.balance = start;
    }

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

    public double getBalance() {
        return this.balance;
    }
    public static void main(String[] args) {
        BankAccount account = new BankAccount(100);
        account.deposit(-500);
        System.out.println(account.getBalance()); // 100.0
        account.deposit(50);
        System.out.println(account.getBalance()); // 150.0
        try {
            new BankAccount(-50);
        } catch (IllegalArgumentException error) {
            System.out.println("Negative start rejected");
        }
    }
}

static vs instance

• An instance field belongs to one object. Each object has its own.
• A static field belongs to the class itself — it is shared by all objects.
• Below, count rises by 1 every time a Robot is constructed. It counts constructions, not the number of objects still alive; discarding a reference does not decrease it.

public class Robot {
    private static int count = 0;   // shared by all robots

    public Robot() {
        count = count + 1;
    }

    public static int getCount() {
        return count;
    }
    public static void main(String[] args) {
        Robot first = new Robot();
        Robot second = new Robot();
        System.out.println(Robot.getCount()); // 2 constructions
    }
}

toString()

• toString() returns text that describes the object.
• Java calls it automatically when you print the object or join it with text using +. The inherited Object.toString() uses the class name, @ and a hexadecimal hash code; that text is not a guaranteed memory address.
• It takes no parameters and returns a String.

public class Point {
    private int x;
    private int y;

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

    public String toString() {
        return "(" + this.x + ", " + this.y + ")";
    }
    public static void main(String[] args) {
        Point point = new Point(3, 4);
        System.out.println(point); // (3, 4)
        System.out.println("Point: " + point); // Point: (3, 4)
    }
}

Common mistakes

• Make fields private and reach them through getters and setters.
• A setter can check a value before storing it.

Now you try

• Fill in each class according to its stated constructor and method contract; private alone does not enforce it.
• A hidden Harness builds the object, calls the methods, and checks the results.
• These class tasks have no standalone main and no Run button. Check answer compiles your class with the supplied harness, runs its calls and gives feedback. The complete examples above have their own Run buttons.