装饰模式(Decorator)简介

╰半橙微兮° 2022-08-06 02:17 149阅读 0赞

装饰模式是第三个介绍的模式了.

这个模式没有前面两个那么好理解.,

## 一, 装饰模式(decorator)的定义.    ##

教材里是这样写的:

动态第给1个对象添加1写额外的职责(功能), 就增加的功能来讲, 装饰模式比生成子类更加灵活.

就咁睇的确很难明白. 但我们起码可以知道一下两点:

1. 装饰模式的作用是增强1个对象(类) 的功能.

2. 它比生成子类更加灵活.

本文着重讲下第2点, 包括什么是生成子类,  为什么装饰模式比它更加灵活.

## 二, 1个Hunter1(猎人)类的例子. ##

举1个很简单的例子. 1个猎人类实现1个打猎的接口.

### Huntable 接口:    ###

public interface Huntable {
    	public void hunt();
    }

### 猎人类Hunter1: ###

public class Hunter1 implements Huntable{
    	public void eat(){
    		System.out.println("eating!");
    	}
    	
    	public void hunt(){
    		System.out.println("Hunter is Hunting!");
    	}
    }

可见Hunter1这个类实现了Huntable借口.

hunt()方法里只简单重写了hunt()方法.

### 客户端代码: ###

Hunter1 h = new Hunter1();
    h.hunt();

### 输出: ###

Hunter is Hunting!

### 1个增强hunt()方法的需求: ###

好了, 现在有1个猎人, 他出去不只是打猎,  他打猎的同时还同时训练它的猎狗, 最后还会给战利品拍一张照片.

也就是需要增强hunt()方法功能.

加上

trainDog() 和 takePic()这个两个方法.

怎么实现呢?

## 三, 通过添加子类Hunter2方法来增强Hunter1 ##

### open-closed principle: ###

可能有人会觉得. 直接在Hunter1里加上两个方法trainDog () 和  takePic(),  在hunt()里调用这个两个新方法不就完事了吗.

的确, 但是这种做法修改了原有的类,  违反了"封闭-开放原则".

所谓"封闭-开发原则" 就是对修改封闭, 对扩展开放.

在项目中, 很多旧的业务类根本不会让你修改(jar包发布或者你没有权限)

所以我们应该把这个新需求当做1个扩展来处理, 而不是修改旧代码.

其中1个方法就是增加子类.

### 新增1个Hunter2 类: ###

public class Hunter2 extends Hunter1{
    	@Override
    	public void hunt(){
    		super.hunt();
    		this.trainDog();
    		this.takePic();
    	}
    	
    	//new function()
    	public void trainDog(){
    		System.out.println("Train the Dog!");
    	}
    	
    	public void takePic(){
    		System.out.println("Take a picture!");
    	}
    }

### 客户端代码: ###

Hunter2 h2 = new Hunter2();
    h2.hunt();

### UML: ###

![444127020141214130750099.png_434x385_130][]

可见, 这种方法, 只是新增了1个子类, 以及修改客户端代码, 对原来的类代码没有任何修改, 是符合"封闭-修改 原则"的.

这种修改, 增强了原来的类Hunter1 的hunt()功能, 可以说是"装饰"了原来的hunt()方法.

但是这种修改不是很灵活.

比如:   这种猎人是先打猎,再训狗,再拍照的.

如果有一种猎人喜欢先拍照再训狗了,  我们就又要增加1个Hunter1的子类了....

而装饰模式能解决问题.

## 四, 通过装饰模式来增强Hunter类. ##

### Huntable 接口 和 Hunter类: ###

首先构造两个相同的接口和类:

public interface Huntable {
    	public void hunt();
    }

public class Hunter implements Huntable {
    	public void eat(){
    		System.out.println("eating!");
    	}
    
    	@Override
    	public void hunt(){
    		System.out.println("Hunter is Hunting!");
    	}
    }

Hunter类跟上面的Hunter1类是完全一样的.

下面开始构造新的类来强化hunt()方法.

### 抽象装饰角色类   HuntOperation: ###

无论, 是训狗trainDog() 还是拍照takePic() 都是对hunt()的增强.

我们新增1个HuntOperation类,  让它继承Hunter类,  让它能重写hunt()方法.

public abstract class HuntOperation extends Hunter{
    	
    	private Hunter hunter = null;
    	
    	//setting component
    	public HuntOperation(Hunter hunter){
    		this.hunter = hunter;
    	}
    	
    	//actually execute component's hunt() method
    	@Override
    	public void hunt(){
    		if (null != hunter){
    			hunter.hunt();
    		}
    	}
    }

注意, 这个类有1个Hunter对象成员.

**在hunt()方法里, 执行的实际上是成员Hunter对象的hunt()方法.**

### 具体的装饰行为类 HuntTakePic(): ###

照相类, 就让它继承抽象行为类 HuntOperation类.

public class HuntTakePic extends HuntOperation{
    	public HuntTakePic(Hunter hunter) {
    		super(hunter);
    	}
    
    	@Override
    	public void hunt(){
    		super.hunt();
    		this.takePic();
    	}
    	
    	public void takePic(){
    		System.out.println("Taking a Picture!");
    	}
    }

可见, 它先执行性成员Hunter对象的hunt()方法, 在执行自己的照相方法.

### 具体的装饰行为类 HuntTrainDog(): ###

同样, 这个类也继承HuntOperation.

先执行Hunter对象的hunt()方法, 再执行自己的TrainDog方法.

public class HuntTrainDog extends HuntOperation{
    
    	public HuntTrainDog(Hunter hunter) {
    		super(hunter);
    		// TODO Auto-generated constructor stub
    	}
    	
    	@Override
    	public void hunt(){
    		super.hunt();
    		this.trainDog();
    	}
    	
    	public void trainDog(){
    		System.out.println("Training the dog!");
    	}
    
    }

### 客户端代码: ###

客户端代码如下:

先构建1个Hunter对象h, 然后再基于h构建HuntTakePic htp,  然后在基于htp构建HuntTrainDog 对象htd.

最后执行htd的hunt()方法.

Hunter h = new Hunter();
    		HuntTakePic htp = new HuntTakePic(h);
    		HuntTrainDog htd = new HuntTrainDog(htp);
    		
    		htd.hunt();

实际上, 就先执行Hunter对象的hunt(), 再执行HuntTakePic对象的hunt(), 最后才执行HuntTrainDog对象的hunt()

输出:

Hunter is Hunting!
    Taking a Picture!
    Training the dog!

### UML: ###

![444127020141214133723051.png_620x456_130][]

### 装饰模式的灵活性: ###

好了, 这种模式一样能增强Hunter类的hunt()

那么它到底比第一种方法灵活在哪里呢.

很简单, 假如另1类猎人想调换训狗, 和照相的顺序, 只需修改客户端的构建循序, 并需要再新增1个子类.

这就是装饰模式的灵活性.

有人会觉得, 装饰模式同样需要增加子类啊,  实际上, 假如我们为Hunter的hunt()再增加1个子行为, 例如给猎物剥皮.

那么只需要增加1个抽象行为HuntOperation的子类, 而不是Hunter的子类..

## 五, 小结 ##

其实想深一层, 装饰模式之所以叫装饰模式.

是因为装饰不能改变原有的功能的行为.

就如上面的例子,  Hunter里原来的hunt()方法没有改变,  只是增加了一些额外的功能.

所以如果需要从根本上改变Hunter里hunt()的代码, 装饰模式就不适用了,  还是建议用增加Hunter子类的方法.

[444127020141214130750099.png_434x385_130]: http://image16.poco.cn/mypoco/myphoto/20141214/13/444127020141214130750099.png?434x385_130
[444127020141214133723051.png_620x456_130]: http://image16.poco.cn/mypoco/myphoto/20141214/13/444127020141214133723051.png?620x456_130