title	shortTitle	description	category	language	tag
Table Inheritance Pattern in Java: Modeling Hierarchical Data in Relational Databases	Table Inheritance	Explore the Table Inheritance pattern in Java with real-world examples, database schema, and tutorials. Learn how to model class hierarchies elegantly in relational databases.	Data Access Pattern, Structural Pattern	en	Decoupling Inheritance Polymorphism Object Mapping Persistence Data Transformation

Also Known As

• Class Table Inheritance

---

Intent of Table Inheritance Pattern

The Table Inheritance pattern models a class hierarchy in a relational database by creating separate tables for each class in the hierarchy. These tables share a common primary key, which in subclass tables also serves as a foreign key referencing the primary key of the base class table. This linkage maintains relationships and effectively represents the inheritance structure. This pattern enables the organization of complex data models, particularly when subclasses have unique properties that must be stored in distinct tables.

---

Detailed Explanation of Table Inheritance Pattern with Real-World Examples

Real-World Example

Consider a Vehicle Management System with a Vehicle superclass and subclasses like Car and Truck.

• The Vehicle Table stores attributes common to all vehicles, such as make, model, and year. Its primary key (id) uniquely identifies each vehicle.
• The Car Table and Truck Table store attributes specific to their respective types, such as numberOfDoors for cars and payloadCapacity for trucks.
• The id column in the Car Table and Truck Table serves as both the primary key for those tables and a foreign key referencing the id in the Vehicle Table.

This setup ensures each subclass entry corresponds to a base class entry, maintaining the inheritance relationship while keeping subclass-specific data in their own tables.

In Plain Words

In table inheritance, each class in the hierarchy is represented by a separate table, which allows for a clear distinction between shared attributes (stored in the base class table) and specific attributes (stored in subclass tables).

Martin Fowler Says

Relational databases don't support inheritance, which creates a mismatch when mapping objects. To fix this, Table Inheritance uses a separate table for each class in the hierarchy while maintaining relationships through foreign keys, making it easier to link the classes together in the database.

For more detailed information, refer to Martin Fowler's article on Class Table Inheritance.

Programmatic Example of Table Inheritance Pattern in Java

The Vehicle class will be the superclass, and we will have Car and Truck as subclasses that extend Vehicle. The Vehicle class will store common attributes, while Car and Truck will store attributes specific to those subclasses.

Key Aspects of the Pattern:

1. Superclass (Vehicle):
   The Vehicle class stores attributes shared by all vehicle types, such as:

   • make: The manufacturer of the vehicle.
   • model: The model of the vehicle.
   • year: The year the vehicle was manufactured.
   • id: A unique identifier for the vehicle.

   These attributes are stored in the Vehicle table in the database.

2. Subclass (Car and Truck):
   Each subclass (Car and Truck) stores attributes specific to that vehicle type:

   • Car: Has an additional attribute numberOfDoors representing the number of doors the car has.
   • Truck: Has an additional attribute payloadCapacity representing the payload capacity of the truck.

   These subclass-specific attributes are stored in the Car and Truck tables.

3. Foreign Key Relationship:
   Each subclass (Car and Truck) contains the id field which acts as a foreign key that references the primary key (id) of the superclass (Vehicle). This foreign key ensures the relationship between the common attributes in the Vehicle table and the specific attributes in the subclass tables (Car and Truck).

/**
 * Superclass
 * Represents a generic vehicle with basic attributes like make, model, year, and ID.
 */
public class Vehicle {
    private String make;
    private String model;
    private int year;
    private int id;

    // Constructor, getters, and setters...
}

/**
 * Represents a car, which is a subclass of Vehicle.
 */
public class Car extends Vehicle {
    private int numberOfDoors;

    // Constructor, getters, and setters...
}

/**
 * Represents a truck, which is a subclass of Vehicle.
 */
public class Truck extends Vehicle {
    private int payloadCapacity;

    // Constructor, getters, and setters...
}

Table Inheritance Pattern Class Diagram

Table Inheritance Pattern Database Schema

Vehicle Table

Column	Description
id	Primary key
make	The make of the vehicle
model	The model of the vehicle
year	The manufacturing year of the vehicle

Car Table

Column	Description
id	Foreign key referencing Vehicle(id)
numberOfDoors	Number of doors in the car

Truck Table

Column	Description
id	Foreign key referencing Vehicle(id)
payloadCapacity	Payload capacity of the truck

---

When to Use the Table Inheritance Pattern in Java

• When your application requires a clear mapping of an object-oriented class hierarchy to relational tables.
• When subclasses have unique attributes that do not fit into a single base table.
• When scalability and normalization of data are important considerations.
• When you need to separate concerns and organize data in a way that each subclass has its own table but maintains relationships with the superclass.

Table Inheritance Pattern Java Tutorials

• Software Patterns Lexicon: Class Table Inheritance
• Martin Fowler: Class Table Inheritance

---

Real-World Applications of Table Inheritance Pattern in Java

• Vehicle Management System: Used to store different types of vehicles like Car and Truck in separate tables but maintain a relationship through a common superclass Vehicle.
• E-Commerce Platforms: Where different product types, such as Clothing, Electronics, and Furniture, are stored in separate tables with shared attributes in a superclass Product.

Benefits and Trade-offs of Table Inheritance Pattern

Benefits

• Clear Structure: Each class has its own table, making the data model easier to maintain and understand.
• Scalability: Each subclass can be extended independently without affecting the other tables, making the system more scalable.
• Data Normalization: Helps avoid data redundancy and keeps the schema normalized.

Trade-offs

• Multiple Joins: Retrieving data that spans multiple subclasses may require joining multiple tables, which could lead to performance issues.
• Increased Complexity: Managing relationships between tables and maintaining integrity can become more complex.
• Potential for Sparse Tables: Subclasses with fewer attributes may end up with tables that have many null fields.

Related Java Design Patterns

• Single Table Inheritance – A strategy where a single table is used to store all classes in an inheritance hierarchy. It stores all attributes of the class and its subclasses in one table.
• Singleton Pattern – Used when a class needs to have only one instance.

References and Credits

• Martin Fowler - Patterns of Enterprise Application Architecture
• Java Persistence with Hibernate - Link to book
• Object-Relational Mapping on Wikipedia - Link to article