装饰者模式 读书笔记

 package pattern; 
public class StarbuzzCoffee { 
public static void main(String args[]) { 
Beverage beverage = new Espresso(); 
System.out.println(beverage.getDescription() + "$" + beverage.cost(0.5)); 
Beverage beverage2 = new DarkRoast(); 
beverage2 = new Mocha(beverage2); 
beverage2 = new Mocha(beverage2); 
beverage2 = new Whip(beverage2); 
System.out.println(beverage2.getDescription() + "$" + beverage2.cost(0.5)); 
Beverage beverage3 = new HouseBlend(); 
beverage3.setDiscounts(true); 
beverage3.setSize(beverage.TALL); 
beverage3 = new Soy(beverage3); 
beverage3 = new Mocha(beverage3); 
beverage3 = new Whip(beverage3); 
System.out.println(beverage3.getDescription() + "$" + beverage3.cost(0.5)); 
} 
} 
abstract class Beverage { 
public static int TALL = 10; 
public static int GRANDE = 20; 
public static int VENTI = 30; 
public int size = VENTI; 
public boolean isDiscounts=false; 

public int getSize() { 
return size; 
} 
public void setSize(int insize) { 
size = insize; 
} 
String description = "Unknown Beverage"; 
public String getDescription() { 
return description; 
} 
public abstract double cost(double discounts); 
public boolean isDiscounts() { 
return isDiscounts; 
} 
public void setDiscounts(boolean isDiscounts) { 
this.isDiscounts = isDiscounts; 
} 
} 
abstract class CondimentDecorator extends Beverage { 
public abstract String getDescription(); 
} 
class Espresso extends Beverage { 
public Espresso() { 
description = "Espresso"; 
} 
public double cost(double discounts) { 
if(isDiscounts){ 
return 1.99*discounts; 
} 
return 1.99; 
} 
} 
class DarkRoast extends Beverage { 
public DarkRoast() { 
description = "DarkRoast"; 
} 
public double cost(double discounts) { 
if(isDiscounts){ 
return 0.99*discounts; 
} 
return 0.99; 
} 
} 
class HouseBlend extends Beverage { 
public HouseBlend() { 
description = "House Blend Coffee"; 
} 
public double cost(double discounts) { 
if(isDiscounts){ 
return .89*discounts; 
} 
return .89; 
} 
} 
class Mocha extends CondimentDecorator { 
Beverage beverage; 
public Mocha(Beverage beverage) { 
this.beverage = beverage; 
} 
public String getDescription() { 
return beverage.getDescription() + ",Mocha"; 
} 
public double cost(double discounts) { 
return .20 + beverage.cost(discounts); 
} 
} 
class Whip extends CondimentDecorator { 
Beverage beverage; 
public Whip(Beverage beverage) { 
this.beverage = beverage; 
} 
public String getDescription() { 
return beverage.getDescription() + ",Whip"; 
} 
public double cost(double discounts) { 
return .20 + beverage.cost(discounts); 
} 
} 
class Soy extends CondimentDecorator { 
Beverage beverage; 
public Soy(Beverage beverage) { 
this.beverage = beverage; 
} 
public int getSize() { 
return beverage.getSize(); 
} 
public String getDescription() { 
return beverage.getDescription() + ",Soy"; 
} 
public double cost(double discounts) { 
double cost = beverage.cost(discounts); 
if (getSize() == Beverage.TALL) { 
cost += .10; 
} else if (getSize() == Beverage.GRANDE) { 
cost += .15; 
} else if (getSize() == Beverage.VENTI) { 
cost += .20; 
} 
return cost; 
} 
}

 装饰着模式--动态地讲责任附加到对象上。想要扩展功能，装饰着提供有别于继承的另一种选择。

继承属于扩展形式之一，但是不见得是达到弹性设计的最佳方案。

在我们的设计中，应该允许行为可以被扩展，而无须修改现有代码。

组和合委托可用于在运行时动态地加上新的行为。

除了继承装饰着模式也可以让我们扩展行为。

装饰者模式意味着一群装饰者类，这些类用来包装具体组件。

装饰者 可以在被被装饰者的行为前面或者与后面加上自己的行为，甚至将被装饰者的行为整个替换，而达到特定的目的。

可以用无数的装饰者包装一个组件。

装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型。

装饰者会导致设计中出现很多小对象，如果过度使用，会让程序变得复杂。

装饰者模式 有点类似墙壁和染料，墙壁类似被装饰者，染料类似装饰者，我们可以给墙上涂上无穷的染料，而改变墙壁的颜色。或者类似人和衣服， 人为被装饰者 ，衣服为装饰者，衣服不停装饰人，人的外形就会改变，如果衣服有飞的功能，那么人就会飞了。