Final Class In Java

What is Final Class in Java?

In Java programming, a final class is a class that cannot be extended (subclassed or inherited from). In other words, no other class can inherit from a final class. This is achieved by using the keyword final in the class declaration.

Properties of Final Class In Java

Some key properties of final classes in Java:

• A final class cannot be subclassed. Attempting to extend a final class will result in a compile-time error. This prevents other classes from inheriting from and modifying the behavior of a final class.
• All the methods in a final class are implicitly final. You do not need to actually declare them as final. Since the class cannot be subclassed, there is no way for a subclass to override the methods.
• Instance fields and static fields in a final class can be modified, unless they are declared as final themselves. The final modifier on a class only prevents subclassing, not modification of fields.
• A final class can extend other classes and implement interfaces like any other non-final class. The final modifier only prevents other classes from extending this class.
• Final classes are useful for classes that need to remain immutable for security or thread-safety purposes. Examples from the Java API include the String class and Box classes like Integer and Long.

So, final keyword prevents subclassing, implicitly finalizes all methods, but allows fields to be modified unless themselves declared final. Finality allows immutability but does not prevent extending other classes.

public final class FinalClass {

  // class contents

}

When To Use Final Class In Java

You should use a final class in Java when you want to prevent that class from being subclassed or extended. Here are some common scenarios and Java code examples where using a final class is appropriate:

Utility Classes

When you have a class that contains only static methods and is used as a utility, making it final ensures it cannot be extended or modified.

final class MathUtils {

    private MathUtils() {} // Private constructor to prevent instantiation

    public static int add(int a, int b) {
        return a + b;
    }

    public static int multiply(int a, int b) {
        return a * b;
    }
}

By making MathUtils final, you ensure that it cannot be subclassed or modified. Users can only use its static methods.

Immutable Classes

In cases where you want to create immutable objects, you can make the class final to prevent any modification to its state once it’s constructed.

final class ImmutablePerson {
    private final String name;
    private final int age;

    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

This ImmutablePerson class ensures that once an instance is created, its state cannot be changed.

Security Concerns

In cases where you want to protect sensitive data or operations, making a class final can enhance security.

final class SecureDataStorage {
    private final String encryptedData;

    public SecureDataStorage(String encryptedData) {
        this.encryptedData = encryptedData;
    }

    // Additional security-related methods
}

By making SecureDataStorage final, you prevent any unauthorised changes to the data it holds.

Singleton Design Pattern

When implementing the Singleton design pattern, you can make the Singleton class final to ensure there’s only one instance.

final class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {} // Private constructor

    public static Singleton getInstance() {
        return INSTANCE;
    }

    // Other methods and data
}

The final keyword guarantees that there won’t be subclasses or multiple instances of the Singleton.

In all these cases, using the final keyword ensures that the class cannot be extended, which aligns with the design intent and enhances code stability and security.

Predefined Final Classes in Java

In Java, there are several predefined final classes provided by the Java Standard Library and the Java API. These classes are marked as final by design, and they serve various purposes in the Java ecosystem. Here are some examples of predefined final class in Java:

Advantages Of Final Class In Java

The advantages of using final class in Java are:

• Enhances Security and Integrity: Final classes cannot be extended, ensuring consistent and secure behavior.
• Ensures Thread Safety: Immutable final classes guarantee thread safety by preventing state changes.
• Optimizes Performance: Final classes allow for performance optimizations due to their predictable behavior.
• Clarifies Design Intent: Marking a class as final communicates the intent to discourage unnecessary subclassing.
• Promotes Consistency: Final classes provide a stable foundation, reducing the risk of unexpected changes.