replace type code with class（重构）用类替换类型码

    在实际编程中，经常会遇到一些这样的问题：对于一类事物，经过会有一些不变的常量。例如：季节有春夏秋冬，方向有东西南北，状态有一二三四等等。通常的解决办法是使用类型码：也就是通常所说的类常量。

      对于这种解决方法，存在者许多问题。例如：类型不安全、错误的赋值等。可以使用【用类代替类型码】重构来解决这类问题。

      先简单介绍一下【用类代替类型码】重构：

• 使用场合：类中有数字或其他类型的类型码，这些类型码不影响类的行为。
• 解决方法：用类来替代这些类型码。

• 动机：数值码、枚举都是C语言的普通特性。通过有意义的命名使得它们变得可读，但是问题在于编译器关注的是它们底层的数值。编译器的类型检查也是根据数值而不是有意义的名称。任何以类型码作为参数的方法期望接收数字，但是它们不能强制使用有意义的类型码。从而降低了可读性，同时也将会是错误的源泉（a source of bugs）。如果使用类来替代数值码，那么编译器就会进行类型检查。

      接下来就具体介绍一下【提取方法】重构的实施过程。

1. 为类型码创建一个新类，并且这个类中持有一个与类型码匹配的字段。并为这个字段提供getter方法。同时还需要一组静态变量，这些变量包括了所有可能的新类的实例。提供一个静态方法，接收一个类型码的参数并返回一个合适的类实例。

2. 使用新类来改变原有类的实现。

3. 编译并测试。

4. 为原类中每个使用类型码的方法创建一个使用新类型的方法，并用新方法代替原方法。

5. 修改客户程序，使用新接口。

6. 每次修改客户程序后都进行编译和测试。

7. 删除使用类型码的旧方法，并且删除类型码。

8. 编译并测试。

    现在给出一个简单的重构过程来加深理解。

   

[java]  view plain copy

1. public class Person {  
2.   
3.     public static final int O = 0;  
4.     public static final int A = 1;  
5.     public static final int B = 2;  
6.     public static final int C = 3;  
7.       
8.     private int _bloodGroup;  
9.       
10.     public Person(int bloodGroup) {  
11.         _bloodGroup = bloodGroup;  
12.     }  
13.       
14.     public void setBloodGroup(int bloodGroup){  
15.         _bloodGroup = bloodGroup;  
16.     }  
17.       
18.     public int getBloodGroup(){  
19.         return _bloodGroup;  
20.     }  
21. }  

     

   首先为类型码创建一个新类BloodGroup。

   

[java]  view plain copy

1. public class BloodGroup {  
2.     public static final BloodGroup O = new BloodGroup(0);  
3.     public static final BloodGroup A = new BloodGroup(1);  
4.     public static final BloodGroup B = new BloodGroup(2);  
5.     public static final BloodGroup C = new BloodGroup(3);  
6.       
7.     private static final BloodGroup[] _values = {O,A,B,C};  
8.     private int _code;  
9.       
10.     public BloodGroup(int code) {  
11.         _code = code;  
12.     }  
13.       
14.     public int getCode(){  
15.         return _code;  
16.     }  
17.       
18.     public static BloodGroup code(int arg){  
19.         return _values[arg];  
20.     }  
21. }  

   然后用新类中的类型码替换Person类中的类型码。

   

[java]  view plain copy

1. public class Person {  
2.   
3.     public static final int O = BloodGroup.O.getCode();  
4.     public static final int A = BloodGroup.A.getCode();  
5.     public static final int B = BloodGroup.B.getCode();  
6.     public static final int C = BloodGroup.C.getCode();  
7.       
8.     private BloodGroup _bloodGroup;  
9.       
10.     public Person(int bloodGroup) {  
11.         _bloodGroup = BloodGroup.code(bloodGroup);  
12.     }  
13.       
14.     public void setBloodGroup(int bloodGroup){  
15.         _bloodGroup = BloodGroup.code(bloodGroup);  
16.     }  
17.       
18.     public int getBloodGroup(){  
19.         return _bloodGroup.getCode();  
20.     }  
21. }  

   现在需要在运行时检查BloodGroup类型，为了能够从这个变化中真正的得到好处，需要让Person类的客户程序使用BloodGroup类型来代替原有的整数类型。为Person类添加使用BloodGroup类型的构造函数和getter/setter方法。

   

[java]  view plain copy

1. public class Person {  
2.   
3.     private BloodGroup _bloodGroup;  
4.       
5.     public Person(BloodGroup bloodGroup) {  
6.         _bloodGroup = bloodGroup;  
7.     }  
8.       
9.     public void setBloodGroup(BloodGroup bloodGroup){  
10.         _bloodGroup = bloodGroup;  
11.     }  
12.       
13.     public BloodGroup getBloodGroup(){  
14.         return _bloodGroup;  
15.     }  
16. }  

   如果没有客户程序使用BloodGroup中的getCode()和code()方法，可以将其设置为private。

   

[java]  view plain copy

1. private int getCode(){  
2.     return _code;  
3. }  
4.   
5. private static BloodGroup code(int arg){  
6.     return _values[arg];  
7. }  

   重构结束！

   最后总结一下【用类替换类型码】的优缺点：

   优点：更好的避免非法赋值和比较。

   缺点：比使用不安全类型要求更多的代码。