Inheritance establishes an "is-a" relationship between classes, allowing child structures to acquire fields and behaviors from parent definitions. This mechanism drives modular design by enabling code reuse and hierarchical specialization.

Fundamental Characteristics

Reusability and Abstraction

Extracting shared logic into a base class eliminates redundant implementations. When common attributes are centralized at the root level, derived classes automatically inherit them, reducing maintenance overhead and ensuring consistant behavior across related types.

Specialization and Extension

Derived classes can introduce domain-specific functionality while preserving inherited operations. This pattern supports progressive refinement, where generic capabilities reside at higher levels and tailored logic is layered downward.

Single Inheritance Restriction

Java enforces a strict single-inheritance model for classes. A subclass may extend exactly one direct parent, preventing method resolution conflicts and state initialization ambiguity. However, multiple subclasses can inherit from the same parent, forming a tree structure rather than a diamond graph. At the apex of every reference type hierarchy sits java.lang.Object, which serves as the implicit base for all classes in the JVM.

The Base Reference: java.lang.Object

Unless explicitly declared with extends, every Java class implicitly inherits from Object. This baseline prvoides essential utility methods for object inspection, comparison, and memory tracking.

toString()

By default, toString() returns a string formatted as ClassName@HexHashCode. Overriding this method is standard practice to generate meaningful, human-readable representations during debugging or logging.

public class Product {
    private String sku;
    private double price;

    public Product(String sku, double price) {
        this.sku = sku;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Product[sku=" + sku + ", price=" + price + "]";
    }
}

equals(Object obj)

The == operator verifies reference identity, whereas equals() evaluates logical equivalence based on internal state. The default implementation delegates to ==, comparing memory addresses. Developers must override this method when content-based comparison is required. It operates exclusively on reference types; primitive data types cannot invoke instance methods.

public class Document {
    private String text;

    public Document(String text) { this.text = text; }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Document other = (Document) obj;
        return text != null ? text.equals(other.text) : other.text == null;
    }
}

hashCode()

This method generates an integer hash value derived from the object's state. Contractually, overriding hashCode() is mandatory whenever equals() is overridden, ensuring that logically equal objects produce identical hash codes. Adherence to this rule is critical for hash-based collections like HashMap and HashSet.

@Override
public int hashCode() {
    return text != null ? text.hashCode() : 0;
}

Type Conversion and Polymorphism

Polymorphism enables variables to hold references to different concrete implementations. Explicit casting facilitates navigation between these types while respecting compile-time safety constraints.

Upcasting (Implicit Widening)

Assigning a subclass instance to a superclass reference occurs automatically. The compiler restricts access to members defined exclusively within the child class.

class ServiceBase {
    void register() { System.out.println("Registered base service"); }
}

class WebService extends ServiceBase {
    void deploy() { System.out.println("Deployed web component"); }
}

public class CastExample {
    public static void main(String[] args) {
        ServiceBase ref = new WebService(); // Implicit upcast
        ref.register();                      // Valid: inherited method
        // ref.deploy();                   // Compilation error: undefined in ServiceBase
    }
}

Downcasting (Explicit Narrowing)

Converting a superclass reference back to its actual subclass type requires explicit casting. This operation succeeds only if the underlying object was originally instantiated as that subtype. Attempting to downcast an incompatible reference triggers a ClassCastException at runtime.

public class CastExample {
    public static void main(String[] args) {
        ServiceBase ref = new WebService();
        
        if (ref instanceof WebService) {
            WebService svc = (WebService) ref; // Safe explicit cast
            svc.deploy();                      // Valid: accesses child method
        } else {
            throw new ClassCastException("Downcast failed: type mismatch");
        }
    }
}

Direct instantiation of the parent followed by downcasting violates type safety:

ServiceBase base = new ServiceBase();
// WebService fail = (WebService) base; // Throws ClassCastException at runtime