设计模式装饰者模式(结构型)

定义

在不改变原有对象的基础之上，将功能附加到对象上。提供了比继承更有弹性的替代方案（扩展原有对象功能）。

适用场景

• 扩展一个类的功能或给一个类添加附加职责


• 动态的给一个对象添加功能，这些功能也可以动态撤销

优点

• 继承的有力补充，比继承灵活，不改变原有对象的情况下给一个对象扩展功能。


• 通过使用不同的装饰类以及这些装饰类的排列组合，可以实现不同的效果。


• 符合开闭原则。

缺点

• 会出现更多的代码和类，增加程序的复杂性。


• 动态装饰时，多层装饰时会更复杂，不易于调试。

代码以及UML类图

对于我们程序员来说，选老婆的标准一定不能低了。我们就来用装饰者模式，来一步一步装饰我们心中的女神。

首先得是一个女生（当然你要是口味不同，另说）

其次必须 貌美 肤白 大长腿

好了，说的都流口水了。来 让我们来码出来吧。

代码

抽象一个女生类

/**
* 抽象girl
*/
public abstract class AbstractGirl {
/**
* 特点
* @return
*/
protected abstract String feature();
/**
* 描述
* @return
*/
protected abstract String getDesc();
}


具体实现我们心中模糊的标准的女生

/**
* 你眼中的女神
*/
public class YourGirl extends AbstractGirl {
@Override
protected String feature() {
return "是一个女生";
}
@Override
protected String getDesc() {
return "漂亮";
}
}


抽象一个具体装饰女生的标准类

/**
* 女神的装饰抽象方法
*/
public abstract class AbstractGirlDecorate extends AbstractGirl {
//将装饰类和装饰者关联
private AbstractGirl abstractGirl;
//通过构造函数关联
public AbstractGirlDecorate(AbstractGirl abstractGirl) {
this.abstractGirl = abstractGirl;
}
@Override
protected String feature() {
return this.abstractGirl.feature();
}
/**
* 其他描述，对自己的标准
*/
protected abstract void otherThings();
@Override
protected String getDesc() {
return this.abstractGirl.getDesc();
}
}


我们通过构造方法来关联被装饰的对象，在这里我们增加了一个otherThings() 抽象方法，用来补充，比如 我们如果想要一个漂亮又腿长的女生，那么我们需要做到什么样子的标准。

具体实现装饰标准 —腿长装饰类

public class LongLegsGirlDecorate extends AbstractGirlDecorate {
public LongLegsGirlDecorate(AbstractGirl abstractGirl) {
super(abstractGirl);
}
@Override
protected String feature() {
return super.feature() + " 大长腿 ";
}
@Override
protected void otherThings() {
System.out.println("努力赚钱");
}
@Override
protected String getDesc() {
return super.getDesc() + "身高1米7";
}
}


具体实现装饰标准–肤白装饰类

public class WhiteSkinGirlDecorate extends AbstractGirlDecorate {
public WhiteSkinGirlDecorate(AbstractGirl abstractGirl) {
super(abstractGirl);
}
@Override
protected String feature() {
return super.feature() + " 皮肤白 ";
}
@Override
protected void otherThings() {
System.out.println("温柔体贴");
}
@Override
protected String getDesc() {
return super.getDesc() + " 面如凝脂 ";
}
}


做梦的开始类

public class DecoratorBootStrap {
public static void main(String[] args) {
//你心里的第一要求的女孩
AbstractGirl abstractGirl = new YourGirl();
//进一步细化一下,要求腿长
abstractGirl = new LongLegsGirlDecorate(abstractGirl);
System.out.println("想要一个腿长的女神，我们要");
((LongLegsGirlDecorate) abstractGirl).otherThings();
//既然腿长怎么可能少了肤白
abstractGirl = new WhiteSkinGirlDecorate(abstractGirl);
System.out.println("再想要腿长和肤白,我们要");
((WhiteSkinGirlDecorate) abstractGirl).otherThings();
System.out.println("你心里要求的女孩标准是" + abstractGirl.feature());
System.out.println("必须满足:" + abstractGirl.getDesc());
}
}


在这里 由于我们的抽象装饰类AbstractGirlDecorate 也继承AbstractGirl ,因此我们可以做相互转换。

UML 类图

decorator.jpg

我们可以看到 一个抽象装饰类（AbstractGirlDecorate），只装饰一个被装饰者对象（YourGirl）。

做梦的结果展示

fighting.jpg

小结

虽然代码的例子很屌丝，但是希望从众能看到装饰者这种设计模式的巧妙支持，以及他的缺点，合适的运用。