Crafting Class Hierarchies

Hello! Welcome to the third lesson in our journey through Object-Oriented Programming foundations.

In the previous lesson, we focused on encapsulation and the use of access modifiers (public, private, default). We ended by noting that the protected modifier is specifically designed for inheritance, allowing subclasses to access members of their parent class. Today, we'll explore that relationship fully.

Our learning outcome is to design class hierarchies using inheritance, abstract classes, and interfaces. This is a fundamental skill in Low-Level Design. In an interview, creating a well-structured class hierarchy demonstrates that you can build systems that are logical, maintainable, and flexible.

1. Inheritance: The "Is-A" Relationship

At its core, inheritance allows a new class (the subclass or child class) to be based on an existing class (the superclass or parent class). The subclass inherits the attributes and methods of its superclass, forming an "is-a" relationship. For example, a Manager is a type of Employee.

This mechanism is central to creating logical hierarchies and promoting code reuse. Let's dive into the theory with a foundational reading.

To summarize the key points from the reading:

• Code Reusability: You define common attributes and behaviors in a superclass, and multiple subclasses can reuse them without duplication. The classic example is a Person class with name and address, which can be extended by Employee and Customer.
• Type Hierarchy: Inheritance creates a clear and logical structure. A Car object is also a Vehicle object. This relationship is crucial for polymorphism, which we will cover in a future lesson.
• Overriding: A subclass can provide its own specific implementation of a method that it inherits from its superclass. For instance, a SavingsAccount might override the withdraw method of a BankAccount to add a fee.
• The super keyword: This keyword gives you access to the immediate parent class. You can use super.methodName() to call the parent's method from within an overridden method, or super() to call the parent's constructor.

A quick note on access modifiers: as we touched upon last lesson, and as the reading details in its "How Are Access Modifiers Affected By Inheritance?" section, protected members of a superclass are directly accessible to its subclasses. This is how you allow child classes to interact with the parent's state in a controlled way, without making that state public.

2. Abstract Classes: Defining a Template

What if you have a concept that is too general to be instantiated on its own? For instance, it makes sense to create a Dog or Cat object, but does it make sense to create a generic Animal object? What kind of animal would it be?

This is where abstract classes come in. An abstract class serves as a template for other classes. It cannot be instantiated itself, but it can be extended.

Key characteristics of abstract classes:

• They are declared with the abstract keyword.
• They cannot be instantiated directly using new.
• They can contain both abstract methods (with no implementation) and concrete methods (with a full implementation).
• Any concrete (non-abstract) class that extends an abstract class must provide an implementation for all inherited abstract methods.

By using an abstract class, you are saying: "Any class that is a type of X must have these specific behaviors and can optionally use this shared code."

3. Interfaces: Defining a Contract

While inheritance defines what an object is, an interface defines what an object can do. An interface is a contract that specifies a set of method signatures. Any class that implements an interface agrees to provide implementations for all the methods defined in that interface.

The most significant difference from class inheritance is that a Java class can implement multiple interfaces but can only extend one superclass.

Let's see a practical example of how to use both abstract classes and interfaces together to build a flexible design.

An interface defines a "can-do" or "has-a-capability" relationship. A Car and a Person are unrelated, but both could implement a Sellable interface. A Thread and a TimerTask are different, but both implement the Runnable interface because they both define a task that can be run.

This is powerfully demonstrated in the Java Development Kit (JDK) itself. For example, the Java Collection Framework is built on a rich hierarchy of interfaces and classes.

4. Abstract Class vs. Interface: Making the Design Choice

In a system design interview, you'll need to justify your design choices. When should you use an abstract class, and when is an interface more appropriate?

Let's watch a final short clip that directly compares the two.

Here's a summary to guide your decision:

Use an Abstract Class when:

• You want to share code among several closely related classes.
• You expect that classes that extend your abstract class have many common methods or fields, or require access modifiers other than public (e.g., protected).
• You are defining the fundamental identity of an object and want to establish a strong "is-a" relationship. (e.g., AbstractVehicle, AbstractAccount).

Use an Interface when:

• You expect that unrelated classes will implement the interface. For example, Comparable and Cloneable are implemented by many unrelated classes.
• You want to specify the behavior of a particular data type, but you are not concerned about who implements its behavior.
• You want to take advantage of multiple inheritance of type.

5. Application in a Low-Level Design

Let's see how these concepts are applied in a real LLD problem. We'll look at the design for a system like Stack Overflow. User-generated content comes in different forms: questions, answers, and comments. This is a perfect candidate for a class hierarchy.

The Stack Overflow design uses a hierarchy to great effect:

• Content (abstract): The base for all content, containing common fields like author and creationTime.
• Post (abstract, extends Content): A more specific type of content that can be voted on. It adds voting logic.
• Question (concrete, extends Post): A post with a title and tags.
• Answer (concrete, extends Post): A post that belongs to a question.
• Comment (concrete, extends Content): Simple content that cannot be voted on.

This structure is logical and prevents code duplication by placing shared functionality in the appropriate parent class.

Conclusion

Today, we explored the tools for building structured and logical class hierarchies in Java. Designing these hierarchies is a creative process of identifying commonalities and separating concerns.

Key Takeaways:

• Inheritance (extends) creates an "is-a" relationship, allowing a subclass to inherit state and behavior from a single superclass. It's for building a hierarchy of related objects.
• Abstract Classes serve as non-instantiable templates for a family of classes. They can provide shared code (concrete methods) and enforce common behavior (abstract methods).
• Interfaces (implements) define a "can-do" contract. A class can implement multiple interfaces, allowing objects from different hierarchies to share common behaviors.
• The choice between them is a key design decision: use abstract classes for shared identity and code within a family; use interfaces to define capabilities that can be applied across different families.

In this lesson, we saw how a subclass can override a method from its superclass. This is a powerful feature that enables runtime polymorphism. In our next lesson, we will focus entirely on this concept: implementing runtime polymorphism using method overriding.