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，将只与特定种类雇员相关的函数和字段推到相关的子类去。