Why are method parameters rarely marked `final` in Java?

Why not use final on Method Parameters?

The final keyword on method parameters has limited utility.

No Effect on Primitive Parameters

When a primitive type is used as a method parameter, marking it final has no effect. Primitive parameters are passed by value, meaning that any changes made to the value within the method are not reflected outside the method.

Limited Effect on Non-Primitive Parameters

For non-primitive parameters (objects), marking them final prevents the method from re-assigning a new reference to the parameter. However, the object itself can still be altered.

Counter-Example

The following example illustrates these limitations:

public void changeParameter(Collection<Integer> c) {
    c = new ArrayList<>(); // Can't assign a new reference
    c.add(5); // Mutating the object is still possible
}

Even though c is marked final, the method changes the collection referenced by c.

Why Use final on Method Parameters?

Despite these limitations, there is one key benefit to marking parameters final: it prevents the method from accidentally re-assigning the parameter to a different object. This can help prevent errors where the method relies on the object referenced by the parameter.

Recommendation

In general, it is recommended to mark method parameters final unless there is a specific reason not to. It improves readability and prevents accidental errors. However, it is important to be aware of the limitations of final when used with non-primitive parameters.

The Immutable Case

In one important case, it is essential to mark parameters final: when the method guarantees that the object referenced by the parameter will not be modified. This assurance can be achieved when the object is immutable, meaning its state cannot be changed. For example:

public void processImmutableObject(final ImmutableClass obj) {
    // obj's state will not change
}

In this scenario, marking obj final prevents the method from accidentally modifying the object.

The above is the detailed content of Why are method parameters rarely marked `final` in Java?. For more information, please follow other related articles on the PHP Chinese website!