Passing and Returning References · Passer et Retourner des Références
| English | Français |
|---|---|
| NullPointerException/nʌl ˈpɔɪntə ekˈsepʃn/ | NullPointerException |
Mutating an object differs from reassigning a parameter
- A caller refers to a Student with score 10. The method executes s.addScore(5); then s = new Student("Other");
- The score of the original shared object becomes 15. Reassigning the local parameter does not change the caller variable, because Java copies the reference value into the parameter.
Passing an object to a method
- Java copies the reference value into the method parameter; it does not copy the object. The method's parameter points at the same object as the caller's variable.
- So changes the method makes to the object are visible to the caller. Both primitive and reference arguments are passed by value; the copied reference can still reach a shared object.
Primitives vs. objects as arguments
- A primitive argument is copied — the method can't change the caller's variable. For an object argument, the copied reference reaches the same object — the method can mutate that object.
changeInt(x)can't alterx;student.addScore(10)does · fait change that student. Ask whether the method mutates the shared object or reassigns only its local parameter.
Returning an object
- A method can return a reference to an object — the caller then shares it.
public Student topStudent() { return best; }hands back a reference tobest. - Returning
bestshares an existing object. In contrast,return new Student("Copy");constructs a new object and returns its reference; a method can also returnnull. Read the return expression before deciding whether state is shared.
Copied reference, shared object; copied primitive · Objet partagé, primitif copié
The object's score changes; the primitive x does not.
When you pass an object to a method, the method receives...
Java copies the reference value into a separate parameter variable. The two references can reach the same object; parameter reassignment does not replace the caller variable.
A method can change the caller's int variable by modifying its parameter.
Primitives are copied — the caller's int is untouched.
Calling an instance method through a null reference throws...
null points at no object, so there's nothing to call the method on.
A method can return a reference to an object, which the caller then shares.
A method can return an existing object reference and share its object with the caller. A different method can construct and return a fresh object instead.
To safely use a reference that might be null, you should first check...
Guard against null before calling a method on it.
Every method that returns a Student reference must return a previously existing object.
False: return new Student("Other"); constructs and returns a fresh object.
The null reference
- A reference that points at no object is
null. Calling an instance method throughnullthrows a NullPointerException 空指针异常. - Returning
null(e.g. "not found") is common — the caller must check for it. Guard withif (s != null) { s.addScore(10); }before using a possibly-null reference.
Passing an object copies a reference value — the method can change the caller's object; passing a primitive copies the value — it can't. So student.addScore(10) mutates the caller's object, but changeInt(x) leaves the caller's x untouched. And calling an instance method through a null reference throws a NullPointerException — check != null first when a reference might be null.
After the two statements, what is the original caller-referenced Student score?
The first statement mutates the original object to 15. The later local reassignment does not replace the caller reference.
A method returns new Student("Other"); but the caller ignores the result. What happens to the caller's existing Student variable?
Returning a reference does not assign it into the caller variable. The existing variable still points to its original object.
Reference vs. value:
void addTen(Student s) { s.addScore(10); }— changes the passed object (shared reference).void addTen(int x) { x += 10; }— the caller'sintis unchanged (copied value).- Both parameter values are copied; only the copied reference reaches shared mutable state.
Carry the reasoning to a new case
- Compare · Comparer
return s;withreturn new Student("Other");: the first returns the supplied reference; the second returns a newly constructed object. Neither return changes the caller's variable until the caller assigns the result. - To predict a change, draw the caller and parameter as separate reference variables pointing to objects. Update the object for a mutator call, and update only the parameter arrow for parameter reassignment.
Passing an object reference copies its value into the parameter, so the method can change the caller's object; passing a primitive copies the value, so it can't. A method can return a reference to an object. A reference to no object is null — calling an instance method through it throws a NullPointerException, so check first.