Replace Type Code with Subclasses (以子类取代类型码)

Summary： 你有一个不可变的类型码，它会影响类的行为。以子类取代这个类型码。

                                               

动机:

  如果你面对的类型码不会影响宿主类的行为，可以使用Replace Type Code with Class来处理它们。但如果类型码会影响宿主类的行为，那么最好的办法就是借助多态来处理变化行为。

一般来说，这种情况的标志就是像switch这样的条件表达式。这种条件表达式可能有两种表现形式：switch语句或者if-then-else结构。不论哪种形式，它们都是检查类型码值，并根据不同的值执行不同的动作。这种情况下，你应该以Replace Conditional with Polymorphism进行重构，首先应该将类型码替换为可拥有多态性为的继承体系。这样的一个继承体系应该以类型码的宿主类为基类，并针对每一种类型码各建立一个子类。

为建立这样的继承体系，最简单的办法就是Replace Type Code with Subclasses：以类型码的宿主为基类，针对每种类型码建立相应的子类。

但是以下两种情况你不能那么做：（1）类型码值在对象创建之后发生了改变；（2）由于某些原因，类型码素质类已经有了子类。如果你恰好面临这两种情况之一，就需要使用Replace Type Code with State/Strategy。

Replace Type Code with Subclasses的主要作用其实是搭建一个舞台，让Replace Conditional with Polymorphism得以一展身手。如果宿主类中并没有出现条件表达式，那么Replace Type Code with Class更合适，风险也比较低。

使用Replace Type Code with Subclasses 的另一个原因就是，宿主类中出现了“只与具备特定类型码之对象相关”的特性。完成本项重构后，你可以使用Push Down Method和Push Down Field将这些特性推到合适的子类去，以彰显它们只与特定情况相关这一事实。

Replace Type Code with Subclasses的好处在于：它把“对不同行为的了解”从类用户那儿转移到了类自身。如果需要再加入新的行为变化，只需添加一个子类就行了。如果没有多态机制，就必须找到所有条件表达式，并注意修改它们。因此，如果未来还有可能加入新行为，这项重构将特别有价值。

做法:

1.使用Self Encapsulate Field将类型码自我封装起来

à如果类型码被传递给构造函数，就需要将构造函数换成工厂函数。

2.为类型码的每一个数值建立一个相应的子类。在每个子类中覆写类型码的取值函数，使其返回相应的类型码值。

à这个值被硬编码与return语句中（例如，return 1）。这看起来很肮脏，但只是权宜之计。当所有case子句都被替换后，问题就解决了。

3.每建立一个新的子类，编译并测试。

4.从超类中删掉保存类型码的字段。将类型码访问函数声明为抽象函数。

5.编译，测试。

范例：

为简单起见，我们还是使用哪个恼人又不切实际的“雇员/薪资”例子。我们以Employee表示“雇员”：

class Employee...
    private int _type;
    static final int ENGINEER = 0;
    static final int SALESMAN = 1;
    static final int MANAGER =2;
    
    Employee (int type){
        _type = type;
    }

第一步是以Self Encapsulate Field将类型码自我封装起来：

int getType(){
    return _type;
}

由于Employee构造函数接受类型码作为一个参数，所以我必须将它替换为一个工厂函数：

static Employee create (int type){
    return new Employee(type);
}
private Employee (int type){
    _type = type;
}

现在，我们可以先建立一个子类Engineer表示“工程师”。首先建立这个子类，并在其中覆写类型码取值函数：

class Engineer extends Employee{
    int getType(){
       return Employee.ENGINEER; 
   }
}

同时应该修改工厂函数，令它返回一个合适的对象：

class Employee
    static Employee create(int type){
        if(type == ENGINEER){
            return new Engineer();
        }else{
            return new Employee(type);
        }    
    }

然后，继续逐一地处理其他类型码，直到所有类型码都被替换成子类为止。此时我们就可以移除Employee中保存类型码的字段，并将getType声明为一个抽象函数。现在，工厂函数看起来像这样：

abstract int getType();

static Employee create(int type){
    switch (type){
        case ENGINEER:
          return new Engineer();
        case SALESMAN:
          return new Saleman();
        case MANAGER:
          return new Manager();  
        default:
            throw new IllegalArgumentException("Incorrect type code value");
    }
}

当然，我们总是避免使用switch语句。但这里只有一处用到switch语句，并且只用于决定创建何种对象，这样的switch语句是可以接受的。

很自然地，在建立了这些子类后，就应该使用Push Down Method和Push Down Field，将只与特定种类雇员相关的函数和字段推到相关的子类去。

转载于:https://my.oschina.net/u/134516/blog/212266