Getter for private member object in Java

Question

Say I have a class called Truck and one of the private member variables is of class Wheel. A getter for the Wheel variable, getWheel, would return a reference to it, as follows:

class Truck{
    private Wheel wheel;

    Truck(){
        wheel=new Wheel();

    }

    Wheel getWheel(){
        return this.wheel;
    }
}

class Wheel{
    int color;
}

Now, whoever calls getWheel will be able to modify the private member object at will:

class me{
    public static void main(String[] args){
        Truck ye=new Truck();
        Wheel v=ye.getWheel();

        v.color=2;
    }
}

This would defeat encapsulation, wouldn't it?

What would be the right remedy for this?

Answer 1

The usual approaches are:

• Make a defensive copy (e.g., return a copy of Wheel)
• Make Wheel immutable (any time you want to change it, you create a new one instead, constructed with the new color)
• Don't return Wheel, return an immutable interface on Wheel that only exposes getters, no mutation operations
• As Sandeep said, make the setter more restricted than the getter, say, package-private for the setter and public for the getter. Then classes within the package could set the color of Wheel, but classes outside the package cannot. (I prefer #3 in this situation for the clear separation, but this works too if you're crossing a visibility boundary.)

That third option is one of the reasons why making instance variables (fields) non-private is often considered poor practice.

Here's #3 in more depth, just because it's more complicated than #1 and #2, not because it's necessarily better (it isn't, design choices are made in context).

A read-only interface, typically public or package-private depending on how you're going to use all of this stuff:

public interface Wheel {
    int getColor();
}

The concrete class, typically package-private (could be a private static nested class within Truck if that's the only place it's used):

class WheelImplementation implements Wheel {
    private int color;

    WheelImplementation(int color) {
        this.color = color;
    }

    public int getColor() {
        return this.color;
    }

    void setColor(int color) {
        this.color = color;
    }
}

Truck, typically same visibility as Wheel:

public class Truck {
    private WheelImplementation wheel;

    Truck(){
        this.wheel = new WheelImplementation(/*...initial color...*/);
    }

    Wheel getWheel() {
        return this.wheel;
    }
}

Sure, that can be defeated through reflection, but generally you design an API for use, rather than for abuse. :-)