java 中復合機制的實例詳解

更新時間：2017年09月08日 14:33:15 投稿：lqh

這篇文章主要介紹了java 中復合機制的實例詳解的相關資料,希望通過本文大家能了解繼承和復合的區(qū)別并應用復合這種機制，需要的朋友可以參考下

java 中復合機制的實例詳解

繼承的缺陷

繼承的缺陷是由它過于強大的功能所導致的。繼承使得子類依賴于超類的實現(xiàn)，從這一點來說，就不符合封裝的原則。
一旦超類隨著版本的發(fā)布而有所變化，子類就有可能遭到破壞，即使它的代碼完全沒有改變。

為了說明的更加具體，假設我們現(xiàn)在程序中使用到了HashSet，我們需要增加一個功能，去統(tǒng)計這個HashSet自創(chuàng)建以來一共曾經(jīng)添加過多少元素。

在還不知道繼承的缺陷的情況下，我們設計了一個類，繼承了HashSet，添加了一個屬性addCount來進行統(tǒng)計，并且復寫了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; 
  } 
 
}

這個類看起了合情合理，但是它并不能正常工作，執(zhí)行這段代碼：

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內(nèi)部，addAll方法是基于add方法來實現(xiàn)的，因此，使用addAll添加三個元素，會調用一次addAll，三次add。
再看看我們復寫的方法，也就明白為什么getAddCount返回6了。

當然，你會說，既然HashSet是這樣實現(xiàn)的，那么我們就不要復寫addAll方法就行了。是的，沒錯。

但是這樣雖然可以正常工作，但是它的正確性卻依賴于這樣的事實：HashSet的addll方法是在add方法上實現(xiàn)的。

一旦超類修改了實現(xiàn)細節(jié)，我們的功能就會有可能受影響。

總的來說，繼承存在三個天然缺陷，這些缺陷會導致軟件非常脆弱：

1）子類如果調用了父類的方法，那么就會對父類形成依賴，一旦父類做了改動，子類就很可能不能正常工作。
2）如果父類新增了方法，而子類恰好已經(jīng)提供了一個簽名相同但是返回值不同的方法，那么子類將無法通過編譯。
3）在不應該繼承的時候使用繼承，會暴露不必要的API給子類。這一點，Java平臺就犯過錯，典型的例子就是Properties繼承了HashTable，這是不合理的，屬性列表不是散列表，但是Java代碼里的Properties卻繼承了HashTable，導致用戶創(chuàng)建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 { 
     
  } 
}

復合繼承的替代方案

上一節(jié)講了繼承的缺陷，這一節(jié)就讓我們來看看解決這個問題的方案——復合。

首先我們需要一個持有Set對象的一個類，這個類實現(xiàn)了Set接口，實現(xiàn)方法里調用了所持有的Set對象的對應的方法，因此我們也叫它轉發(fā)類：

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(); } 
}

接著，我們就可以設計具有統(tǒng)計功能的類了，只需要去繼承我們剛剛創(chuàng)建的轉發(fā)類，然后統(tǒng)計的邏輯代碼的編寫即可：

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()); 
  } 
}

這樣的實現(xiàn)方式，避免了上一節(jié)講的所有問題，由于不使用繼承，它不依賴于超類的實現(xiàn)邏輯，也不用擔心超類新增新的方法對我們的影響。

而且這樣寫還有一個好處，這個類可以給所有實現(xiàn)了Set接口的類添加統(tǒng)計功能，而不僅僅是HashSet，還包括TreeSet等其他Set。

其實，這就是裝飾模式，InstrumentedSet對Set進行了修飾，給它增加了計數(shù)屬性。

總結

繼承會破壞類的封裝性，導致子類非常脆弱，容易受到破壞。

使用復合的方式，對超類進行修飾，使得子類更加的健壯，同時功能更加強大。

如有疑問請留言或者到本站社區(qū)交流討論，感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！

您可能感興趣的文章: