Java - 复合模式优于继承
继承是实现代码重用的方法之一,但使用不当则会导致诸多问题。
继承会破坏封装性,对一个具体类进行跨包访问级别的继承很危险。
即,子类依赖父类的实现细节。
如果父类的实现细节发生变化,子类则可能遭到破坏。
举个例子,扩展HashSet,记录HashSet实例创建以来一共进行了多少次添加元素的操作。
HashSet有两个添加元素的方法——add(E e)和addAll(Collection<? extends E> c)。
那就覆盖这两个方法,在添加操作执行前记录次数:
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;
}
}
测试一下,通过addAll方法添加3个元素:
public static void main(String[] args) {
InstrumentedHashSet<String> s = new InstrumentedHashSet<String>();
s.addAll(Arrays.asList("Snap", "Crackle", "Pop"));
System.out.println(s.getAddCount());
}
结果是: wKioL1PLrWjBf_fsAADIJ3WV64w978.jpg
导致这种结果的原因很简单。
参考AbstractCollection中的add(E e)和addAll(Collection<? extends E> c),
add(E e)中只有一段throw new UnsupportedOperationException();
而addAll(Collection<? extends E> c)的文档注释中有这么一段话:
* <p>Note that this implementation will throw an
* <tt>UnsupportedOperationException</tt> unless <tt>add</tt> is
* overridden (assuming the specified collection is non-empty).
解决这个问题的方法很简单,只需要去掉覆盖的addAll方法即可。
但这样却不能解决根本问题,即HashSet的addAll方法不保证在以后的发行版本中不发生变化。
即,子类实现依赖父类实现,父类发生变化时子类遭到破坏。
也许我们可以覆盖父类方法重新实现,虽然解决问题,但这样费力不讨好,毫无意义。
另外,父类增加或者移除方法也会对子类产生影响。
举个例子,子类扩展了某个集合类,覆盖了所有添加元素的方法,在添加元素之前对元素进行检查,让所有元素满足某个条件。
如果在后来的版本中,父类增加了新的添加元素的方法,而子类没有覆盖该方法,导致非法元素添加到集合中。
反之,也有可能出现这种情况。
即便父类的实现没有问题,但也可以因为子类实现不当而破坏父类的约束。
比如,父类恰好增加了和子类相同签名和返回类型的方法。
于是,为了应对这些情况,可以使用复合模式(composition)代替继承。
即,在一个forwarding class中增加一个private field引用现有类的实例,forwarding class中的方法对应现有类的方法。
代码如下:
import java.util.Collection;
import java.util.Iterator;
import java.util.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();
}
}
使用时直接继承forwarding class:
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;
}
}
forwarding class通过Set接口提供了相应方法。
这种设计也有其灵活性,继承只能选择Set的某个特定实现,但使用复合我们可以选择任何接口实现。
比如:
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());
}
如何从继承和复合之间做出选择?
比较抽象的说法是,只有子类和父类确实存在"is-a"关系的时候使用继承,否则使用复合。
或者比较实际点的说法是,如果TypeB只需要TypeA的部分行为,则考虑使用复合。
Java - 复合模式优于继承的更多相关文章
- Java复合优先于继承
复合优于继承 继承打破了封装性(子类依赖父类中特定功能的实现细节) 合理的使用继承的情况: 在包内使用 父类专门为继承为设计,并且有很好的文档说明,存在is-a关系 只有当子类真正是父类的子类型时,才 ...
- Effective Java 第三版——18. 组合优于继承
Tips <Effective Java, Third Edition>一书英文版已经出版,这本书的第二版想必很多人都读过,号称Java四大名著之一,不过第二版2009年出版,到现在已经将 ...
- java 装饰者模式与继承的区别
装饰者模式目标 把许多要实现的功能,加载在子类上,类的继承,显得很臃肿,装饰着模式是在不改变原有类文件和使用继承的情况下,通过创建一个包装对象动态地扩展一个对象的功能,相比生成子类更为灵活 装饰者模式 ...
- Java 设计模式_复合模式(2016-08-31)
一.什么是复合模式? 在形式上,复合模式确实是多个模式的组合,但满足了这一条并不一定是复合模式,注意它的定义: 将多个模式结合起来形成一个“框架”,以解决一般性问题 一提到“框架”,可能最容易联想到的 ...
- java设计模式----复合模式
复合模式:复合模式结合两个或以上的模式,组成一个解决方案,解决一再发生的一般性问题 要点: 1.MVC是复合模式,结合了观察者模式.策略模式和组合模式 2.模型使用观察者模式,以便观察者更新,同时保持 ...
- <代码整洁之道>、<java与模式>、<head first设计模式>读书笔记集合
一.前言 几个月前的看书笔记 ...
- Java与模式读书笔记
>设计目标:可扩展性,灵活性,可插入性. >设计原则 ● Open Closed Principle 开闭原则 对扩展开放,对修改关闭. 对面向对象的语言来说,不可以更改的是系统的抽象层, ...
- 设计模式学习--复合模式(Compound Pattern)
设计模式学习--复合模式(Compound Pattern) 概述 ——————————————————————————————————————————————————— 2013年8月4日<H ...
- Java并发编程阅读笔记-Java监视器模式示例
1.前言 书中在解释Java监视器模式的时候使用了一个车辆追踪器例子,根据不同的使用场景给出了不同的实现和优化. 2.监视器模式示例 实现一个调度车辆的"车辆追踪器",每台车使用一 ...
随机推荐
- 兼容性测试中如何切换和管理多个JDK版本
本文由作者邹珍珍授权网易云社区发布. 一.测试背景: 项目对外提供JAR包,需要测试该JAR包对不同JDK版本(1.6至1.9版本)的兼容性.下面主要介绍在兼容性测试中,JDK多版本共存时如何配置环境 ...
- dockerfile 构建tomcat
事先下载好tomcat和jdk的二进制包. 下载地址https://pan.baidu.com/s/1kWWHGEV 值得一说的是 tomcat的官方镜像 剪切了很多jdk和系统命令,所以生产环境建议 ...
- jQuery操作标签--样式、文本、属性操作, 文档处理
1.样式 2.文本 3.属性操作 全选,反选效果 4.文档处理 操作标签 一.样式操作 样式类: addClass(); // 添加指定的css类名 removeClass(); //移除指定的css ...
- java 实验4 异常
异常(实际使用直接try-catch) 1.常见系统异常 异常 异常的解释 ClassNotFoundException 未找到要装载的类 ArrayIndexOutOfBoundsException ...
- “全栈2019”Java异常第一章:什么是异常?
难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java异 ...
- 【timeisprecious】【JavaScript 】JavaScript String 对象
JavaScript>String 对象 1 .From Runnob JavaScript String 对象(概览) JavaScript String 对象(教程)
- android 开发 简单的小计算器
↑大致效果 项目构成: 随便写的,用的线性布局 activity_main.xml <?xml version="1.0" encoding="utf-8" ...
- 《快学Scala》第一章 基础
- 解决 sublime text 3 there are no packages available for installation 错误
重装win7 系统后,使用sublime text 3 出现下面的错误提示: 经过摸索,解决方案如下: 第一种方法: 是因为 ipv6 的问题,导致无法访问 sublime 官网,解决方法: 在 ho ...
- Nginx采用yum安装-Carr
(1)使用yum安装nginx需要包括Nginx的库,安装Nginx的库 #rpm -Uvh http://nginx.org/packages/centos/7/noarch/RPMS/nginx- ...