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。 当然,你会说,既然HashSet是这样实现的,那么我们就不要复写addAll方法就行了。是的,没错。 但是这样虽然可以正常工作,但是它的正确性却依赖于这样的事实:HashSet的addll方法是在add方法上实现的。 一旦超类修改了实现细节,我们的功能就会有可能受影响。 总的来说,继承存在三个天然缺陷,这些缺陷会导致软件非常脆弱: 1) 子类如果调用了父类的方法,那么就会对父类形成依赖,一旦父类做了改动,子类就很可能不能正常工作。 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","Pop")); System.out.println(s.getAddCount()); } } 这样的实现方式,避免了上一节讲的所有问题,由于不使用继承,它不依赖于超类的实现逻辑,也不用担心超类新增新的方法对我们的影响。 而且这样写还有一个好处,这个类可以给所有实现了Set接口的类添加统计功能,而不仅仅是HashSet,还包括TreeSet等其他Set。 其实,这就是装饰模式,InstrumentedSet对Set进行了修饰,给它增加了计数属性。 总结 继承会破坏类的封装性,导致子类非常脆弱,容易受到破坏。 使用复合的方式,对超类进行修饰,使得子类更加的健壮,同时功能更加强大。 如有疑问请留言或者到本站社区交流讨论,感谢阅读,希望能帮助到大家,谢谢大家对本站的支持! (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |