4.16 优先使用Composition替代继承

使用继承可能破坏类的封装性，可能的问题包括：

1.子类必须知道父类的内部实现才能正确的进行覆盖，如以下父类：

 

public class Container {
	private List<Object> elements=new ArrayList<Object>();
	
	public boolean add(Object e){
		return elements.add(e);
	}
	
	public void addAll(Collection<Object> c){
		for(Object e:c)add(e);
	}
}

 

 

以下CounterContainer继承Container，并且可统计自从对象创建后所添加的元素的总数：

 

package com.bingo.practice.effective.four.sixteen;

import java.util.Collection;

public class CounterContainer extends Container {
	private int count;
	
	@Override
	public boolean add(Object e) {
		count++;
		return super.add(e);
	}
	
	@Override
	public void addAll(Collection<Object> c) {
		count+=c.size();
		super.addAll(c);
	}
	
	public int getCount(){
		return count;
	}
}

 

 

以下测试将失败，尽管调用CounterContainer的addAll()只添加了3个元素，但是getCount()返回的值是6。这是因为Container的addAll()内部调用了add()添加元素，进而导致CounterContainer重复计数。

 

	@Test
	public void testCount(){
		Object[] eles=new String[]{"1","2","3"};
		
		CounterContainer c=new CounterContainer();
		c.addAll(Arrays.asList(eles));
		
		Assert.assertEquals(c.getCount(), 3);
	}

 

如果要正确计数，CounterContainer的addAll()必须去掉计数运算。对于开发者来说，要正确的实现CounterContainer的计数功能，必须知道父类Container内部是如何添加元素的。因此继承破坏了类的封装

 

2.父类可能更改内部实现，导致子类实现的功能不正确。

 

如上例，如果Container的addAll()实现方式后期修改如下：

	public void addAll(Collection<Object> c){
		elements.addAll(c);
	}

 

那么CounterContainer也必须进行修改，否则计数不正确。这个问题可能导致一旦修改了父类，那么可能所有子类都必须进行相应修改

 

3.子类可能不小心覆盖了父类方法

 

如上例，如果CounterContainer增加了remove()，此时Container还未有remove()。但是在后期发布时Container也增加了remove()，此时可能导致CounterContainer功能不正常

 

可以使用Composition替代继承（即使用Wrapper，或Decoration设计模式），如下：

注：如果Container实现了功能接口，可创建一个基类实现此接口，然后所有Wrapper类继承此基类

public class ContainerWrapper {
	private Container container;
	private int count;
	
	public ContainerWrapper(Container container){
		this.container=container;
	}

	public boolean add(Object e) {
		count++;
		return container.add(e);
	}
	
	public void addAll(Collection<Object> c) {
		count+=c.size();
		container.addAll(c);
	}
	
	public int getCount(){
		return count;
	}	

 

使用Composition可能的问题包括：

1.回调方法问题，Container不能回调ContainerWrapper的方法

2.性能问题，需多创建Wrapper类对象（此问题影响较小）

 

仅在此情况下使用继承：如果每个B的确都是A的子类，那么使用继承

 

在此情况下仍然考虑使用Composition：如果父类的API具有很多缺点，那么可使用Composition提供新的API