UML diagram inheritance

Mastering Inheritance in UML Class Diagrams

Explore how to effectively represent inheritance relationships in UML class diagrams, a fundamental concept for object-oriented design and system architecture.

UML (Unified Modeling Language) class diagrams are powerful tools for visualizing the static structure of a system, including its classes, attributes, operations, and the relationships between them. Among these relationships, inheritance is a cornerstone of object-oriented programming, allowing classes to inherit properties and behaviors from other classes. Understanding how to correctly model inheritance in UML is crucial for designing robust, scalable, and maintainable software systems.

Understanding Inheritance in Object-Oriented Design

Inheritance is a mechanism that allows a new class (subclass or derived class) to be based on an existing class (superclass or base class), inheriting its fields and methods. This promotes code reusability and establishes a hierarchical relationship between classes, often representing an 'is-a' relationship. For example, a 'Car' is a type of 'Vehicle', and a 'Dog' is a type of 'Animal'. In UML, this relationship is depicted using a specific notation that clearly communicates the direction and nature of the inheritance.

classDiagram
    Animal <|-- Dog
    Animal <|-- Cat
    Vehicle <|-- Car
    Vehicle <|-- Motorcycle

    class Animal {
        +String species
        +int age
        +makeSound()
    }

    class Dog {
        +String breed
        +bark()
    }

    class Cat {
        +boolean indoor
        +meow()
    }

    class Vehicle {
        +String make
        +String model
        +int year
        +startEngine()
    }

    class Car {
        +int numDoors
        +drive()
    }

    class Motorcycle {
        +boolean hasSidecar
        +ride()
    }

UML Class Diagram illustrating basic inheritance relationships

UML Notation for Inheritance

In UML class diagrams, inheritance is represented by a solid line with a large, unfilled arrowhead pointing from the subclass to the superclass. This arrowhead is often referred to as a 'generalization arrow' because the superclass is a more general form of the subclass. The arrow indicates the direction of the dependency: the subclass depends on the superclass for its definition. Attributes and methods inherited from the superclass are typically not repeated in the subclass's compartment unless they are overridden or specialized.

public class Vehicle {
    private String make;
    private String model;

    public Vehicle(String make, String model) {
        this.make = make;
        this.model = model;
    }

    public void startEngine() {
        System.out.println("Engine started.");
    }
}

public class Car extends Vehicle {
    private int numDoors;

    public Car(String make, String model, int numDoors) {
        super(make, model);
        this.numDoors = numDoors;
    }

    public void drive() {
        System.out.println("Car is driving.");
    }
}

Abstract Classes and Interfaces in UML

UML also provides specific notations for abstract classes and interfaces, which are key components of inheritance hierarchies. An abstract class is a class that cannot be instantiated directly and may contain abstract methods (methods without implementation). In UML, an abstract class name and its abstract methods are italicized. An interface, on the other hand, defines a contract of behavior that implementing classes must adhere to. In UML, an interface is represented by a class box with the stereotype <<interface>> above its name, or by a small circle connected to the implementing class by a dashed line.

classDiagram
    Animal <|-- Dog
    Animal <|-- Cat
    <<interface>> Swimmer
    Dog ..|> Swimmer : implements

    class Animal {
        <<abstract>>
        +String species
        +int age
        +makeSound()
        +<<abstract>> move()
    }

    class Dog {
        +String breed
        +bark()
        +move()
        +swim()
    }

    class Cat {
        +boolean indoor
        +meow()
        +move()
    }

    class Swimmer {
        +swim()
    }

UML Class Diagram showing abstract class and interface implementation