Go语言视频零基础入门到精通

javalearner

八、以委托取代继承

     在这文章之前本来应该有“《31天重构》七：重命名（方法、类、参数）”这篇文章的，但是由于我个人认为正确、合适地对一些变量进行命名是每位程序员都应该养成的好习惯，适当的命名对我们理解源代码很有帮助的，原作者认为这是最重要、最常用的重构手法，但是我认为这不用再赘述了，原文请点击这里。 回归本文主题，以委托取代继承是指我们常常为了一时的便利而错误地在代码中使用到了继承机制。我们知道，继承可以使得子类获得了父类的非私有方法、属性，而我们却正好是看中了这种无形中的便利而不正当地在逻辑上几乎不相关的类之间使用了继承，实质上这种为追求便利的继承是无意义的。具体请看下面的代码。 重构前：
  
   
   
     
   

     
   
  

1. 
   
2. class Sanitation {
   
3.         public String washHands() {
   
4.                 return "Cleaned ...";
   
5.         }
   
6. }
   
7. class Child extends Sanitation {
   
8.        
   
9. }

复制代码

在这里，卫生设备 Sanitation 类（假设为水龙头）具有给人们洗手的方法 washHands() ，但是 这里的 Child 类想要具有 washHands() 的方法，但是完全不可以像上面那样子去 extends Sanitation 类啊，这两个类之间完全没有一点支持继承的联系。为了打破我们这种无意义的继承，以及消除这种带来不良影响的便利，我们应该进行重构，利用委托来实现。重构第一步，先保留 extends 关系，这样便于一点点地检测我们的重构是否出错，如下：

1. 
   
2. class Sanitation {
   
3.         public String washHands() {
   
4.                 return "Cleaned ...";
   
5.         }
   
6. }
   
7. // 重构是一小步一小步进行的，先保留 extends 关系
   
8. class Child extends Sanitation{
   
9.        
   
10.         // 具有委托对象 Sanitation 的实例
    
11.         private Sanitation sanitation;
    
12.        
    
13.         public Child() {
    
14.                 // 为委托对象赋值为当前对象，
    
15.                 // 因为我们还保留了 extends 关系
    
16.                 this.sanitation = this;
    
17.         }
    
18.        
    
19.         public String washHands() {
    
20.                 // 这里使用委托获得  washHands() 方法
    
21.                 return (this.sanitation.washHands());
    
22.         }
    
23. }
    

复制代码

当我们编译发现没有错误时（这时还不能运行，会发生栈溢出！），立即将上面 Child 类中的 extends 去掉，并记得将构造函数中的 this 引用改成真正的创建一个 Sanitation 对象。重构第二步：

1. 
   
2. class Child {
   
3.        
   
4.         // 具有委托对象 Sanitation 的实例
   
5.         private Sanitation sanitation;
   
6.        
   
7.         public Child() {
   
8.                 // 删除 extends 关系
   
9.                 this.sanitation = new Sanitation();
   
10.         }
    
11.        
    
12.         public String washHands() {
    
13.                 // 这里使用委托获得  washHands() 方法
    
14.                 return (this.sanitation.washHands());
    
15.         }
    
16. }

复制代码

至此，重构成功了！这才可以运行测试了。 小结：用委托取代这种“莫名其妙”的继承关系，是比较符合逻辑的。像 Child 和 Sanitation 两个类，根本就不是一个继承树上的，原先代码结构表现出来的也是毫无意义的。此外，个人认为，《重构》这本书上对于每个重构的步骤讲得比较详细，但是《31天重构》这本书的这一篇文章中的这个例子比《重构》中的似乎更合理些，因为这里的代码是用了一个逻辑上没有继承关系的例子，就想上文。具体的请参考两本书吧。

九、提取接口（Extract Interface）
    当我们注意到在我们代码结构中超过一个类使用到另一个特殊类中的同一个方法时，此时应该将该类中的方法提取出来放到一个接口（ interface ）中，并对外提供这个接口以便被用户类访问、使用，这样有利于打破原来多个类与这个特殊类的依赖关系。这个重构手法很容易实现，更重要的是这样做有利于松耦合。 先瞧瞧重构前的代码：

1. 
   
2. class ClassRegistration {
   
3.        
   
4.         public void createCode() {
   
5.                 // create registration code
   
6.         }
   
7.        
   
8.         public void transfer() {
   
9.                 // class transfer code
   
10.         }
    
11.        
    
12.         public double getTotal() {
    
13.                 return 0.01;
    
14.         }
    
15. }
    
16. class RegistrationProcessor {
    
17.        
    
18.         public double processRegistration(ClassRegistration registration) {
    
19.                 registration.createCode();
    
20.                 return registration.getTotal();
    
21.         }
    
22. }
    

复制代码

在上面例子中，如果有多个不同的 RegistrationProcessor 类需要自主性地选择不同的注册方式，也就是说，注册 ClassRegistration 类同样有多个不同的实现方法。但是在上面的代码中， RegistrationProcessor 类很明显已经与单独一个 ClassRegistration 类紧耦合了，并不能选择性地与其他具体的实现相关联。 为了解决这种不足，我们把 ClassRegistration 类中的 create() 方法提取出来，再放到一个新的接口（ interface ）中，先看重构后的代码：

1. 
   
2. interface IRegistration {
   
3.        
   
4.         public void createCode();
   
5.        
   
6.         public double getTotal();
   
7. }
   
8. class ClassRegistration implements IRegistration {
   
9.        
   
10.         @Override
    
11.         public void createCode() {
    
12.                 // create registration code
    
13.         }
    
14.        
    
15.         public void transfer() {
    
16.                 // class transfer code
    
17.         }
    
18.        
    
19.         @Override
    
20.         public double getTotal() {
    
21.                 return 0.01;
    
22.         }
    
23. }
    
24. class RegistrationProcessor {
    
25.        
    
26.         public double processRegistration(IRegistration registration) {
    
27.                 registration.createCode();
    
28.                 return registration.getTotal();
    
29.         }
    
30. }

复制代码

重构之后， ClassRegistration 类实现了 IRegistration 接口，并实现了该接口中所声明的所有方法，在 ClassRegistration 类中用 @Override 表明了。注意，最重要的是 RegistrationProcessor 类（也就是客户类）在自己的 processRegistration() 方法中，其参数类型不再是具体的 ClassRegistration 类，而是 IRegistration 接口。如此一来，我们可以提供多个实现了 IRegistration 接口的不同实现类，然后由具体传入 processRegistration() 方法的参数来运行时确定究竟是哪种实现。 实际上，这是我们常说的“面向接口编程”，也就是运用多态机制的好处。重点在于用户类不必与具体的实现类直接依赖，而是依赖于抽象的接口。

本文出自 “蚂蚁” 博客，请务必保留此出处http://haolloyin.blog.51cto.com/1177454/347473



  
  
   
   

     
   

     
   
  

复制代码