> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Java Final Parameter A `final` parameter in Java is a method, constructor, or lambda argument declared with the `final` modifier, which enforces strict read-only semantics for that specific variable within the lexical scope of the method body. Once the parameter is initialized via the method invocation, the Java compiler prevents any subsequent reassignment of that parameter to a new value or memory address. ## Syntax The `final` keyword is placed immediately before the data type in the parameter list. ```java theme={"dark"} public void process(final int count, final User user) { // Method implementation } ``` ## Mechanics and Behavior The behavior of a `final` parameter depends strictly on whether the parameter is a primitive data type or a reference type. ### 1. Primitive Types When a primitive parameter (e.g., `int`, `double`, `boolean`) is marked `final`, its literal value is locked. Any attempt to modify the value using assignment operators (`=`, `+=`, `++`, etc.) results in a compile-time error. ```java theme={"dark"} public void calculate(final int multiplier) { multiplier = 5; // Compilation Error: cannot assign a value to final variable multiplier multiplier++; // Compilation Error } ``` ### 2. Reference Types When an object reference is marked `final`, the memory address it points to is locked. You cannot reassign the parameter to point to a newly instantiated object or another existing object. However, the `final` modifier does **not** make the object itself deeply immutable. The internal state (fields and properties) of the referenced object can still be mutated if the object's class exposes mutating methods. ```java theme={"dark"} public void updateRecord(final StringBuilder buffer) { // ILLEGAL: Cannot change the reference buffer = new StringBuilder("New String"); // Compilation Error buffer = null; // Compilation Error // LEGAL: Can mutate the internal state of the referenced object buffer.append(" appended text"); // Compiles and executes successfully } ``` ## Lambda and Catch Block Parameters The `final` modifier can also be applied to parameters within lambda expressions and `catch` blocks, following the exact same reassignment rules. **Lambda Expression:** ```java theme={"dark"} BiFunction add = (final Integer a, final Integer b) -> { // a = 10; // Compilation Error return a + b; }; ``` **Catch Block:** ```java theme={"dark"} try { // Risky operation } catch (final IOException e) { // e = new IOException(); // Compilation Error e.printStackTrace(); } ``` ## Method Overriding and Overloading The `final` modifier on a parameter is an implementation detail of the method body, not a part of the method signature. Therefore: * Adding or removing `final` from a parameter does not constitute method overloading. * When overriding a method from a superclass or implementing an interface, you can freely add or remove the `final` modifier on the parameters in the subclass implementation without causing a signature mismatch.

Tired of Poor Java Skills? Fix That With Deep Grasping! Learn More