设计模式（四）装饰器模式

　　首先，让我们看看枪：

　　某一把枪，可以给它加上不同的组件，使它具有不同的功能。比如说ak47原来是这样：

　　给他加了刺刀之后，它有了拼刺刀的作用：

　　如果给它加上望远镜，于是有了瞄准狙击的功能：

　　如果还要添加功能，这里我们就可以用装配器模式对这个枪进行修饰。一个普通枪以及其他种类的枪都属于武器，也就是说他们都要继承一个武器类，无论是普通枪还是添加了功能的枪他们都是枪，此外，一个枪不仅可以安装望远镜，还可以同时安装刺刀。于是乎装配器模式的关系可以用下图来形容，建模工具搞了半天没搞到。

　　Gun和FunctionGun都实现了了Weapon接口，其中，FunctionGun是Gun的装饰类，一般是一个抽象类。SniperGun和KnifeGun是具体的装饰功能类。

　　首先是一个武器接口：

public interface Weapon {
	public void function();
}

　　之后是一个实现此接口的枪类：

public class Gun implements Weapon{
	@Override
	public void function() {
		System.out.println("I can shoot!");
	}
}

　　可以给枪类Gun增加功能的，实现了Weapon接口的装饰器抽象类：

public abstract class FunctionGun implements Weapon{
	public void addFunction(){
		System.out.println("add a function!");
	}
}

　　装饰器抽象类的两个具体的实现类：KnifeGun

public class KnifeGun extends FunctionGun{
	private Weapon wp;
	public KnifeGun(Weapon wp) {
		super();
		super.addFunction();
		this.wp=wp;
	}
	@Override
	public void function() {
		wp.function();
		stab();
	}
	public void stab(){//New function
		System.out.println("I can stab!");
	}
}

　　SniperGun

public class SniperGun extends FunctionGun{
	private Weapon wp;
	public SniperGun(Weapon wp) {
		super();
		super.addFunction();
		this.wp=wp;
	}
	@Override
	public void function() {
		wp.function();
		aim();
	}
	public void aim(){
		System.out.println("I can aim!");
	}
}

　　最后是测试类：

public class Test {
	public static void main(String[] args) {
		Weapon weapon = new Gun();
		weapon = new SniperGun(new KnifeGun(weapon));//先加刺刀，然后加瞄准镜
		weapon.function();
		System.out.println("--------");
		Weapon weapon2 =new Gun();
		weapon2 = new SniperGun(weapon2);//只装瞄准镜
		weapon2.function();
	}
}

　　TestResults:

add a function!
add a function!
I can shoot!
I can stab!
I can aim!
--------
add a function!
I can shoot!
I can aim!

　　接下来我们可以看看Java的IO包中一部分类的结构:

　　例如：

InputStream ins = new FileInputStream("C:\\Users\\Desktop\\classtest.txt");
ins= new BufferedInputStream(ins);
System.out.println(ins.read());
ins.close();

　　综上，我们分析，装饰器模式的好处有以下几点：1，原始实现的接口不必在后期增加功能的时候修改。2，可以动态的增加功能。3，如果想增加FileInputStream的功能，并不需要继承FileInputStream的子类实现，而是由装配器FilterInputStream实现，保持相对功能的独立性。