Decorator模式的主要思想是为一个对象已有的子类添加一些额外的职责。与生成子类相比,它更具有灵活性。
应用场景
该模式的使用场景,主要是有的时候我们不愿意定义逻辑上新的子类,因为没有新的逻辑含义上的子类概念,而只是想为一个已存在的子类附加一些职责。
1)需要扩展一个类的功能,或给一个类增加附加责任。
2)需要动态地给一个对象增加功能,这些功能可以再动态地撤销。
3)需要增加由一些基本功能的排列组合而产生的非常大量的功能,从而使继承关系变得不现实。
模式结构
模式角色:
Component
定义一个对象接口,可以给这些对象动态地添加职责。
ConcreteComponent
定义一个对象,可以给这个对象添加一些职责。
Decorator
维持一个指向Component对象的指针,并定义一个与Component接口一致的接口。
ConcreteDecorator
向组件添加职责。
Decorator将请求转发给它的Component对象,并有可能在转发请求前后执行一些附加的动作。
代码实现
1、框架代码:
/************业务接口 Component************/
public interface Component
{
void operation();
}
/************业务接口 Component************/
public class ConcreteComponent implements Component {
public void operation() {
//
}
}
/************装饰 Decorator************/
public class Decorator implements Component
{
private Component component;
public Decorator(Component component)
{
this.component = component;
}
public void operation()
{
component.operation();
}
}
/************具体Decorator************/
public class ConcreteDecorator extends Decorator
{
public ConcreteDecorator(Component component) {
super(component);
}
public void operation()
{
super.operation();
addBehavior();
}
private void addBehavior()
{
System.out.println("addBehavior");
}
}
/************运行示例************/
ConcreteDecorator concreteDecorator=new ConcreteDecorator(new ConcreteComponent());
concreteDecorator.operation();
2.实例应用
过程是这样的:
项目经理接到一个项目,项目最终要完成编码。
项目经理接到项目后,先做些前期的工作(比如需求分析、设计),然后将编码工作委派给代码工人,代码工人干完后,项目经理做项目的收尾工作。
/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-3 12:51:06
* 项目
*/
public interface Project {
/**
* 写代码
*/
void doCoding();
}
/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-3 12:52:12
* 代码工人
*/
public class Employe implements Project{
/**
* 编码
*/
public void doCoding(){
System.out.println("代码工人 在编写代码,加班编啊编啊,终于编完了!");
}
}
/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-3 12:51:26
* 项目经理
*/
public class Manager implements Project {
private Project project; //实际上存放的是代码工人对象
public Manager(Project project) {
this.project = project;
}
/**
* 编码
*/
public void doCoding() {
//项目经理开始新的工作
startNewWork();
}
/**
* 模板:定义项目经理自己的事情
*/
public void startNewWork() {
//项目经理在做早期工作
doEarlyWork();
//项目经理很牛,做完需求和设计后,直接将编码委派给代码工人干
project.doCoding();
//项目经理在做收尾工作
doEndWork();
}
/**
* 项目经理自己的事情:做早期工作
*/
public void doEarlyWork() {
}
/**
* 项目经理做收尾工作
*/
public void doEndWork() {
}
}
/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-3 13:45:18
* 具体的项目经理A
*/
public class ManagerA extends Manager{
public ManagerA(Project project) {
super(project);
}
/**
* 项目经理自己的事情:做早期工作
*/
public void doEarlyWork() {
System.out.println("项目经理A 在做需求分析");
System.out.println("项目经理A 在做架构设计");
System.out.println("项目经理A 在做详细设计");
}
}
/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-3 13:45:27
* 具体的项目经理B
*/
public class ManagerB extends Manager {
public ManagerB(Project project) {
super(project);
}
/**
* 项目经理自己的事情:做早期工作
*/
public void doEarlyWork() {
System.out.println("项目经理B 在做需求分析");
System.out.println("项目经理B 在做详细设计");
}
/**
* 项目经理做收尾工作
*/
public void doEndWork() {
System.out.println("项目经理B 在做收尾工作");
}
}
/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-3 13:03:22
* 客户端测试
*/
public class Client {
public static void main(String args[]) {
Project employe = new Employe(); //代码工人
Project managerA = new ManagerA(employe); //项目经理
Project managerB = new ManagerB(employe); //项目经理
//以经理的名义将编码完成,功劳都是经理的,实际编码的是工人
managerA.doCoding();
managerB.doCoding();
}
}
运行结果:
项目经理A 在做需求分析
项目经理A 在做架构设计
项目经理A 在做详细设计
代码工人在编写代码,加班编啊编啊,终于编完了!
项目经理B 在做需求分析
项目经理B 在做详细设计
代码工人在编写代码,加班编啊编啊,终于编完了!
项目经理B 在做收尾工作