设计模式之五装饰模式

概念

装饰模式能够实现动态的为对象添加功能，是从一个对象外部来给对象添加功能。通常给对象添加功能，要么直接修改对象添加相应的功能，要么派生对应的子类来扩展，抑或是使用对象组合的方式。显然，直接修改对应的类这种方式并不可取。在面向对象的设计中，而我们也应该尽量使用对象组合，而不是对象继承来扩展和复用功能。装饰器模式就是基于对象组合的方式，可以很灵活的给对象添加所需要的功能。装饰器模式的本质就是动态组合。动态是手段，组合才是目的。总之，装饰模式是通过把复杂的功能简单化，分散化，然后再运行期间，根据需要来动态组合的这样一个模式。

装饰模式(Decorator Pattern)是指在不改变原有对象的基础上，将功能附加到对象上，提供了比继承更有弹性的方案(扩展原有对象的功能)，属于结构型模式。装饰模式在生活中的应用也比较多，如给煎饼加鸡蛋、给蛋糕加一些水果、给房子装修等。都是在为对象扩展一些额外的职责。装饰模式适用于以下场景:
①扩展一个类的功能或给一个类添加附加职责
②动态给一个对象添加功能，这些功能可以再动态的撤销。

组成

装饰器模式由组件和装饰者组成。

抽象组件（Component）：需要装饰的抽象对象。
具体组件（ConcreteComponent）：是我们需要装饰的对象
抽象装饰类（Decorator）：内含指向抽象组件的引用及装饰者共有的方法。
具体装饰类（ConcreteDecorator）：被装饰的对象。

案例一

假设我们现在去咖啡店要了一杯咖啡，可以加奶、加糖等等。咖啡和奶、糖分别有不同的价格。
咖啡就是我们的组件，奶和糖是我们的装饰者，现在我们要计算调制这样一杯咖啡花费多少。

Drink 接口类：

public interface Drink {
    public float cost();
    public String getDescription();
}

Coffee 类：

public class Coffee implements Drink {
    final private String description = "coffee";
    //每杯 coffee 售价 10 元
    public float cost() {
        return 10;
    }

    public String getDescription() {
        return description;
    }
}

CondimentDecorator 调味抽象类：装饰器父类

public abstract class CondimentDecorator implements Drink {
    protected Drink decoratorDrink;

    public CondimentDecorator(Drink decoratorDrink) {
        this.decoratorDrink = decoratorDrink;
    }

    public float cost() {
        return decoratorDrink.cost();
    }

    public String getDescription() {
        return decoratorDrink.getDescription();
    }
}

Milk 牛奶装饰类：具体装饰类

public class Milk extends CondimentDecorator {
    public Milk(Drink decoratorDrink) {
        super(decoratorDrink);
    }

    @Override
    public float cost() {
        return super.cost() + 2;
    }

    @Override
    public String getDescription() {
        return super.getDescription() + " milk";
    }
}

Sugar 装饰类：具体装饰类

public class Sugar extends CondimentDecorator {
    public Sugar(Drink decoratorDrink) {
        super(decoratorDrink);
    }

    @Override
    public float cost() {
        return super.cost() + 1;
    }

    @Override
    public String getDescription() {
        return super.getDescription() + " sugar";
    }
}

测试代码：

public class CoffeeShop {
    public static void main(String[] args) {
        //点一杯coffee
        Drink drink = new Coffee();
        System.out.println(drink.getDescription() + ":" + drink.cost());
        //加一份奶
        drink = new Milk(drink);
        System.out.println(drink.getDescription() + ":" + drink.cost());
        //加一份糖
        drink = new Sugar(drink);
        System.out.println(drink.getDescription() + ":" + drink.cost());
        //再加一份糖
        drink = new Sugar(drink);
        System.out.println(drink.getDescription() + ":" + drink.cost());
    }
}

案例二

package com.hanker.net;

//抽象组件
interface Person{
	void desc();//描述信息
}
class Kobe implements Person{
	public void desc() {
		System.out.println("kobe是一个篮球远动员");
	}
}
//装饰器
class PersonDecorator implements Person{
	//持有被装饰类，以公共接口接收
	private Person person;
	public PersonDecorator(Person person) {
		this.person = person;
	}
	@Override
	public void desc() {
		person.desc();
	}
}
//装饰器： 高人
class HighPerson extends PersonDecorator{

	public HighPerson(Person person) {
		super(person);
	}
	@Override
	public void desc() {
		super.desc();
		System.out.println("是一个高人");
	}
}
class RichPerson extends PersonDecorator{

	public RichPerson(Person person) {
		super(person);
	}
	@Override
	public void desc() {
		super.desc();
		System.out.println("140亿财富被瓜分....");
	}
}
class PrettyPerson extends PersonDecorator{

	public PrettyPerson(Person person) {
		super(person);
	}
	@Override
	public void desc() {
		super.desc();
		System.out.println("是一个帅哥....");
	}
	
}
public class DecorationPattern {

	public static void main(String[] args) {
		System.out.println("被装饰类(kobe)###########");
		Person person  = new Kobe();
		person.desc();
		System.out.println("用身高来装饰被装饰对象######");
		person = new HighPerson(new Kobe());
		person.desc();
		System.out.println("多次装饰......");
		//BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		person = new PrettyPerson(new RichPerson(new HighPerson(new Kobe())));
		person.desc();
	}
}

类图:

适用场景

• 扩展一个类的功能。
• 动态增加功能，动态撤销。

优缺点：

优点：

• 装饰类和被装饰类可以独立发展，不会相互耦合
• 动态的将责任附加到对象身上。

缺点：

• 多层装饰比较复杂。