设计模式之装饰模式

 设计模式之装饰模式

     装饰模式(Decorator Pattern)是一种比较常见的模式，其定义如下：Attach additional responsibilites to an object dynamically keeping the same interface.Decorators provide a flexible alternative to subclassing for extending functionality.(动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更加灵活)。

通用类图

四个角色

1.Component抽象构件：Component是一个接口或者是抽象类，就是定义我们最核心的对象，也就是最原始的对象；

2.ConcreteComponent具体构件：ConcreteComponent是最核心、最原始、最基本的接口或抽象类的实现，你要装饰的就是它；

3.Decorator装饰角色：一般是个抽象类，实现接口或者抽象方法，里面不一定能有抽象的方法，在其属性里必然有一个private变量指向Component抽象构件；

4.具体装饰角色：ConcreteDecoratorA和ConcreteDecoratorB是两个具体的装饰类，把最核心、最原始、最基本的东西装饰成其他东西。

注意：装饰模式中，必然有一个最基本、最核心、最原始的接口或者抽象类充当Component抽象构件。

通用代码

抽象构件

public abstract class Component {
	public abstract void operate();
}

具体构件

public class ConcreteComponent extends Component{
	@Override
	public void operate(){
		System.out.println("do something");
	}
}

抽象装饰者

public abstract class Decorator extends Component{
	private Component component=null;
	public Decorator(Component _component){
		this.component=_component;
	}
	@Override
	public void operate()
	{
		this.component.operate();
	}
}

具体装饰者

public class ConcreteDecorator1 extends Decorator{
	public ConcreteDecorator1(Component _component){
		super(_component);
	}
	private void method1(){
		System.out.println("method1 修饰");
	}
	@Override
	public void operate(){
		this.method1();
		super.operate();
	}
}

public class ConcreteDecorator2 extends Decorator{
	public ConcreteDecorator2(Component _component){
		super(_component);
	}
	private void method2(){
		System.out.println("method2 修饰");
	}
	@Override
	public void operate(){
		super.operate();
		this.method2();
	}
}

场景类

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Component component=new ConcreteComponent();
		component=new ConcreteDecorator1(component);
		component=new ConcreteDecorator2(component);
		component.operate();
	}
}

装饰模式优点

1.装饰类和被装饰类可以独立发展，而不会相互耦合。换句话说，Component类无需知道Decorator类，Decorator类是从外部扩展Component功能，而Decorator也不用知道具体的构件；

2.装饰模式是继承关系的一种替代方案。我们看Decorator类，不管装饰多少层，返回的对象还是Component，实现的还是is-a关系；

3.装饰模式可以动态的扩展一个实现的功能。

装饰模式缺点

装饰模式比较复杂。

装饰模式使用场景

1.需要扩展一个类的功能，或者给一个类增加附加功能时；

2.需要动态地给一个对象增加功能，这个功能再动态的撤销；

3.需要为一批的兄弟类进行改装或加装功能，当然是首选装饰模式。

例子：成绩单签字

抽象成绩单

public abstract class SchoolReport {
	public abstract void report();
	public abstract void sign(String name);
}

四年级成绩单

public class FouthGradeSchoolReport extends SchoolReport{
	public void report(){
		System.out.println("尊敬的***家长：");
		System.out.println("语文 62 数学 65 体育99 自然 64");
		System.out.println("家长签字：");
	}
	public void sign(String name){
		System.out.println("家长签名为："+name);
	}
}

修饰抽象类

public abstract class Decorator extends SchoolReport{
	private SchoolReport sr;
	public Decorator(SchoolReport sr){
		this.sr=sr;
	}
	public void report(){
		this.sr.report();
	}
	public void sign(String name){
		this.sr.sign(name);
	}
}

最高成绩修饰类

public class HighScoreDecorator extends Decorator{
	public HighScoreDecorator(SchoolReport sr){
		super(sr);
	}
	private void reportHighScore(){
		System.out.println("语文最高75，数学78，自然80");
	}
	@Override
	public void report(){
		this.reportHighScore();
		super.report();
	}
}

排名修饰类

public class SortDecorator extends Decorator{
	public SortDecorator(SchoolReport sr){
		super(sr);
	}
	private void reportSort(){
		System.out.println("排名38.");
	}
	@Override
	public void report(){
		super.report();
		this.reportSort();
	}
}

场景类

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SchoolReport sr;
		sr=new FouthGradeSchoolReport();
		sr=new HighScoreDecorator(sr);
		sr=new SortDecorator(sr);
		sr.report();
		sr.sign("张三");
	}
}