Methods: How to Write Them
Introduced| English |
|---|
| accessor/əkˈsesə/ |
| mutator/mjuːˈteɪtə/ |
A rejected update leaves the previous state intact
- A score starts at 20. setScore(s) assigns only when s >= 0; the call setScore(-5) leaves score at 20.
- The guard prevents an invalid update. A later getScore() returns the existing state rather than the rejected argument.
Writing a method
- A method has a header and a body. Header:
public void addScore(int s)— access, return type, name, parameters. - Body: the statements in
{ }that do the work. The method can read and change the object's instance variables.
Return values
- A method's return type says what it hands back; use
return value;to send it.public int getScore() { return score; }returns the current score. - A
voidmethod returns nothing — it just does its job (e.g. printing). The returned value must be assignment-compatible with the declared return type; for example, anintvalue can be widened and returned by adoublemethod.
The method public double result() { return 3; } can compile even though 3 is an int literal.
Java widens the int result to double; return values must be compatible, not necessarily written with an identical type.
Accessors and mutators
- An accessor (getter) 访问方法 returns information without changing the object:
getScore(). A mutator (setter) 修改方法 changes the object's state:addScore(s)orsetName(n). - Getters are usually
int/String-returning; setters are usuallyvoid. Together they form the object's public interface over its private data.
An accessor returns a value
Starting at score 20, setScore(-5) rejects the update; getScore returns 20.
A method that returns information without changing the object is a(n)...
Accessors read and return; mutators change state.
A void method...
void = no return value; it just performs an action.
A non-void method may reach its closing brace and complete normally without returning a value.
A path completing normally must return a compatible value. A path that throws an exception is a different case.
Which method can validate its input before changing state?
A setter can check (e.g. reject negatives) before assigning.
Writing return value; inside a void method compiles fine.
A void method can't return a value — that won't compile.
Methods can validate
- Because outside code goes through methods, a method can check before it acts.
public void setScore(int s) { if (s >= 0) score = s; }rejects a negative score. - Private access prevents unrelated code from directly assigning the field. Constructors and every class method that writes it must still preserve the intended rule; the guarded setter cannot repair an invalid initial score by itself.
A non-void method must return a compatible value on every path that completes normally. A path may instead throw an exception. If an int method reaches its end without returning, compilation fails. A void method returns nothing, so return; (or no return) is correct there; writing return value; in a void method won't compile.
For the stated guarded setter, what does getScore() return after setScore(-5)?
The condition fails, so no assignment occurs and the old score remains 20.
Starting at score 20, replaceScore(30) saves the old score, assigns 30, then returns the old score. What value does the call return?
The returned old score is 20; the new stored score is 30. Returning a value does not prevent mutation.
An accessor and a mutator:
- Accessor:
public int getScore() { return score; }— reads, returnsint. - Mutator:
public void addScore(int s) { score += s; }— changes state, returns nothing. student.addScore(10); int now = student.getScore();
Carry the reasoning to a new case
- Consider
public int replaceScore(int s) { int old = score; score = s; return old; }. It is a mutator even though it returns a value: starting at 20, replaceScore(30) returns 20 and leaves the score at 30. - Judge behavior rather than names or return types. A method called getScore that increments the score is not a pure accessor, and a void method that merely prints a message need not mutate the object.
A method has a header (access, return type, name, parameters) and a body. A non-void method must return an assignment-compatible value on every normally completing path; a void method returns nothing. Accessors (getters) return state without changing it; mutators (setters) change state and can validate the new value.