Replace Type Code With Class和Replace Type Code With Subclass和Replace Type Code With State/Strategy

　　周末闲来写写看书总结，今天写《重构》中的3个重要手法，分别是Replace Type Code With Class、Replace Type Code With Subclass和Replace Type Code With State/Strategy。

　　1、Replace Type Code With Class

　　重构前的主体代码如下：

 package nelson;

 public class Person {

     public static final int O = 0;
     public static final int A = 1;
     public static final int B = 2;
     public static final int AB = 3;

     private int _bloodGroup;

     public Person(int bloodGroup){
         _bloodGroup = bloodGroup;
     }

     public void setBloodGroup(int arg){
         _bloodGroup = arg;
     }

     public int getBloodGroup(){
         return _bloodGroup;
     }
 }

　　重构前的应用代码如下：

 package nelson;

 public class HelloJava {

     public static void main(String[] args) {

         System.out.println("Hello,Java");

         Person xiaoming = new Person(Person.A);  //小明A型血

         System.out.println("小明的血型是:"+xiaoming.getBloodGroup());
     }

 }

　　重构前的代码有什么问题呢，在Person中使用public static final修饰了几个变量，这几个变量是血型的类型值。在new对象或者setBloodGroup时可以将此作为参数传入。问题有如下：在New对象或者setBloodGroup时，可以传入其他参数，另外Person.A这样的形式不能直观反映A的含义，如果取为BloodGroup.A--血型，血型中的A型血，是不是更直接明了。

　　重构后的主体代码：

 package nelson;

 public class Person {

     private BloodGroup _bloodGroup;

     public Person(BloodGroup bloodGroup){
         _bloodGroup = bloodGroup;
     }

     public void setBloodGroup(BloodGroup arg){
         _bloodGroup = arg;
     }

     public BloodGroup getBloodGroup(){
         return _bloodGroup;
     }
 }

 class BloodGroup
 {
     public static final BloodGroup O = new BloodGroup(0);
     public static final BloodGroup A = new BloodGroup(1);
     public static final BloodGroup B = new BloodGroup(2);
     public static final BloodGroup AB = new BloodGroup(3);
     public static final BloodGroup[] _values = {O,A,B,AB};

     private final int _code;

     private BloodGroup(int code)
     {
         _code = code;
     }

     public int getCode()
     {
         return _code;
     }

     public BloodGroup getBloodGroup(int arg)
     {
         return _values[arg];
     }
 }

　　重构后的应用代码：

 package nelson;

 public class HelloJava {

     public static void main(String[] args) {

         System.out.println("Hello,Java");

         Person xiaoming = new Person(BloodGroup.A);  //小明A型血

         System.out.println("小明的血型是:"+xiaoming.getBloodGroup().getCode());
     }
 }

重构后比重构前有哪些优势呢？

new Person时需要传入BloodGroup类型参数而不再是int类型参数，这样就有参数类型检查了。参数为BloodGroup.A这样就更容易理解了。

其实以上就是用class来完成枚举enum的实现了。

　　2、Replace Type Code With Subclass

　    重构前的主体类Employee，代表员工，有3中类型（Type）。

 package nelson;

 public class Employee {

     private int _type;   //员工类型
     public static final int ENGINEER = 0;
     public static final int SALEMAN = 1;
     public static final int MANAGER = 2;

     public Employee(int type)
     {
         _type = type;
     }

     public int getType()
     {
         return _type;
     }
 }

重构前的应用代码：

 package nelson;

 import java.util.ArrayList;
 import java.util.List;

 public class HelloJava {

     public static void main(String[] args) {

         System.out.println("Hello,Java");

         Employee xiaotang = new Employee(Employee.ENGINEER);   //小唐是工程师
         Employee xiaoFang = new Employee(Employee.SALEMAN);    //小方是销售
         Employee laozhou = new Employee(Employee.MANAGER);     //老周是经理

         List<Employee> allStaffs = new ArrayList<Employee>();  //所有员工

         allStaffs.add(xiaotang);
         allStaffs.add(xiaoFang);
         allStaffs.add(laozhou);

         //为所有员工发年终奖，喜闻乐见
         System.out.println("\n为所有员工发年终奖");
         for(Employee staff : allStaffs)
         {
             switch(staff.getType())
             {
             case Employee.ENGINEER: System.out.println("多发一个月工资");break;
             case Employee.SALEMAN: System.out.println("多发1.5个月工资");break;
             case Employee.MANAGER:System.out.println("多发2个月工资");break;
             default:break;
             }
         }

         System.out.println("\n确定所有员工的春节放假时间");
         for(Employee staff : allStaffs)
         {
             switch(staff.getType())
             {
             case Employee.ENGINEER: System.out.println("休息7天");break;
             case Employee.SALEMAN: System.out.println("休息10天");break;
             case Employee.MANAGER:System.out.println("休息5天");break;
             default:break;
             }
         }
     }
 }

　　这里有什么问题呢，看起来逻辑也是很清晰的。问题在于，应用代码中需要不断地判断员工类型。也可以将发放年终奖做成一个函数定义在Employee中，如PaidAnnualBonus()，将春节休假时间做成一个函数定义在Employee中，如SpringFestivalVacationTime()，可以确定是这两个函数里依然会对员工类型做判断。

　　重构后的主体类：

 package nelson;

 public abstract class Employee {

     public static final int ENGINEER = 0;
     public static final int SALEMAN = 1;
     public static final int MANAGER = 2;

     public Employee()
     {
     }

     public static Employee Create(int type)
     {
         switch(type)
         {
         case ENGINEER: return new Engineer();
         case SALEMAN: return new Salesman();
         case MANAGER: return new Manager();
         default:throw new IllegalArgumentException("Incorrect type code value");
         }
     }

     abstract int getType();
     abstract void PaidAnnualBonus();  //发年终奖
     abstract void SpringFestivalVacationTime(); //春节放假时间
 }

 class Engineer extends Employee
 {

     public Engineer() {
         super();
     }

     public int getType()
     {
         return Employee.ENGINEER;
     }

     public void PaidAnnualBonus()
     {
         System.out.println("我是工程师，我年终奖多发一个月工资");
     }

     public void SpringFestivalVacationTime()
     {
         System.out.println("我是工程师，我春节放假7天");
     }
 }

 class Salesman extends Employee
 {

     public Salesman() {
         super();
     }

     public int getType()
     {
         return Employee.SALEMAN;
     }

     public void PaidAnnualBonus()
     {
         System.out.println("我是销售员，我年终奖多发一个半月工资");
     }

     public void SpringFestivalVacationTime()
     {
         System.out.println("我是销售员，我春节放假10天");
     }
 }

 class Manager extends Employee
 {

     public Manager() {
         super();
     }

     public int getType()
     {
         return Employee.MANAGER;
     }

     public void PaidAnnualBonus()
     {
         System.out.println("我是经理，我年终奖多发两个月工资");
     }

     public void SpringFestivalVacationTime()
     {
         System.out.println("我是经理，我春节放假5天");
     }
 }

　　重构后的应用代码：

 package nelson;

 import java.util.ArrayList;
 import java.util.List;

 public class HelloJava {

     public static void main(String[] args) {

         System.out.println("Hello,Java");

         Employee xiaotang = Employee.Create(Employee.ENGINEER);   //小唐是工程师
         Employee xiaoFang = Employee.Create(Employee.SALEMAN);    //小方是销售
         Employee laozhou = Employee.Create(Employee.MANAGER);     //老周是经理

         List<Employee> allStaffs = new ArrayList<Employee>();  //所有员工

         allStaffs.add(xiaotang);
         allStaffs.add(xiaoFang);
         allStaffs.add(laozhou);

         //为所有员工发年终奖，喜闻乐见
         System.out.println("\n为所有员工发年终奖");

         for(Employee staff : allStaffs)
         {
             staff.PaidAnnualBonus();
         }

         System.out.println("\n确定所有员工的春节放假时间");
         for(Employee staff : allStaffs)
         {
             staff.SpringFestivalVacationTime();
         }
     }
 }

　　重构后的应用代码变得很简洁，利用了Employee的Create函数，应用类根本不用知道Engineer类、Salesman类、Manager类的存在。

　　3、Replace Type Code With State/Strategy

　　关于这一点的动机，参照《重构》好好理解吧。参见下图:

　　Replace Type Code With Subclass和Replayce Type Code With State/Strategy很类似，Replace-State/Strategy更彻底，将type单独列出来作为一个类，并将它作为宿主类的一个参数，好处就是上图中介绍的，“类型吗的值在对象生命周期中发生变化”和“其他原因使得宿主类不能被继承”。这两句话比较难懂，但考虑这样一个问题就好理解了。上面的Replace-Subclass例子中，如果一个对象被定义为了工程师，现在他得到了提升变为了经理，上面的代码就很难做到。后面“其他原因使得宿主类不能被继承”这里的其他原因确实还没想好(囧)。

　　重构前的代码跟上面Replace Type Code With Subclass一样，也就是Replace Type Code With State/Strategy是Repace Type Code With Subclass的升级版。

　　重构后的主体代码如下:

 package nelson;

 public class Employee {

     EmployeeType employeeType;

     public Employee()
     {
     }

     public void setType(int arg)
     {
         employeeType = EmployeeType.Create(arg);
     }

     public void PaidAnnualBonus()
     {
         employeeType.PaidAnnualBonus();
     }

     public void SpringFestivalVacationTime()
     {
         employeeType.SpringFestivalVacationTime();
     }
 }

 abstract class EmployeeType
 {
     public static final int ENGINEER = 0;
     public static final int SALEMAN = 1;
     public static final int MANAGER = 2;

     abstract int getType();
     abstract void PaidAnnualBonus();  //发年终奖
     abstract void SpringFestivalVacationTime(); //春节放假时间

     public static EmployeeType Create(int type)
     {
         switch(type)
         {
         case ENGINEER: return new Engineer();
         case SALEMAN: return new Salesman();
         case MANAGER: return new Manager();
         default:throw new IllegalArgumentException("Incorrect type code value");
         }
     }
 }

 class Engineer extends EmployeeType
 {

     public Engineer() {
         super();
     }

     public int getType()
     {
         return EmployeeType.ENGINEER;
     }

     public void PaidAnnualBonus()
     {
             System.out.println("我是工程师，我年终奖多发一个月工资");
     }

     public void SpringFestivalVacationTime()
     {
         System.out.println("我是工程师，我春节放假7天");
     }
 }

 class Salesman extends EmployeeType
 {

     public Salesman() {
         super();
     }

     public int getType()
     {
         return EmployeeType.SALEMAN;
     }

     public void PaidAnnualBonus()
     {
             System.out.println("我是销售员，我年终奖多发一个半月工资");
     }

     public void SpringFestivalVacationTime()
     {
         System.out.println("我是销售员，我春节放假10天");
     }
 }

 class Manager extends EmployeeType
 {
     public Manager() {
         super();
     }

     public int getType()
     {
         return EmployeeType.MANAGER;
     }

     public void PaidAnnualBonus()
     {
             System.out.println("我是经理，我年终奖多发两个月工资");
     }

     public void SpringFestivalVacationTime()
     {
         System.out.println("我是经理，我春节放假5天");
     }
 }

　　重构后的应用代码如下：

 package nelson;

 import java.util.ArrayList;
 import java.util.List;

 public class HelloJava {

     public static void main(String[] args) {

         System.out.println("Hello,Java");

         Employee xiaotang = new Employee();
         xiaotang.setType(EmployeeType.ENGINEER);   //小唐是工程师
         Employee xiaoFang = new Employee();
         xiaoFang.setType(EmployeeType.SALEMAN);    //小方是销售
         Employee laozhou = new Employee();
         laozhou.setType(EmployeeType.MANAGER);     //老周是经理

         List<Employee> allStaffs = new ArrayList<Employee>();  //所有员工

         allStaffs.add(xiaotang);
         allStaffs.add(xiaoFang);
         allStaffs.add(laozhou);

         //为所有员工发年终奖，喜闻乐见
         System.out.println("\n为所有员工发年终奖");

         for(Employee staff : allStaffs)
         {
             staff.PaidAnnualBonus();
         }

         System.out.println("\n确定所有员工的春节放假时间");
         for(Employee staff : allStaffs)
         {
             staff.SpringFestivalVacationTime();
         }
     }
 }

　　重构后的好处就像上面的两条动机那样，Employee类现在就可以动态改变员工类型属性了，还有就是Employee类也可以被方便的继承而不受约束。