Final Keyword in Java

The final keyword in Java is a non-access modifier that can be applied to variables, methods, and classes to indicate that they cannot be modified or overridden. It plays a crucial role in enforcing immutability and defining constant values in your code.

Key Points on the Final Keyword:

• Final Variables: A variable declared with the final keyword cannot be reassigned once it has been initialized. This makes it a constant.
• Final Methods: A method marked as final cannot be overridden by subclasses, ensuring the original implementation remains intact.
• Final Classes: A class declared as final cannot be subclassed, preventing inheritance. This is useful for creating immutable classes.
• Static Final Variables: Static final variables are constants shared across all instances of a class, commonly used for defining constants.
• Final Parameters: Parameters in methods can also be declared final, indicating they cannot be modified within the method.
• Best Practices: Use final when you want to ensure that certain values or methods remain unchanged, promoting better code readability and reliability.
• Immutability: Using final can contribute to immutability in classes, which is a key concept in functional programming and helps prevent side effects.
• Final in Interfaces: In Java 8 and later, all fields in interfaces are implicitly final and static.
• Constructor Limitation: Final variables must be initialized when they are declared or within the constructor of the class.

Syntax of Final Keyword:

final int constantValue = 10; // Final variable
        final void myMethod() { // Final method
            // Implementation
        }
        final class MyFinalClass { // Final class
            // Class contents
        }

Example of Final Variable in Java:

This example demonstrates the use of a final variable.

public class FinalVariableExample {
            public static void main(String[] args) {
                final int x = 5;
                System.out.println("Value of x: " + x);
                // x = 10; // This will cause a compilation error
            }
        }

Example of Final Method in Java:

This example demonstrates a final method that cannot be overridden.

class Parent {
            final void display() {
                System.out.println("This is a final method.");
            }
        }
        
        class Child extends Parent {
            // void display() { // This will cause a compilation error
            //     System.out.println("Attempting to override.");
            // }
        }
        
        public class FinalMethodExample {
            public static void main(String[] args) {
                Child child = new Child();
                child.display(); // Calls the final method from Parent
            }
        }

Example of Final Class in Java:

This example shows how a final class cannot be subclassed.

final class FinalClass {
            void show() {
                System.out.println("This is a final class.");
            }
        }
        
        // class SubClass extends FinalClass { // This will cause a compilation error
        // }
        
        public class FinalClassExample {
            public static void main(String[] args) {
                FinalClass obj = new FinalClass();
                obj.show();
            }
        }

Detailed Explanation:

• Final Variables: The example shows how a final variable cannot be reassigned after its initial assignment. Attempting to do so results in a compilation error.
• Final Methods: A method declared as final cannot be overridden in derived classes. This is illustrated by the display method in the Parent class.
• Final Classes: The FinalClass cannot be subclassed, as shown in the commented-out code, which would cause a compilation error if uncommented.
• Immutability and Constants: Using final is essential for defining constants in applications, ensuring that important values remain unchanged throughout the program execution.
• Performance Considerations: While the final keyword doesn’t directly affect performance, it can lead to optimizations in certain contexts, as the compiler knows that final variables and methods cannot change.

Understanding the final keyword is crucial for writing robust and maintainable Java code, particularly when working with constants and ensuring certain methods or classes remain unchanged.