Inheritance and interface notation in LLD - System Design Guide

Problem Statement

When designing software, unclear relationships between classes cause confusion and errors. Without clear notation, developers struggle to understand which classes share behavior or must implement certain methods, leading to inconsistent code and harder maintenance.

Solution

Using inheritance and interface notation clearly shows which classes inherit behavior from others and which classes promise to implement specific methods. This visual and code-level clarity helps teams understand class roles, reuse code properly, and enforce contracts between components.

Architecture

Interface

(Drawable)

→Class A

↓

Class B

Class B

This diagram shows an interface named Drawable implemented by Class A, and Class B inherits from Class A, illustrating interface implementation and inheritance relationships.

Trade-offs

✓ Pros

→

Clarifies class relationships and responsibilities in code.

→

Enables code reuse through inheritance, reducing duplication.

→

Enforces method implementation contracts via interfaces.

→

Improves maintainability and team communication.

✗ Cons

→

Overusing inheritance can lead to rigid and tightly coupled code.

→

Interfaces add extra code and complexity if overused for simple cases.

→

Misusing inheritance for code reuse can cause fragile designs.

Use when multiple classes share common behavior or must follow a contract, especially in medium to large codebases with multiple developers.

Avoid deep inheritance hierarchies in small projects or when classes have little shared behavior; prefer composition or simpler patterns.

Real World Examples

Google

Uses interfaces extensively in Android development to define UI components contracts, ensuring consistent behavior across different widgets.

Microsoft

In .NET framework, interfaces define service contracts allowing different implementations to be swapped without changing client code.

Amazon

Uses inheritance in backend services to share common logic like logging and error handling across multiple service classes.

Code Example

The before code has classes with draw methods but no enforced contract. The after code defines an abstract interface Drawable requiring draw method, a base class Shape implementing it, and Circle and Square inherit Shape overriding draw. This clarifies relationships and enforces method implementation.

LLD

### Before: No clear interface or inheritance
class Circle:
    def draw(self):
        print("Drawing circle")

class Square:
    def draw(self):
        print("Drawing square")

### After: Using interface and inheritance notation
from abc import ABC, abstractmethod

class Drawable(ABC):
    @abstractmethod
    def draw(self):
        pass

class Shape(Drawable):
    def draw(self):
        print("Drawing shape")

class Circle(Shape):
    def draw(self):
        print("Drawing circle")

class Square(Shape):
    def draw(self):
        print("Drawing square")

Alternatives

Composition over Inheritance

Instead of inheriting behavior, classes contain instances of other classes to reuse functionality.

Use when: When you want more flexible and loosely coupled designs avoiding rigid inheritance hierarchies.

Mixin Classes

Small classes provide specific behavior that can be combined with other classes without forming deep inheritance trees.

Use when: When you need to share behavior across unrelated classes without forcing a strict parent-child relationship.

Summary

Inheritance and interface notation clarify class relationships and contracts in software design.

They help enforce method implementation and enable code reuse while improving maintainability.

Use them carefully to avoid rigid designs and prefer alternatives like composition when appropriate.

Practice

1. What does the notation <|-- represent in system design diagrams?

easy

A. Dependency, where one class depends on another

B. Interface implementation, where a class follows a set of rules

C. Inheritance, where one class is a specialized version of another

D. Aggregation, where one class contains another

Solution

1. Step 1: Understand notation meanings

   The notation <|-- is used to show inheritance in system design diagrams.

2. Step 2: Differentiate from interface notation

   Interface implementation uses <|.., not <|--.

3. Final Answer:

   Inheritance, where one class is a specialized version of another -> Option C

4. Quick Check:

   Inheritance = <|-- [OK]

Hint: Inheritance uses solid arrow <|-- [OK]

Common Mistakes:

• Confusing inheritance with interface implementation
• Mixing aggregation with inheritance notation
• Assuming dependency uses <|--

2. Which of the following is the correct notation for a class implementing an interface?

easy

A. Class <|-- Interface

B. Class <|.. Interface

C. Interface <|-- Class

D. Interface <|.. Class

Solution

1. Step 1: Recall interface implementation notation

   Interface implementation is shown by a dashed arrow <|.. from class to interface.

2. Step 2: Verify direction and notation

   The arrow points from the class to the interface, so Class <|.. Interface is correct.

3. Final Answer:

   Class <|.. Interface -> Option B

4. Quick Check:

   Interface implementation = <|.. from class to interface [OK]

Hint: Interface uses dashed arrow <|.. from class [OK]

Common Mistakes:

• Reversing arrow direction between class and interface
• Using solid arrow for interface implementation
• Confusing interface and inheritance notation

3. Given the following UML snippet:

interface IAnimal
class Dog <|.. IAnimal
class Labrador <|-- Dog

Which statement is true?

medium

A. IAnimal inherits from Dog and Labrador

B. Labrador implements IAnimal and inherits from Dog

C. Dog inherits from Labrador and implements IAnimal

D. Dog implements IAnimal and Labrador inherits from Dog

Solution

1. Step 1: Analyze interface implementation

   Dog implements IAnimal, shown by <|.. from Dog to IAnimal.

2. Step 2: Analyze inheritance

   Labrador inherits from Dog, shown by <|-- from Labrador to Dog.

3. Final Answer:

   Dog implements IAnimal and Labrador inherits from Dog -> Option D

4. Quick Check:

   Interface = <|.., Inheritance = <|-- [OK]

Hint: Dashed arrow = interface, solid arrow = inheritance [OK]

Common Mistakes:

• Mixing inheritance and interface directions
• Assuming interface inherits classes
• Confusing which class inherits which

4. Identify the error in this UML notation:

class Vehicle <|.. Car
interface Drivable <|-- Vehicle

medium

A. Vehicle cannot implement Car because Car is a class

B. Drivable cannot inherit Vehicle because interfaces use dashed arrows for inheritance

C. Arrow directions are reversed for both lines

D. No error, notation is correct

Solution

1. Step 1: Check first line meaning

   Vehicle <|.. Car means Vehicle implements Car, but Car is a class, not an interface, so this is invalid.

2. Step 2: Check second line meaning

   Drivable <|-- Vehicle means Drivable inherits Vehicle, but Drivable is an interface and Vehicle a class, so invalid.

3. Final Answer:

   Vehicle cannot implement Car because Car is a class -> Option A

4. Quick Check:

   Classes implement interfaces only [OK]

Hint: Classes implement interfaces, not other classes [OK]

Common Mistakes:

• Allowing classes to implement classes
• Reversing inheritance arrow direction
• Ignoring interface vs class roles

5. You are designing a system where Smartphone inherits from Device and implements two interfaces: Camera and GPS. Which UML notation correctly represents this?

hard

A. Smartphone <|-- Device
Smartphone <|.. Camera
Smartphone <|.. GPS

B. Device <|-- Smartphone
Smartphone <|.. Camera
Smartphone <|.. GPS

C. Device <|.. Smartphone
Camera <|-- Smartphone
GPS <|-- Smartphone

D. Smartphone <|.. Device
Camera <|.. Smartphone
GPS <|.. Smartphone

Solution

1. Step 1: Identify inheritance direction

   Smartphone inherits from Device, so arrow <|-- points from Smartphone to Device: Smartphone <|-- Device.

2. Step 2: Identify interface implementation

   Smartphone implements Camera and GPS interfaces, so dashed arrows <|.. point from Smartphone to each interface.

3. Step 3: Verify all notations

   Smartphone <|-- Device
   Smartphone <|.. Camera
   Smartphone <|.. GPS

   correctly shows inheritance and interface implementation directions.

4. Final Answer:

   Smartphone <|-- Device Smartphone <|.. Camera Smartphone <|.. GPS -> Option A

5. Quick Check:

   Inheritance arrow points to parent, interface arrow dashed from class [OK]

Hint: Inheritance arrow points to parent class, interface arrow dashed from class [OK]

Common Mistakes:

• Reversing inheritance arrow direction
• Using solid arrow for interface implementation
• Pointing interface arrows from interface to class