设计模式学习--装饰者模式（Decorator Pattern)
设计模式学习--装饰者模式（Decorator Pattern)
2013年5月19日 天气：阴天下雨
不停脚步继续学习设计模式
小巫在呐喊：啊、啊、啊、啊、啊
什么是装饰者模式？
其实我们用Java I/O的时候已经用到过了，只是可能不知道这就是设计模式，在后面有一个设计自己的装饰者模式，再介绍吧。
HeadFirst这样定义：动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。
新的设计原则
对扩展开发，对修改关闭
写一写要点
1. 继承属于扩展形式之一，但不见得达到弹性设计的最佳方式。
2. 在我们的设计中，应该允许行为可以被扩展，而无须修改现有的代码。
3. 组合和委托可用于在运行时动态加上新的行为。
4. 除了继承，装饰者模式也可以让我们扩展行为。
5. 装饰者模式意味着一群装饰者类，这些类用来包装具体组件。
6. 装饰者类反映出被装饰的组件类型（事实上，他们具有相同的类型，都经过接口或继承实现）
7. 装饰者可以在被装饰者的行为与/或后面加上自己的行为，甚至将被装饰者的行为整个取代掉，而达到特定的目的。
8. 你可以用无数个装饰者包装一个组件。
9. 装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型。
10. 装饰者会导致设计中出现许多的小对象，如果过度使用，会让程序变得很复杂。
装饰者模式例子：星巴兹咖啡
怎么开始？
写下星巴兹的代码：
package decoratorPattern;
/**
* 2013/5/19
* @author wwj
* 饮料抽象类
*/
public abstract class Beverage {
String description = "Unknown Beverage"; //饮料描述
public String getDescription() { //得到饮料描述
return description;
}
public abstract double cost(); //抽象方法，用于计算饮料价格
}
package decoratorPattern;
/**
* 2013/5/19
* @author wwj
* 调料抽象类：代表装饰者
*/
public abstract class CondimentDecorator extends Beverage {
@Override
public double cost() {
return 0;
}
/**
* 所有的调料装饰者都必须重新实现getDescription()方法。
*/
public abstract String getDescription();
}
写饮料的代码：
这里有四种：Epresso、HouseBlend、DarkRoast、Decat
package decoratorPattern;
/**
* 2013/5/19
* @author wwj
* 浓缩咖啡，一种饮料
*/
public class Espresso extends Beverage {
public Espresso() {
description = "Espresso";
}
@Override
public double cost() {
return 1.99;
}
}
package decoratorPattern;
/**
* 2013/5/19
* @author wwj
* 综合饮料
*/
public class HouseBlend extends Beverage {
public HouseBlend(){
description = "House Blend Coffee";
}
@Override
public double cost() {
return .89;
}
}
package decoratorPattern;
/**
* 2013/5/19
* @author wwj
* 深培咖啡
*/
public class DarkRoast extends Beverage {
public DarkRoast(){
description = "DarkRoast";
}
@Override
public double cost() {
return .99;
}
}
package decoratorPattern;
/**
* 2013/5/19
* @author wwj
* 低咖啡因
*/
public class Decat extends Beverage {
public Decat(){
description = "Decat";
}
@Override
public double cost() {
return 1.05;
}
}
写调料的代码
这里有三种调料：Mocha、Soy、Whip
package decoratorPattern;
/**
* 2013/5/19
* @author wwj
* 具体装饰者：摩卡
*/
public class Mocha extends CondimentDecorator {
//定义一个实例变量记录饮料，也就是被装饰者
Beverage beverage;
/**
* 用来把被装饰者记录到实例变量中去
* @param beverage
*/
public Mocha(Beverage beverage) {
this.beverage = beverage;
}
/**
* 这里利用委托的做法，得到一个叙述，然后在其后加上附加的叙述
*/
@Override
public String getDescription() {
return beverage.getDescription() + ", Mocha";
}
/**
* 要计算Mocha饮料的价钱。首先把调用委托给被装饰对象，以计算价钱，然后再加上Mocha的价钱，得到最后结果
*/
public double cost() {
return .20 + beverage.cost();
}
}
package decoratorPattern;
/**
* 2013/5/19
* @author wwj
* 豆浆，一种配料
*/
public class Soy extends CondimentDecorator {
Beverage beverage;
public Soy(Beverage beverage) {
this.beverage = beverage;
}
@Override
public String getDescription() {
return beverage.getDescription() + ",Soy";
}
public double cost() {
return .15 + beverage.cost();
}
}
package decoratorPattern;
/**
* 2013/5/19
* @author wwj
* 奶泡，一种配料
*/
public class Whip extends CondimentDecorator {
Beverage beverage;
public Whip(Beverage beverage) {
this.beverage = beverage;
}
@Override
public String getDescription() {
return beverage.getDescription() + ",Whip";
}
public double cost() {
return .10 + beverage.cost();
}
}
现在可以供应咖啡了
package decoratorPattern;
/**
* 测试类，供应咖啡
* @author wwj
*
*/
public class StarbuzzCoffee {
public static void main(String[] args) {
//订一杯Espresso，不需要调料,打印出它的描述与价钱
Beverage beverage = new Espresso();
System.out.println(beverage.getDescription() + " $" + beverage.cost());
Beverage beverage2 = new DarkRoast();
beverage2 = new Mocha(beverage2); //用Mocha装饰它
beverage2 = new Mocha(beverage2); //用第二个Mocha装饰它
beverage2 = new Whip(beverage2); //用Whip装饰它
System.out.println(beverage2.getDescription() + " $" + beverage2.cost());
Beverage beverage3 = new HouseBlend();
beverage3 = new Soy(beverage3);
beverage3 = new Mocha(beverage3);
beverage3 = new Whip(beverage3);
System.out.println(beverage3.getDescription() + " $" + beverage3.cost());
}
}
实验结果如下：
Espresso $1.99 DarkRoast, Mocha, Mocha,Whip $1.49 House Blend Coffee,Soy, Mocha,Whip $1.34
如果觉得看得不够爽，买办HeadFirst设计模式吧，就算小巫是新手也还是觉得这本书值得一卖，图文并茂，看起来不会累。
刚开始的时候已经说过Java中使用装饰者模式的I/O
下面就扩展一下它的行为：将大写字符转换为小写字符
package javaIo;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
/*
* 编写自己的Java I/O装饰者
*/
public class LowerCaseInputStream extends FilterInputStream {
protected LowerCaseInputStream(InputStream in) {
super(in);
}
/**
* 针对字节
*/
public int read() throws IOException {
int c = super.read();
return (c == -1 ? c : Character.toLowerCase((char) c));
}
/**
* 针对字节数组
*/
public int read(byte[] b, int offset, int len) throws IOException {
int result = super.read(b, offset, len);
for(int i = offset; i < offset + result; i++) {
b[i] = (byte) Character.toLowerCase((char)b[i]);
}
return result;
}
}
package javaIo;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class InputTest {
public static void main(String[] args) throws IOException{
int c;
try {
//设置FileInputStream,先用BufferedInputStream装饰它，再用我们崭新的
//LowerCaseInputStream过滤器装饰它
InputStream in =
new LowerCaseInputStream(
new BufferedInputStream(new FileInputStream("D:/test.txt")));
while((c = in.read()) >= 0) {
System.out.print((char)c);
}
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
测试结果：
i know the decorator pattern
ok，装饰者模式就是这样子啦，搞清楚装饰者和被装饰者之间的关系，也没啥不好理解的。下一个设计模式：工厂模式，比较常用的一个模式。今天是星期日，宝贵的周末时间就要没了，可能就不会想这两天那么频繁地发表博客了，不过有空一定会继续学习的。