重构研究：Replace Type Code with Subclasses(以子类取代类型码)，

 

动机：

如果你的类中有一个不可变的类型码，它会影响类的行为

如果类中有一个标志，看起来像是switch这样，或者if-else if-else if这种结构，并且以后可能还要增加其他类型的标志，就可以使用这种重构方法

做法：

1.先使用Self Encapsulate Field(自封装字段)将类型码自我封装起来，如果类型码有在构造函数里赋值，就需要将构造函数改为工厂函数来创建对象

2.为类中的每一个标志建立一个子类，在每个子类中覆写类型码的get函数，返回相应的类型码

3.从超类中删掉保存标志的字段，将超类的get函数声明为抽象函数

示例：

public class Employee {

    private static final int ENGINEER = 0;

    private static final int SALESMAN = 1;

    private int type;
    
    public Employee(int type) {
        this.type = type;
    }
    
    public int getType() {
        return this.type;
    }
}

修改后的代码为：

public abstract class Employee {

    protected static final int ENGINEER = 0;

    protected static final int SALESMAN = 1;

    protected Employee() {
    }

    public static Employee createEmployee(int type) {
        switch (type) {
        case ENGINEER: {
            return new Engineer();
        }
        case SALESMAN: {
            return new Salesman();
        }
        default: {
            throw new RuntimeException("createEmployee error");
        }
        }
    }

    protected abstract int getType();
}

public class Engineer extends Employee {

    protected Engineer() {
        super();
        // TODO Auto-generated constructor stub
    }

    @Override
    protected int getType() {
        // TODO Auto-generated method stub
        return Employee.ENGINEER;
    }
}

public class Salesman extends Employee {

    protected Salesman() {
        super();
        // TODO Auto-generated constructor stub
    }

    @Override
    protected int getType() {
        // TODO Auto-generated method stub
        return Employee.SALESMAN;
    }
}

 

这样以后想要增加一种方法就只要创建一个子类，然后修改一下父类的工厂函数就可以了，这种用于Replace Conditional with Polymorphism(用多态代替条件语句)或者用Replace Type Code with State/Strategy(用State/Strategy代替类型码)就方便了