Understanding the Differences Between final, finalize, and finally Keywords in Java

Introduction:

In Java, there are three keywords that are often confused due to their similar spellings: final, finalize, and finally. While they may sound alike, these keywords have distinct meanings and serve different purposes in the Java language. In this article, we will delve into each keyword, explain their differences, and provide code examples to illustrate their usage. Understanding these distinctions will help you write more efficient and error-free Java code.

final Keyword:

The final keyword is used to declare a variable, method, or class that cannot be modified or overridden. When applied to a variable, it indicates that its value cannot be changed once assigned. When applied to a method, it signifies that the method implementation cannot be overridden by subclasses. Finally, when applied to a class, it indicates that the class cannot be subclassed.

public class Circle {
    private final double PI = 3.14159;
    private final int radius;
  
    public Circle(int radius) {
        this.radius = radius;
    }
  
    public final double calculateArea() {
        return PI * radius * radius;
    }
}

finalize Method:

The finalize method is a special method provided by the Object class in Java. It is called by the garbage collector when an object is no longer reachable, just before it is deallocated from memory. The purpose of the finalize method is to perform cleanup actions or resource releasing operations before an object is destroyed.

public class Resource {
    // Constructor, methods, and fields
    
    @Override
    protected void finalize() throws Throwable {
        try {
            // Cleanup actions or resource releasing operations
        } finally {
            super.finalize();
        }
    }
}

Note: It is important to note that the usage of the finalize method is generally discouraged in modern Java development due to its unpredictability and potential performance impact. It is recommended to use alternative mechanisms, such as try-with-resources or explicit resource management, for proper resource cleanup.

finally Block:

The finally block is used in conjunction with the try-catch block to ensure that a certain piece of code is always executed, regardless of whether an exception occurs or not. The statements within the finally block will be executed even if an exception is thrown or if a return statement is encountered within the corresponding try or catch blocks.

public void processFile() {
    FileReader fileReader = null;
    try {
        fileReader = new FileReader("filename.txt");
        // Code for file processing
    } catch (IOException e) {
        // Exception handling
    } finally {
        if (fileReader != null) {
            try {
                fileReader.close();
            } catch (IOException e) {
                // Exception handling
            }
        }
    }
}

The finally block is particularly useful when dealing with resource cleanup, ensuring that resources are properly released regardless of exceptions occurring during execution.

Conclusion:

In summary, the final, finalize, and finally keywords in Java have distinct purposes and usage scenarios. The final keyword is used to indicate immutability of variables, methods, or classes. The finalize method, although discouraged, allows for cleanup actions before an object is destroyed. The finally block ensures that specific code is executed regardless of exceptions or control flow within try-catch blocks.

By understanding the differences and appropriate usage of these keywords, you can write more robust and maintainable Java code. Use the final keyword to enforce immutability, exercise caution with the finalize method, and leverage the finally block for essential cleanup operations.