How do you avoid inheritance and template method pattern mistakes?

由人工智能和领英社区提供技术支持

Inheritance and template method pattern are two common design patterns that can help you reuse code and define algorithms with hooks for subclasses. However, they can also lead to problems such as tight coupling, fragile base class, violation of the Liskov substitution principle, and increased complexity. How do you avoid these pitfalls and use these patterns effectively? Here are some tips and best practices to follow.

此文章中的业界达人

由社区从 3 条内容中精选。了解更多

Amritpal Singh

CTO at Zapbuild Technologies

1 Use composition over inheritance

One of the main principles of SOLID design is to favor composition over inheritance. This means that instead of inheriting behavior from a base class, you can delegate it to a separate object that implements an interface or an abstract class. This way, you can achieve more flexibility, modularity, and testability in your code. For example, instead of creating a subclass for each type of animal that inherits from a base class Animal, you can create a separate class for each behavior, such as FlyBehavior or QuackBehavior, and compose them into different animals.

添加您的观点

Amritpal Singh

CTO at Zapbuild Technologies
举报内容
The Polymorphic Open Closed Principle suggests to use Contracts or Interfaces to abstract the differentiating "Behaviors" in your code. This does not just simply mean using Interfaces and Polymorphism but also thinking from a generalization point-of-view where you need to identify Common but Variable behaviors and implement those behaviors separately with a common abstraction/interface. While thinking from a generalization perspective, a useful tip that helped me personally is to change the way we think about naming the behaviors. While writing Classes and Method names, we should start thinking in terms of common behaviors and Name them accordingly. All the common behaviors, then, form a family and can be separated as a common interface.

已翻译

赞

2 Use template method pattern sparingly

The template method pattern defines the skeleton of an algorithm in a base class and lets subclasses override some steps without changing the structure. This can be useful when you have common logic that can be shared among different variations of the same algorithm. However, you should use this pattern sparingly, as it can create tight coupling between the base class and the subclasses, making them hard to change and extend. Moreover, it can violate the Liskov substitution principle, which states that subclasses should be substitutable for their base class without breaking the program. For example, if you have a base class CoffeeMaker that defines a template method makeCoffee(), and a subclass EspressoMaker that overrides some steps, you cannot use an EspressoMaker object where a CoffeeMaker object is expected, as they have different behaviors.

添加您的观点

3 Use abstract classes and interfaces wisely

When using inheritance and template method pattern, you should use abstract classes and interfaces wisely. Abstract classes are classes that cannot be instantiated and have at least one abstract method that must be implemented by subclasses. Interfaces are contracts that define the methods that a class must implement, but do not provide any implementation. Both abstract classes and interfaces can help you define the common behavior and structure of your subclasses, but they have different purposes and trade-offs. For example, abstract classes can provide some default implementation and state, but they limit the inheritance hierarchy to a single branch. Interfaces can support multiple inheritance and polymorphism, but they cannot have any state or implementation.

添加您的观点

4 Refactor your code regularly

One of the best ways to avoid inheritance and template method pattern mistakes is to refactor your code regularly. Refactoring is the process of improving the design and quality of your code without changing its functionality. It can help you identify and eliminate code smells, such as duplicated code, long methods, large classes, and inappropriate coupling. By refactoring your code, you can make it more readable, maintainable, and extensible. For example, you can use the extract method technique to break down a long method into smaller methods, or the replace inheritance with delegation technique to replace a subclass with a composed object.

添加您的观点

5 Apply the open-closed principle

Another important principle of SOLID design is the open-closed principle, which states that classes should be open for extension, but closed for modification. This means that you should be able to add new features or behaviors to your classes without changing the existing code. This can help you avoid breaking the existing functionality and reduce the risk of introducing bugs. One way to apply the open-closed principle is to use the strategy pattern, which defines a family of interchangeable algorithms that can be selected at runtime. For example, instead of using the template method pattern to define different ways of sorting a list, you can use the strategy pattern to define different sorting algorithms as separate classes that implement a common interface, and pass them as parameters to a context class that performs the sorting.

添加您的观点

Amritpal Singh

CTO at Zapbuild Technologies
举报内容
OCP means that your code should be written in a way that makes it flexible to adapt to changing functionality or new additions to the application (Open), however, without modifying already written and tested code (closed). Initially, Meyer suggested that classes and common code should be distributed as compiled libraries which makes them closed for modification, however, they would still be open for inheritance. However, Inheritance introduces tight coupling. In 1990s, Robert C. Martin started proposing to use Polymorphic Open Closed Principle. Using Polymorphism, we can provide the interface abstraction to the changing behaviors/functionality and avoid the dependency on a strict implementation of that module.

已翻译

赞

6 Learn from examples and resources

Finally, if you want to avoid mistakes related to inheritance and template method patterns, you should learn from examples and resources. There are many books, blogs, courses, and tutorials that can help you use these patterns correctly. Some of the most popular and recommended ones are Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma et al., Head First Design Patterns by Eric Freeman et al., Refactoring: Improving the Design of Existing Code by Martin Fowler et al., Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin, and SOLID Principles for C# Developers by Steve Smith.

添加您的观点

Amritpal Singh

CTO at Zapbuild Technologies
举报内容
As mentioned in first section, always code to Composition and separate the behaviors from parent class using Interfaces. In this example, the Marching behavior of different Soldiers are separated. Inteface MarchingBehavior { public abstract void March(); } Class Soldier { MarchingBehavior marchBehavior; public int Attack() { } } Class MarchByFoot : MarchingBehavior { public override void March() { "March by Foot"; } } Class MarchByHorse : MarchingBehavior { public override void March() { "March by Horse"; } } Class SwordsMan : Soldier { public void SwordsMan() { marchBehavior = new MarchByFoot(); } } Class Knight : Soldier { public void Knight() { marchBehavior = new MarchByHorse(); } }

已翻译

赞

7 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?

添加您的观点

Design Patterns

+ 关注

给文章评分

我们借助人工智能创建了此文章。您认为这篇文章怎么样？

很棒不太好

举报此文章

查看全部

How do you avoid inheritance and template method pattern mistakes?

1

2

3

4

5

6

7

1 Use composition over inheritance

2 Use template method pattern sparingly

3 Use abstract classes and interfaces wisely

4 Refactor your code regularly

5 Apply the open-closed principle

6 Learn from examples and resources

7 Here’s what else to consider

Design Patterns

给文章评分

感谢您的反馈

更多Design Patterns相关文章

更多相关阅读内容