Mutator Accessor Methods

Introduction

Accessor and Mutator methods are used to read and modify private fields of a class. They provide controlled access to class data.

Accessor Methods (Getters)

Accessor methods (getters) are used to read (access) the value of private fields.

Naming Convention:

• Prefix: get
• Format: getFieldName()
• Returns: Field value

Example:

class Student {
    private String name;
    private int age;

    // Accessor methods (Getters)
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        // s.name = "John";  // ❌ Error: name is private

        String studentName = s.getName();  // ✓ Use getter
        System.out.println(studentName);
    }
}

Mutator Methods (Setters)

Mutator methods (setters) are used to modify (change) the value of private fields.

Naming Convention:

• Prefix: set
• Format: setFieldName(value)
• Returns: Usually void

Example:

class Student {
    private String name;
    private int age;

    // Mutator methods (Setters)
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student();

        // Set values using setters
        s.setName("John");
        s.setAge(20);
    }
}

Complete Example

class BankAccount {
    private String accountNumber;
    private double balance;

    // Getters (Accessors)
    public String getAccountNumber() {
        return accountNumber;
    }

    public double getBalance() {
        return balance;
    }

    // Setters (Mutators)
    public void setAccountNumber(String accountNumber) {
        this.accountNumber = accountNumber;
    }

    public void setBalance(double balance) {
        if (balance >= 0) {  // Validation
            this.balance = balance;
        } else {
            System.out.println("Invalid balance");
        }
    }

    // Other methods
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited: " + amount);
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: " + amount);
        } else {
            System.out.println("Insufficient balance");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();

        // Use setters
        account.setAccountNumber("1234567890");
        account.setBalance(1000.0);

        // Use getters
        System.out.println("Account: " + account.getAccountNumber());
        System.out.println("Balance: " + account.getBalance());

        // Other operations
        account.deposit(500);
        account.withdraw(200);

        System.out.println("Final Balance: " + account.getBalance());
    }
}

Why Use Getters and Setters?

1. Encapsulation:

Hide internal implementation and provide controlled access.

2. Validation:

Validate data before setting values.

class Person {
    private int age;

    public void setAge(int age) {
        if (age > 0 && age < 150) {  // Validation
            this.age = age;
        } else {
            System.out.println("Invalid age");
        }
    }

    public int getAge() {
        return age;
    }
}

3. Read-Only or Write-Only Fields:

class Employee {
    private String id;
    private double salary;

    // Read-only: Only getter
    public String getId() {
        return id;
    }

    // Write-only: Only setter
    public void setSalary(double salary) {
        this.salary = salary;
    }
}

4. Future Modifications:

Can change implementation without affecting code that uses the class.

class Circle {
    private double radius;

    public void setRadius(double radius) {
        this.radius = radius;
    }

    // Can add logic later
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

Boolean Getters

For boolean fields, use is prefix instead of get.

class Student {
    private boolean present;
    private boolean passed;

    // Boolean getters use 'is' prefix
    public boolean isPresent() {
        return present;
    }

    public boolean isPassed() {
        return passed;
    }

    // Setters remain same
    public void setPresent(boolean present) {
        this.present = present;
    }

    public void setPassed(boolean passed) {
        this.passed = passed;
    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        s.setPresent(true);

        if (s.isPresent()) {  // Use 'is' prefix
            System.out.println("Student is present");
        }
    }
}

Common Pattern

class Product {
    private String name;
    private double price;
    private int quantity;

    // Getters
    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }

    public int getQuantity() {
        return quantity;
    }

    // Setters
    public void setName(String name) {
        this.name = name;
    }

    public void setPrice(double price) {
        if (price > 0) {
            this.price = price;
        }
    }

    public void setQuantity(int quantity) {
        if (quantity >= 0) {
            this.quantity = quantity;
        }
    }

    // Calculated getter
    public double getTotalValue() {
        return price * quantity;
    }
}

Advantages

1. Data Hiding: Fields remain private
2. Validation: Control what values are set
3. Flexibility: Change implementation easily
4. Read-only/Write-only: Selective access
5. Calculated Values: Getters can compute values

Getter vs Setter

Quick Reference

class Example {
    private int value;

    // Getter
    public int getValue() {
        return value;
    }

    // Setter
    public void setValue(int value) {
        this.value = value;
    }
}

// Usage
Example obj = new Example();
obj.setValue(100);           // Set
int x = obj.getValue();      // Get

Exam Tips

Remember:

1. Getter: Read value, prefix get
2. Setter: Modify value, prefix set
3. Fields should be private
4. Methods should be public
5. Boolean getters use is prefix
6. Setters allow validation
7. Getters return value
8. Setters usually void
9. Use this keyword in setters
10. Provides encapsulation

Common Questions:

• What are getter and setter methods?
• Why use getters and setters?
• Difference between getter and setter?
• What is naming convention?
• What is encapsulation?
• How to validate data in setters?