Скачать или смотреть Understanding Design Patterns: How to Properly Use Inheritance in OOP for Container Classes

Discover how to refactor your class architecture in object-oriented programming to properly express relationships between `container` classes through inheritance and composition.
---
This video is based on the question https://stackoverflow.com/q/63410193/ asked by the user 'Solon' ( https://stackoverflow.com/u/2074574/ ) and on the answer https://stackoverflow.com/a/63526375/ provided by the user 'Booboo' ( https://stackoverflow.com/u/2823719/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: design pattern to express that "container" over derived class is derived from container of a base class

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Design Patterns: How to Properly Use Inheritance in OOP for Container Classes

Inheritance is one of the core principles of object-oriented programming (OOP). However, when it comes to representing relationships between complex classes, things can get tricky. This guide explores a common issue faced by developers: how to represent a container class derived from a base class while adhering to proper design principles.

The Problem

Imagine you have a class called Track that holds a set of Point instances. This class represents a person's location over time. You've extended the functionality of Point through a subclass called OptimizedPoint, which contains additional data necessary for optimization. You also created a class OptimizedTrack, which is a collection of OptimizedPoints and includes more data for optimization purposes.

After running an optimization routine, you need to present the user with clean data from the original Track class without the optimization data. However, you face a dilemma: how can you express that OptimizedTrack is an extension of Track? More specifically, how can you introduce common methods—like calculating the length of the track—that apply to both classes? This dilemma arises because you can't directly establish a parent-child relationship between an array of OptimizedPoint and an array of Point.

Proposed Solution

The solution to this problem lies in understanding object-oriented design principles and recognizing the limitations of inheritance for container classes. Here’s a breakdown of the recommended approach:

Rethink the Use of Inheritance

While it may seem intuitive to make OptimizedTrack a subclass of Track, this approach contradicts the fundamentals of the Liskov Substitution Principle. This principle emphasizes that a subclass should be able to stand in for its base class without causing issues. Since you cannot substitute a container of Point into a container of OptimizedPoint, trying to derive the two creates problems.

Use Composition Instead

Instead of inheritance, you should use composition to build OptimizedTrack using an instance of Track.

Define the Track Class:

[[See Video to Reveal this Text or Code Snippet]]

Define OptimizedTrack with Composition:

[[See Video to Reveal this Text or Code Snippet]]

Benefits of This Design

By using composition, you can accomplish several goals:

Maintainability: Changes to the Track logic will automatically apply to OptimizedTrack, ensuring that both classes stay synchronized.

Flexibility: You can easily extend the functionality of OptimizedTrack by adding more methods without impacting Track.

Clarity: It becomes clear that OptimizedTrack is a separate entity that enhances Track with additional capabilities without muddling the inheritance hierarchy.

Conclusion

In summation, while inheritance has its place within object-oriented programming, it is crucial to use it judiciously, particularly with container classes. The best approach in this scenario is to embrace composition to convey the relationship between Track and OptimizedTrack. This design choice not only aligns with established OOP principles but also enhances the architecture of your code, promoting better functionality and user experience.

By keeping these design patterns in mind, you can effectively manage class structures in your applications, leading to cleaner, more efficient codebases.