《重构-改善既有代码的设计 第二版》第12章“处理继承关系”的总结、重点及读书笔记。
一、总结
第12章“处理继承关系”主要讨论了如何通过重构手法来优化继承层次结构，使代码更加清晰、简洁和易于维护。Martin Fowler 提供了多种具体的重构方法，来解决继承关系中的常见问题，如代码重复、类职责不清晰、过度依赖继承等。通过这些方法，可以提高代码的可维护性和可扩展性。
二、重点
1. **函数上移（Pull Up Method）**：
- 将子类中重复的方法移到超类中，减少代码重复。
- 提高代码复用性和维护性。
2. **字段上移（Pull Up Field）**：
- 将子类中重复的字段移到超类中，减少代码重复。
- 提高代码一致性。
3. **构造函数本体上移（Pull Up Constructor Body）**：
- 将子类构造函数中的共同行为移到超类构造函数中。
- 简化构造函数逻辑。
4. **函数下移（Push Down Method）**：
- 将超类中特定子类才需要的方法移动到具体的子类中。
- 避免超类中包含不必要的方法。
5. **字段下移（Push Down Field）**：
- 将超类中特定子类才需要的字段移动到具体的子类中。
- 保持类的职责单一。
6. **以子类取代类型码（Replace Type Code with Subclasses）**：
- 将类型码替换为子类，利用多态性消除条件分支。
- 提高代码灵活性和可读性。
7. **移除子类（Remove Subclass）**：
- 当子类不再有存在的必要时，将其移除并合并到超类中。
- 简化类层次结构。
8. **提炼超类（Extract Superclass）**：
- 提取多个类的共性，形成一个新的超类。
- 减少代码重复，提高代码复用性。
9. **折叠继承体系（Collapse Hierarchy）**：
- 当两个相邻的类没有明显的区别时，将它们合并成一个类。
- 简化继承结构。
10. **以委托取代子类（Replace Subclass with Delegate）**：
- 当子类实现过于复杂时，使用委托模式来替代继承。
- 降低类之间的耦合度。
11. **以委托取代超类（Replace Superclass with Delegate）**：
- 当超类实现过于复杂时，使用委托模式来替代继承。
- 提高代码的灵活性。
三、阅读笔记
1. **函数上移（Pull Up Method）**：
- 适用场景：子类中有相同或相似的方法。
- 示例：
```java
public class Employee {
protected String name;
}
public class Manager extends Employee {
public void printDetails() {
System.out.println("Manager: " + name);
}
}
public class Developer extends Employee {
public void printDetails() {
System.out.println("Developer: " + name);
}
}
// 重构后
public class Employee {
protected String name;
public void printDetails() {
System.out.println("Employee: " + name);
}
}
public class Manager extends Employee {}
public class Developer extends Employee {}
```
2. **字段上移（Pull Up Field）**：
- 适用场景：子类中有相同或相似的字段。
- 示例：
```java
public class Manager {
protected String department;
}
public class Developer {
protected String department;
}
// 重构后
public class Employee {
protected String department;
}
public class Manager extends Employee {}
public class Developer extends Employee {}
```
3. **构造函数本体上移（Pull Up Constructor Body）**：
- 适用场景：子类构造函数有相同的初始化逻辑。
- 示例：
```java
public class Employee {
protected String name;
public Employee(String name) {
this.name = name;
}
}
public class Manager extends Employee {
public Manager(String name) {
super(name);
}
}
public class Developer extends Employee {
public Developer(String name) {
super(name);
}
}
```
4. **函数下移（Push Down Method）**：
- 适用场景：超类中有方法只适用于某些子类。
- 示例：
```java
public class Employee {
public void manageTeam() {
// 仅经理使用
}
}
public class Manager extends Employee {
@Override
public void manageTeam() {
// 具体实现
}
}
public class Developer extends Employee {}
// 重构后
public class Employee {}
public class Manager extends Employee {
public void manageTeam() {
// 具体实现
}
}
public class Developer extends Employee {}
```
5. **字段下移（Push Down Field）**：
- 适用场景：超类中有字段只适用于某些子类。
- 示例：
```java
public class Employee {
protected String team;
}
public class Manager extends Employee {}
public class Developer extends Employee {}
// 重构后
public class Employee {}
public class Manager extends Employee {
protected String team;
}
public class Developer extends Employee {}
```
6. **以子类取代类型码（Replace Type Code with Subclasses）**：
- 适用场景：类中使用类型码来区分不同行为。
- 示例：
```java
public class Employee {
private int type;
public static final int MANAGER = 0;
public static final int DEVELOPER = 1;
public void work() {
if (type == MANAGER) {
manageTeam();
} else if (type == DEVELOPER) {
writeCode();
}
}
}
// 重构后
public abstract class Employee {
public abstract void work();
}
public class Manager extends Employee {
@Override
public void work() {
manageTeam();
}
}
public class Developer extends Employee {
@Override
public void work() {
writeCode();
}
}
```
7. **移除子类（Remove Subclass）**：
- 适用场景：子类没有存在的必要。
- 示例：
```java
public class Employee {
public void performDuties() {
// 统一处理逻辑
}
}
public class Manager extends Employee {}
public class Developer extends Employee {}
// 重构后
public class Employee {
public void performDuties() {
// 统一处理逻辑
}
}
```
8. **提炼超类（Extract Superclass）**：
- 适用场景：多个类有共性，可以提取超类。
- 示例：
```java
public class Manager {
protected String name;
}
public class Developer {
protected String name;
}
// 重构后
public class Employee {
protected String name;
}
public class Manager extends Employee {}
public class Developer extends Employee {}
```
9. **折叠继承体系（Collapse Hierarchy）**：
- 适用场景：两个相邻类没有明显区别。
- 示例：
```java
public class Person {
protected String name;
}
public class Employee extends Person {
// 没有额外属性和方法
}
// 重构后
public class Employee {
protected String name;
}
```
10. **以委托取代子类（Replace Subclass with Delegate）**：
- 适用场景：子类实现复杂且冗余。
- 示例：
```java
public class Printer {
public void print() {
// 打印逻辑
}
}
public class ColorPrinter extends Printer {
@Override
public void print() {
// 彩色打印逻辑
}
}
// 重构后
public class Printer {
private PrintDelegate delegate;
public Printer(PrintDelegate delegate) {
this.delegate = delegate;
}
public void print() {
delegate.print();
}
}
public interface PrintDelegate {
void print();
}
public class ColorPrintDelegate implements PrintDelegate {
@Override
public void print() {
// 彩色打印逻辑
}
}
```
11. **以委托取代超类（Replace Superclass with Delegate）**：
- 适用场景：超类实现复杂且冗余。
- 示例：
```java
public class Printer {
public void print() {
// 打印逻辑
}
}
public class AdvancedPrinter extends Printer {
@Override
public void print() {
// 高级打印逻辑
}
}
// 重构后
public class Printer {
private PrintDelegate delegate;
public Printer(PrintDelegate delegate) {
this.delegate = delegate;
}
public void print() {
delegate.print();
}
}
public interface PrintDelegate {
void print();
}
public class AdvancedPrintDelegate implements PrintDelegate {
@Override
public void print() {
// 高级打印逻辑
}
}
```
四、阅读后感受
通过阅读第12章，我对继承关系的处理有了更深刻的理解。以下是我的一些感受：
1. **继承虽强大，但应谨慎使用**：
- 继承可以很方便地重用代码，但滥用继承会导致代码耦合度过高，难以维护。通过适当地使用重构手法，如函数上移、字段上移，可以在保持代码复用性的同时，避免过度依赖继承。
2. **灵活应用委托模式**：
- 委托模式提供了一种灵活的替代继承的方法，可以降低类之间的耦合度，提高代码的可维护性。通过重构，将复杂的继承关系替换为委托，可以使代码更易于理解和修改。
3. **重构是提高代码质量的重要手段**：
- 重构不仅仅是修复代码的一个过程，更是提高代码质量的重要手段。通过不断地重构，可以逐步优化代码结构，使其更加清晰、简洁和高效。
4. **减少代码重复，提高代码复用性**：
- 通过提炼超类、上移字段和方法，可以有效减少代码重复，提高代码的复用性。这不仅可以减少维护工作量，还可以提高代码的一致性和正确性。
5. **单一职责原则的重要性**：
- 在重构过程中，单一职责原则显得尤为重要。通过下移字段和方法，可以确保每个类只承担单一的职责，减少类的复杂性，提高代码的可读性和维护性。
总的来说，第12章提供的重构手法对优化继承关系非常有帮助。这些手法不仅可以提高代码的质量，还可以使代码更易于理解和维护。在实际开发中，逐步应用这些技巧，可以带来长期的收益。