设计模式——装饰者模式（8）

一、定义

• 指在不改变现有对象布局的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。
  
• 我们先来看一个快餐店的例子。快餐店有炒面、炒饭这些快餐，可以额外附加鸡蛋、火腿、培根这些配菜，当然加配菜需要额外加钱，每个配菜的价钱通常不太一样，那么盘算总价就会显得比力麻烦。假如使用继承的方式存在的标题：扩展性欠好假如要再加一种配料（火腿肠），我们就会发现需要给FriedRiceFriedNoodles分别定义一个子类。假如要新增一个快餐品类（炒河粉）的话，就需要定义更多的子类。产生过多的子类
  
• 所以我们使用装饰者模式进行修饰
  
  
  
  

二、代理模式和装饰模式的区别

• 雷同点
  
  
  
  • 都要实现与目标类雷同的业务接口
    
  • 在两个类中都要声明目标对象
    
  • 都可以在不修改目标类的前提下增强目标方法
    
  
  
• 不同点
  
  
  
  • 目的不同 装饰者是为了增强目标对象 静态代理是为了掩护和隐藏目标对象
    
  • 获取目标对象构建的地方不同 装饰者是由外界传递进来，可以通过构造方法传递 静态代理
    是在代理类内部创建，以此来隐藏目标对象
    
  
  

1. public abstract class FastFood {
2.         private float price;
3.         private String desc;
4.         public FastFood() {
5.         }
6.         public FastFood(float price, String desc) {
7.         this.price = price;
8.         this.desc = desc;
9.         }
10.         public void setPrice(float price) {
11.                 this.price = price;
12.         }
13.         public float getPrice() {
14.                 return price;
15.         }
16.         public String getDesc() {
17.                 return desc;
18.         }
19.         public void setDesc(String desc) {
20.                 this.desc = desc;
21.         }
22.         public abstract float cost(); //获取价格
23.         }
24. }
25.         //炒饭
26. public class FriedRice extends FastFood {
27.         public FriedRice() {
28.                 super(10, "炒饭");
29.         }
30.         public float cost() {
31.                 return getPrice();
32.         }
33. }
34. //炒面
35. public class FriedNoodles extends FastFood {
36.         public FriedNoodles() {
37.                 super(12, "炒面");
38.         }
39.         public float cost() {
40.                 return getPrice();
41.         }
42. }
43. //配料类
44. public abstract class Garnish extends FastFood {
45.         private FastFood fastFood;
46.         public FastFood getFastFood() {
47.                 return fastFood;
48.         }
49.         public void setFastFood(FastFood fastFood) {
50.                 this.fastFood = fastFood;
51.         }
52.         public Garnish(FastFood fastFood, float price, String desc) {
53.                 super(price,desc);
54.                 this.fastFood = fastFood;
55.         }
56. }
57. //鸡蛋配料
58. public class Egg extends Garnish {
59.         public Egg(FastFood fastFood) {
60.                 super(fastFood,1,"鸡蛋");
61.         }
62.         public float cost() {
63.                 return getPrice() + getFastFood().getPrice();
64.         }
65.         @Override
66.         public String getDesc() {
67.                 return super.getDesc() + getFastFood().getDesc();
68.         }
69. }
70. //培根配料
71. public class Bacon extends Garnish {
72.         public Bacon(FastFood fastFood) {
73.                 super(fastFood,2,"培根");
74.         }
75.         @Override
76.         public float cost() {
77.                 return getPrice() + getFastFood().getPrice();
78.         }
79.         @Override
80.         public String getDesc() {
81.                 return super.getDesc() + getFastFood().getDesc();
82.         }
83. }
84. //测试类
85. public class Client {
86.         public static void main(String[] args) {
87.                 //点一份炒饭
88.                 FastFood food = new FriedRice();
89.                 //花费的价格
90.                 System.out.println(food.getDesc() + " " + food.cost() + "元");
91.                 System.out.println("========");
92.                 //点一份加鸡蛋的炒饭
93.                 FastFood food1 = new FriedRice();
94.                 food1 = new Egg(food1);
95.                 //花费的价格
96.                 System.out.println(food1.getDesc() + " " + food1.cost() + "元");
97.                 System.out.println("========");
98.                 //点一份加培根的炒面
99.                 FastFood food2 = new FriedNoodles();
100.                 food2 = new Bacon(food2);
101.                 //花费的价格
102.                 System.out.println(food2.getDesc() + " " + food2.cost() + "元");
103.         }
104. }

复制代码