设计模式———装饰模式
例子：成绩单报告
在面向对象的设计中，如果超过两层继承，可能就出设计问题了。这是经验总结，并非定论。继承层次越多，维护成本越多。
成绩装饰模型
增加一个抽象类和两个实现类，其中Decorator的作用是封装SchoolReort类
抽象成绩单
//抽象成绩单
public abstract class SchoolReport{
public abstract void report();
public abstract void sign(String name);
}
具体的四年级成绩
public abstract FourthGradeSchoolReport extends SchoolReport{
public void report(){
System.out.println("尊敬的XX家长");
System.out.println("成绩如下");
System.out.println("语文xx");
// ...
}
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("最高成绩是:XX");
}
public void report(){
this.reportHighScore();
super.report();
}
}
排名情况修饰
public class SortDecorator extends Decorator {
public SortDecorator(SchoolReport sr){
super(sr);
}
public void reportSort(){
System.out.println("排名情况是xx");
}
@Override
public void report(){
this.reportSort();
super.report();
}
}
查看成绩单
public class Father{
public static void main(String[] args) {
//把成绩单拿过来
SchoolReport sr;
//原装的成绩单
sr = new FourthGradeSchoolReport();
//加了最高分说明的成绩单
sr = new HighScoreDecorator(sr);
// 加了排名的说明
sr = new SortDecorator(sr);
//看成绩单
sr.report();
sr.sign("name");
}
}
装饰模式的定义
Attach additional responsibilities to an object dynamically keeping the same interface. Decorators provide a flexible alternative to subclassing for extending functionality.
动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。
装饰模式
四个角色说明
- component抽象构件
- component是一个接口或者是抽象类,就是定义我们最核心的对象,也就是最原始的对象
- 在装饰模式中,必然有一个最基本,最核心,也就是最原始的对象
- concreteComponent具体构建
- concreteComponent是最核心,最原始,最基本的接口或抽象类的实现,要装饰的就是它
- Decorator装饰角色
- 一般是一个抽象类,实现接口或者抽象方法
- 它的属性里必定有一个private变量指向Component抽象构建
- ConcreteDecorator具体装饰角色
- ConcreteDecoratorA和ConcreteDecoratorB是两个具体的装饰类,要把最原始,最基本,最核心的进行装饰
抽象构件
public abstract class Component{
//抽象的方法
public abstract void operate();
}
具体构件
public class ConcreteComponent extends Component {
// 具体实现
public void operate(){
// code to do something
System.out.println("doSomethin");
}
}
抽象装饰者
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);
}
//定义自己的修饰方法
public void method(){
//code to do something
}
public void operate(){
this.method();
super.operate();
}
}
public class ConcreteDecorator2 extends Decorator{
public ConcreteDecorator2(Component component){
super(component);
}
//定义自己的修饰方法
public void method(){
//code to do something
}
public void operate(){
this.method();
super.operate();
}
}
场景类
public class Client{
public static void main(String[] args) {
Component component = new ConcreteComponent();
// 第一次修饰
component = new ConcreteDecorator1(component);
// 第二次修饰
component = new ConcreteDecorator2(component);
//运行结果
component.operate();
}
}
装饰模式的优缺点
装饰模式的优点
- 装饰类和被装饰类可以独立发展，不会相互耦合。
- Component类无需知道Decorator类，Decorator类是从外部来扩展Component类的功能，Decorator也不用知道具体的构件
- 装饰模式是继承关系的一个替代方案
- 装饰类Decorator不管装饰多少层，返回的对象还是Component，实现的还是is-a关系
- 装饰模式可以动态地扩展一个实现类的功能，这不需要多说，装饰模式的定义就是如此
装饰模式的缺点
- 多层的装饰是比较复杂的
- 尽量减少装饰类的数量，一遍降低系统的复杂度
装饰模式的使用场景
- 需要扩展一个类的功能，或给出一个类增加附加功能
- 需要动态地给一个对象增加功能，这些功能可以再动态地撤销
- 需要为一批的兄弟类进行改装或加装功能，当然是首选装饰模式
