登录查看更多内容

How do you refactor code that has too much or too little composition and aggregation?

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

Composition and aggregation are two common ways of creating relationships between classes in object-oriented design. They help you reuse code, avoid duplication, and follow the principle of cohesion. But how do you know if you are using them correctly? And how do you refactor your code if you have too much or too little of them? In this article, you will learn what composition and aggregation are, how to identify their benefits and drawbacks, and how to apply some refactoring techniques to improve your code quality and readability.

此文章中的业界达人

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

Timothy Atkinson

Software Engineer / Computer Scientist

1 What is composition?

Composition is a strong form of association between classes, where one class owns or contains another class. The contained class is called a component, and the containing class is called a composite. For example, a Car class can have a composition relationship with an Engine class, meaning that a car object has an engine object as a component. The component's lifecycle depends on the composite's lifecycle, so if the car object is destroyed, so is the engine object.

添加您的观点

2 What is aggregation?

Aggregation is a weaker form of association between classes, where one class references or uses another class. The referenced class is called a part, and the referencing class is called a whole. For example, a Library class can have an aggregation relationship with a Book class, meaning that a library object has a collection of book objects as a part. The part's lifecycle does not depend on the whole's lifecycle, so if the library object is destroyed, the book objects still exist.

添加您的观点

3 Benefits and drawbacks of composition and aggregation

Using composition and aggregation can be beneficial in certain contexts and design goals, as it allows for code reuse, promotes cohesion and modularity, and supports polymorphism and abstraction. However, it can also increase complexity and coupling between classes, reduce flexibility and extensibility, and introduce potential bugs and errors by exposing the internal state and behavior of the classes.

添加您的观点

4 How to identify too much or too little composition and aggregation

There is no definitive rule or metric to determine the optimal amount of composition and aggregation in your code, but there are some signs and symptoms that can indicate if you have too much or too little. If your classes have too many responsibilities and methods, dependencies and collaborations, or levels of nesting and indirection, it may be an indication of excessive composition and aggregation. On the other hand, if your classes have too little functionality and behavior, duplication and redundancy, or switch statements and conditionals, it could be a sign of inadequate composition and aggregation.

添加您的观点

Chao-Hung Sun

Snowboard Instructor | Ex-Microsoft
举报内容
Another way to identify if we should reconsider the OO design is to draw out the intended code's dependency graph, I encountered more often with excessive composition because as we work on minor feature with existing codebase, it's very tempting to just stuff one new line of composition on a class that seems fit. As a result classes become huge overtime and sometimes they actually create performance impact. and that's also time to examine whether to refactor and consider its benefits vs cost.

已翻译

赞

5 How to refactor your code using composition and aggregation

If you notice that your code has too much or too little composition and aggregation, you can apply some refactoring techniques to improve your code quality and readability. Extract class is a common technique to extract some of the responsibilities or methods into a new class, creating a composition or aggregation relationship between them. Inline class is the opposite, eliminating unnecessary composition or aggregation relationship. Additionally, you can replace inheritance with composition if it does not use or override its methods. On the other hand, you can also replace composition with inheritance if your class needs to access or modify its protected or private members.

添加您的观点

Chao-Hung Sun

Snowboard Instructor | Ex-Microsoft
(已编辑)
举报内容
I would choose the technique composition over inheritance. Though it's sort of mentioned in the article but the exact tip wasn't listed as composition over inheritance specifically suggests to define interfaces that describes the common behaviors. This generally should reduce the level of inheritance and its complexity to understand object relationships. Plus by using interface it also helps refactoring with a fair amount of unit testing using mock method to ensure your refactored code behaves the way we expected. Some programming language has the concept of extension like C#, without extension, we could still write a static method that takes an instance of the interface defined and use it to perform common logic for the interface.

已翻译

赞

6 How to test your refactored code

Refactoring your code using composition and aggregation can improve code quality and readability, but it can also introduce new bugs and errors. To ensure that the refactored code still works as expected, it is important to test it thoroughly. Unit tests can be written for each class and method to check that they pass before and after the refactoring. Integration tests are also useful for testing the interactions between the classes that you refactor. Regression tests can be used to compare the output and behavior of your refactored code with the original code to make sure they are consistent and correct.

添加您的观点

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?

添加您的观点

Timothy Atkinson

Software Engineer / Computer Scientist
举报内容
An important consideration of designing object oriented code is the creation of a new language (abet a sub-language of what ever programming language it is written in). Thinking how the end user (another programmer) will interact with this new language can help streamline the which objects are important. After brainstorming everything the end user could want, then it important to start brainstorming how to cut things out and focus the api. I find that I constantly remind myself of the saying, “design is not perfected when there is nothing left to add, but when there is nothing left to take away”.

已翻译

赞

Object Oriented Design

+ 关注

给文章评分

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

很棒不太好

举报此文章

查看全部

How do you refactor code that has too much or too little composition and aggregation?

1

2

3

4

5

6

7

1 What is composition?

2 What is aggregation?

3 Benefits and drawbacks of composition and aggregation

4 How to identify too much or too little composition and aggregation

5 How to refactor your code using composition and aggregation

6 How to test your refactored code

7 Here’s what else to consider

Object Oriented Design

给文章评分

感谢您的反馈

更多Object Oriented Design相关文章

更多相关阅读内容