What is an Accessor Method in OOP?
Learn what an accessor method (getter) is in OOP — side-effect-free reads, defensive copying — with a Java example and Q&A.
Expected Interview Answer
An accessor method, commonly called a getter, is a public method that returns the value of a private field without modifying the object’s internal state, providing controlled read-only access.
Instead of exposing a field directly as public, a class provides a method such as “getBalance()” that returns the current value, optionally computing it, formatting it, or returning a defensive copy for mutable types like collections or dates. This keeps the internal representation hidden and controllable: the class can change how the value is stored or derived internally without breaking any code that calls the getter. Accessors should be side-effect free — calling one repeatedly should never change the object. They pair with mutator methods (setters), which are the write counterpart, and together they form the standard controlled interface encapsulation relies on.
- Provides read access without exposing internal representation
- Allows returning derived or defensively copied values safely
- Lets internal storage change without breaking callers
- Keeps reading side-effect free, unlike a mutator
AI Mentor Explanation
A live scoreboard display lets anyone read the current score at any time, but looking at it never changes the score itself — only the official scorer’s recording process does that. Fans query the board as often as they like with zero side effects on the match. That read-only display mirrors an accessor method: a controlled way to retrieve current state without ever modifying it.
Step-by-Step Explanation
Step 1
Keep the field private
Declare the underlying instance variable private so it isn’t directly readable from outside.
Step 2
Expose a public getter
Provide a public method such as getBalance() that returns the current value.
Step 3
Return safely
For mutable fields (dates, collections), return a defensive copy so callers cannot mutate internal state indirectly.
Step 4
Guarantee no side effects
Calling the getter must never change the object’s state, however many times it’s called.
What Interviewer Expects
- A clear definition distinguishing accessors (getters) from mutators (setters)
- Awareness that accessors must be side-effect free
- Mention of defensive copying for mutable field types
- Understanding that getters hide the internal representation from callers
Common Mistakes
- Writing a getter that also has a mutating side effect (e.g. resets a counter on read)
- Returning a mutable internal reference directly, letting callers mutate private state indirectly
- Confusing accessor with mutator methods
- Auto-generating getters for every field without considering whether exposure is appropriate
Best Answer (HR Friendly)
“An accessor method, usually called a getter, lets outside code read the value of a private field in a controlled way without exposing the field itself. It never changes the object’s state — it just reports the current value — and it lets the class hide or change how that value is actually stored internally.”
Code Example
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class Order {
private final Date placedAt;
private final List<String> items = new ArrayList<>();
public Order(Date placedAt) {
this.placedAt = new Date(placedAt.getTime()); // defensive copy in
}
// Accessor: read-only, returns a defensive copy of the mutable Date
public Date getPlacedAt() {
return new Date(placedAt.getTime());
}
// Accessor: returns an unmodifiable view, never exposes the live list
public List<String> getItems() {
return List.copyOf(items);
}
}Follow-up Questions
- What is the difference between an accessor and a mutator method?
- Why should a getter return a defensive copy of a mutable field?
- Can an accessor method have side effects? Why is that discouraged?
- How do accessors support hiding the internal representation of a class?
MCQ Practice
1. An accessor method is primarily used to?
An accessor (getter) exposes a value for reading and must not modify the object’s state.
2. Why might a getter return a defensive copy of a field?
Returning a copy of a mutable internal reference (like a Date or List) prevents outside code from altering internal state through the reference.
3. Which is a red flag in a getter’s implementation?
Accessors must be side-effect free; mutating state inside a getter violates the read-only contract callers expect.
Flash Cards
Accessor method in one line? — A method that reads an object’s internal state without modifying it.
Other common name? — Getter.
Opposite kind of method? — Mutator (setter), which changes state.
Why defensively copy in a getter? — To prevent callers from mutating internal mutable state through the returned reference.