> ## 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 Class
A `final` class in Java is a class declared with the `final` modifier, which strictly prohibits inheritance. Once a class is marked as `final`, it becomes a terminal node in the class hierarchy, meaning the Java compiler will reject any attempt by another class to extend it.
```java theme={"dark"}
public final class TerminalClass {
// Class members
}
```
## Core Mechanics and Compiler Behavior
**Inheritance Restriction**
Attempting to use the `extends` keyword on a `final` class results in a strict compile-time error (`cannot inherit from final`).
```java theme={"dark"}
public final class BaseComponent {
}
// COMPILER ERROR: Cannot inherit from final 'BaseComponent'
public class SubComponent extends BaseComponent {
}
```
**Method Implication and Binding**
Because a `final` class cannot be subclassed, it is impossible for any of its instance methods to be overridden. Consequently, the compiler can safely use static binding (early binding) for all method calls on instances of the class. Explicitly declaring methods as `final` inside a `final` class is syntactically valid but entirely redundant.
**Field Mutability**
Applying the `final` modifier to a class declaration does **not** cascade to its members. Instance variables within a `final` class remain fully mutable unless they are individually declared with the `final` modifier.
```java theme={"dark"}
public final class StateContainer {
// This field can still be modified after instantiation
public int mutableCounter = 0;
// This field is strictly immutable
public final String id = "STATIC_ID";
}
```
**Instantiation**
The `final` modifier has no impact on object creation. A `final` class behaves identically to a standard class regarding instantiation and can be instantiated normally using the `new` keyword, provided its constructors are accessible.
## Modifier Conflicts
A class cannot be declared as both `abstract` and `final`. This is a logical contradiction enforced by the compiler: the `abstract` modifier dictates that a class *must* be subclassed to implement its abstract methods, whereas the `final` modifier dictates that a class *cannot* be subclassed.
```java theme={"dark"}
// COMPILER ERROR: Illegal combination of modifiers: 'abstract' and 'final'
public abstract final class InvalidClass {
}
```
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
