java 中复合机制的实例详解

java 中复合机制的实例详解

继承的缺陷

继承的缺陷是由它过于强大的功能所导致的。继承使得子类依赖于超类的实现，从这一点来说，就不符合封装的原则。
一旦超类随着版本的发布而有所变化，子类就有可能遭到破坏，即使它的代码完全没有改变。

为了说明的更加具体，假设我们现在程序中使用到了hashset，我们需要增加一个功能，去统计这个hashset自创建以来一共曾经添加过多少元素。

在还不知道继承的缺陷的情况下，我们设计了一个类，继承了hashset，添加了一个属性addcount来进行统计，并且复写了add和addall方法，在方法里面修改addcount的值，

代码如下：

public class instrumentedhashset<e> extends hashset<e> { 
  // the number of attempted element insertions 
  private int addcount = 0; 
 
  public instrumentedhashset() { 
  } 
 
  public instrumentedhashset(int initcap, float loadfactor) { 
    super(initcap, loadfactor); 
  } 
 
  @override public boolean add(e e) { 
    addcount++; 
    return super.add(e); 
  } 
 
  @override public boolean addall(collection<? extends e> c) { 
    addcount += c.size(); 
    return super.addall(c); 
  } 
 
  public int getaddcount() { 
    return addcount; 
  } 
 
} 

这个类看起了合情合理，但是它并不能正常工作，执行这段代码：

public static void main(string[] args) { 
  instrumentedhashset<string> s = 
    new instrumentedhashset<string>(); 
  s.addall(arrays.aslist("snap", "crackle", "pop"));   
  system.out.println(s.getaddcount()); // expect 3 but 6 
} 

因为只插入了三个元素，我们期望getaddcount方法应该返回3，然后事实却是返回6，哪里出错了？

其实，在hashset内部，addall方法是基于add方法来实现的，因此，使用addall添加三个元素，会调用一次addall，三次add。
再看看我们复写的方法，也就明白为什么getaddcount返回6了。

当然，你会说，既然hashset是这样实现的，那么我们就不要复写addall方法就行了。是的，没错。

但是这样虽然可以正常工作，但是它的正确性却依赖于这样的事实：hashset的addll方法是在add方法上实现的。

一旦超类修改了实现细节，我们的功能就会有可能受影响。

总的来说，继承存在三个天然缺陷，这些缺陷会导致软件非常脆弱：

1） 子类如果调用了父类的方法，那么就会对父类形成依赖，一旦父类做了改动，子类就很可能不能正常工作。
2） 如果父类新增了方法，而子类恰好已经提供了一个签名相同但是返回值不同的方法，那么子类将无法通过编译。
3） 在不应该继承的时候使用继承，会暴露不必要的api给子类。这一点，java平台就犯过错，典型的例子就是properties继承了hashtable，这是不合理的，属性列表不是散列表，但是java代码里的properties却继承了hashtable，导致用户创建properties实例后，有put和setproperties两个方法，有get和getproperties两个方法，而put和get方法是不应该给用户暴露的。
因为在properties里，key和value都应该是string，而hashmap可以是其他类型甚至是对象。

public class testproperty { 
  public static void main(string[] args) { 
    properties properties = new properties(); 
    properties.setproperty("aaa", "aaa"); 
    properties.put("aaa", new testpropertyobj()); 
    system.out.println(properties.getproperty("aaa")); // null 
    system.out.println(properties.get("aaa")); // com.hzy.effjava.chp3.item16.testproperty$testpropertyobj@5f4fcc96 
  } 
  static class testpropertyobj { 
     
  } 
} 

复合  继承的替代方案

上一节讲了继承的缺陷，这一节就让我们来看看解决这个问题的方案——复合。

首先我们需要一个持有set对象的一个类，这个类实现了set接口，实现方法里调用了所持有的set对象的对应的方法，因此我们也叫它转发类：

public class forwardingset<e> implements set<e> { 
  private final set<e> s; 
  public forwardingset(set<e> s) { this.s = s; } 
 
  public void clear()        { s.clear();      } 
  public boolean contains(object o) { return s.contains(o); } 
  public boolean isempty()     { return s.isempty();  } 
  public int size()         { return s.size();   } 
  public iterator<e> iterator()   { return s.iterator(); } 
  public boolean add(e e)      { return s.add(e);   } 
  public boolean remove(object o)  { return s.remove(o);  } 
  public boolean containsall(collection<?> c) 
                  { return s.containsall(c); } 
  public boolean addall(collection<? extends e> c) 
                  { return s.addall(c);   } 
  public boolean removeall(collection<?> c) 
                  { return s.removeall(c);  } 
  public boolean retainall(collection<?> c) 
                  { return s.retainall(c);  } 
  public object[] toarray()     { return s.toarray(); } 
  public <t> t[] toarray(t[] a)   { return s.toarray(a); } 
  @override public boolean equals(object o) 
                    { return s.equals(o); } 
  @override public int hashcode()  { return s.hashcode(); } 
  @override public string tostring() { return s.tostring(); } 
} 

接着，我们就可以设计具有统计功能的类了，只需要去继承我们刚刚创建的转发类，然后统计的逻辑代码的编写即可：

public class instrumentedset<e> extends forwardingset<e> { 
  private int addcount = 0; 
 
  public instrumentedset(set<e> s) { 
    super(s); 
  } 
 
  @override public boolean add(e e) { 
    addcount++; 
    return super.add(e); 
  } 
  @override public boolean addall(collection<? extends e> c) { 
    addcount += c.size(); 
    return super.addall(c); 
  } 
  public int getaddcount() { 
    return addcount; 
  } 
 
  public static void main(string[] args) { 
    instrumentedset<string> s = 
      new instrumentedset<string>(new hashset<string>()); 
    s.addall(arrays.aslist("snap", "crackle", "pop"));   
    system.out.println(s.getaddcount()); 
  } 
} 

这样的实现方式，避免了上一节讲的所有问题，由于不使用继承，它不依赖于超类的实现逻辑，也不用担心超类新增新的方法对我们的影响。

而且这样写还有一个好处，这个类可以给所有实现了set接口的类添加统计功能，而不仅仅是hashset，还包括treeset等其他set。

其实，这就是装饰模式，instrumentedset对set进行了修饰，给它增加了计数属性。

总结

继承会破坏类的封装性，导致子类非常脆弱，容易受到破坏。

使用复合的方式，对超类进行修饰，使得子类更加的健壮，同时功能更加强大。

如有疑问请留言或者到本站社区交流讨论，感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！