Private Instance Variables

A class often keeps its data in private variables so that code outside the class cannot change them directly. That protection only helps if the class still offers a legitimate way to change the data. A setter method is that way. It is an ordinary method whose job is to store a new value into a private variable on behalf of some other class. Because every change passes through one method, the class has a single place where it can decide whether a change should be allowed.

This article follows a code-first path. You will look at a small setter, predict what it does with an unusual input, and then work out the mechanism that produces the result. Pay attention to the moment the value moves from the parameter into the private variable, because that moment is where both the normal behaviour and the validation logic live.

Making a field private means outside code cannot assign to it directly. The field still exists, and the class itself can use it, but any other class that wants a new value must ask the class to store it. The setter is that request channel. Every path that changes the field runs through the setter body, and that is why the body is the correct place to put a check. A check placed anywhere else would leave a second route by which a bad value could reach the field, which would defeat the purpose of making the variable private.

A setter has two conventions that tell other programmers what it does. The first is its name. The name begins with the word set, followed by a copy of the variable's name with its first letter capitalized. A variable called title therefore gets a setter called setTitle. The second convention is the parameter. A setter takes one parameter whose type matches the type of the variable it sets. For a String field, the parameter is a String. Following these two rules makes the setter easy to find and easy to use correctly.

When calling code writes a new value through a setter, control leaves the caller and enters the setter. The value passed in is bound to the parameter. The setter then performs its body, and the body is what reaches the private variable. Control returns to the caller once the body finishes. The diagram shows the three participants involved and the order of their messages. The caller never touches the field itself.

Validation means checking a new value before it is assigned to the private variable. The check decides whether the value is legal. When the value is not legal, the setter does not store it as given. Instead, it stores a default value that the class considers acceptable. Validation keeps null and other invalid values out of private variables, so the rest of the class can rely on the field holding something usable.

The validated version has two branches, but only one runs for any given call. A null argument takes the first branch and stores the default. Any other argument takes the second branch and stores the value unchanged. The method always ends with the field holding a value, which is the property the unchecked version lacked.

When a setter seems to store the wrong value, the fastest way to find the fault is to ask which line produced the stored value. Start from the variable and work backwards. Ask whether the setter was called at all, which value reached the parameter, which branch the check took, and what the assignment stored. A mismatch at any of these points shows where to look.