码迷,mamicode.com
首页 > 其他好文 > 详细

设计模式--结构型模式--装饰模式

时间:2016-04-20 20:11:28      阅读:219      评论:0      收藏:0      [点我收藏+]

标签:

装饰者模式:
我们可以通过继承和组合的方式来给一个对象添加行为,虽然使用继承能够很好拥有父类的行为,但是它存在几个缺陷:
一、对象之间的关系复杂的话,系统变得复杂不利于维护。
二、容易产生“类爆炸”现象。
三、是静态的。在这里我们可以通过使用装饰者模式来解决这个问题。
 
装饰者模式,动态地将责任附加到对象上。若要扩展功能,装饰者提供了比继承更加有弹性的替代方案。虽然装饰者模式能够动态将责任附加到对象上,但是他会产生许多的细小对象,增加了系统的复杂度。
 
uml类图如下:
技术分享
 
 装饰者Decorator与被装饰者ConcreteComponent拥有共同的超类Component,继承的目的是继承类型,而不是行为
 

参与者:

Component: 抽象构件。被装饰抽象类,是定义一个对象接口,可以给这些对象动态地添加职责。

ConcreteComponent:具体构件。被装饰具体类,是定义了一个具体的对象,也可以给这个对象添加一些职责。

Decorator: 抽象装饰类。是装饰抽象类,继承了Component,从外类来扩展Component类的功能,但对于Component来说,是无需知道Decorator存在的。

ConcreteDecorator:具体装饰类,起到给Component添加职责的功能。

代码示例:

person:被装饰的接口类,

person:具体的被装饰者,继承自Person

Decorator:装饰的抽象类,实现了被装饰者--person的接口。

Decorator_zero,Decorator_first,Decorator_two:具体的装饰类,继承自Decorator.

技术分享
  1 //定义被装饰者  
  2 public interface Human {  
  3     public void wearClothes();  
  4   
  5     public void walkToWhere();  
  6 }  
  7   
  8 //定义装饰者  
  9 public abstract class Decorator implements Human {  
 10     private Human human;  
 11   
 12     public Decorator(Human human) {  
 13         this.human = human;  
 14     }  
 15   
 16     public void wearClothes() {  
 17         human.wearClothes();  
 18     }  
 19   
 20     public void walkToWhere() {  
 21         human.walkToWhere();  
 22     }  
 23 }  
 24   
 25 //下面定义三种装饰,这是第一个,第二个第三个功能依次细化,即装饰者的功能越来越多  
 26 public class Decorator_zero extends Decorator {  
 27   
 28     public Decorator_zero(Human human) {  
 29         super(human);  
 30     }  
 31   
 32     public void goHome() {  
 33         System.out.println("进房子。。");  
 34     }  
 35   
 36     public void findMap() {  
 37         System.out.println("书房找找Map。。");  
 38     }  
 39   
 40     @Override  
 41     public void wearClothes() {  
 42         // TODO Auto-generated method stub  
 43         super.wearClothes();  
 44         goHome();  
 45     }  
 46   
 47     @Override  
 48     public void walkToWhere() {  
 49         // TODO Auto-generated method stub  
 50         super.walkToWhere();  
 51         findMap();  
 52     }  
 53 }  
 54   
 55 public class Decorator_first extends Decorator {  
 56   
 57     public Decorator_first(Human human) {  
 58         super(human);  
 59     }  
 60   
 61     public void goClothespress() {  
 62         System.out.println("去衣柜找找看。。");  
 63     }  
 64   
 65     public void findPlaceOnMap() {  
 66         System.out.println("在Map上找找。。");  
 67     }  
 68   
 69     @Override  
 70     public void wearClothes() {  
 71         // TODO Auto-generated method stub  
 72         super.wearClothes();  
 73         goClothespress();  
 74     }  
 75   
 76     @Override  
 77     public void walkToWhere() {  
 78         // TODO Auto-generated method stub  
 79         super.walkToWhere();  
 80         findPlaceOnMap();  
 81     }  
 82 }  
 83   
 84 public class Decorator_two extends Decorator {  
 85   
 86     public Decorator_two(Human human) {  
 87         super(human);  
 88     }  
 89   
 90     public void findClothes() {  
 91         System.out.println("找到一件D&G。。");  
 92     }  
 93   
 94     public void findTheTarget() {  
 95         System.out.println("在Map上找到神秘花园和城堡。。");  
 96     }  
 97   
 98     @Override  
 99     public void wearClothes() {  
100         // TODO Auto-generated method stub  
101         super.wearClothes();  
102         findClothes();  
103     }  
104   
105     @Override  
106     public void walkToWhere() {  
107         // TODO Auto-generated method stub  
108         super.walkToWhere();  
109         findTheTarget();  
110     }  
111 }  
112   
113 //定义被装饰者,被装饰者初始状态有些自己的装饰  
114 public class Person implements Human {  
115   
116     @Override  
117     public void wearClothes() {  
118         // TODO Auto-generated method stub  
119         System.out.println("穿什么呢。。");  
120     }  
121   
122     @Override  
123     public void walkToWhere() {  
124         // TODO Auto-generated method stub  
125         System.out.println("去哪里呢。。");  
126     }  
127 }  
128 //测试类,看一下你就会发现,跟java的I/O操作有多么相似  
129 public class Test {  
130     public static void main(String[] args) {  
131         Human person = new Person();  
132         Decorator decorator = new Decorator_two(new Decorator_first(  
133                 new Decorator_zero(person)));  
134         decorator.wearClothes();  
135         decorator.walkToWhere();  
136     }  
137 }
View Code

结果:

技术分享

至于执行顺序,需要仔细的研究一下他们的调用关系。

每一个装饰类,zero,first,two都对wearclothes和findmap进行封装,(拿wearclothes举例)首先都是调用super.wearclothes.而这三个装饰者都继承自Decorator,即调用decorator的wearclothes,decorator的构造函数接收一个human对象person,Decorator自身的wearclothes调用构造参数person的wearclothes.因此最内层的_zero调用的wearclothes中的super.wearclothes是person.wearclothes.

即从内到外。

_zero--->person.wearclothes();//穿什么呢        gohome();//进房子

_first--->_zero.wearclothes();//。。。        goClothespress();//去衣柜找找看

_two--->_first.wearclothes();//...            findClothes();//找到一件d&g

 

finmap的调用和上述过程类似。

关键点:
1、Decorator抽象类中,持有Human接口,方法全部委托给该接口调用,目的是交给该接口的实现类即子类进行调用。
2、Decorator抽象类的子类(具体装饰者),里面都有一个构造方法调用super(human),这一句就体现了抽象类依赖于子类实现即抽象依赖 于实现的原则。因为构造里面参数都是Human接口,只要是该Human的实现类都可以传递进去,即表现出Decorator dt = new Decorator_second(new Decorator_first(new Decorator_zero(human)));这种结构的样子。所以当调用dt.wearClothes();dt.walkToWhere()的时 候,又因为每个具体装饰者类中,都先调用super.wearClothes和super.walkToWhere()方法,而该super已经由构造传 递并指向了具体的某一个装饰者类(这个可以根据需要调换顺序),那么调用的即为装饰类的方法,然后才调用自身的装饰方法,即表现出一种装饰、链式的类似于 过滤的行为。
3、具体被装饰者类,可以定义初始的状态或者初始的自己的装饰,后面的装饰行为都在此基础上一步一步进行点缀、装饰。
4、装饰者模式的设计原则为:对扩展开放、对修改关闭,这句话体现在我如果想扩展被装饰者类的行为,无须修改装饰者抽象类,只需继承装饰者抽象类,实现额 外的一些装饰或者叫行为即可对被装饰者进行包装。所以:扩展体现在继承、修改体现在子类中,而不是具体的抽象类,这充分体现了依赖倒置原则,这是自己理解 的装饰者模式。

第2个例子:

然后再以汉堡包,鸡腿堡,生菜,辣椒,酱。。等等举例:

  汉堡包--同上一个例子中的human--被装饰者的抽象基类接口

 1 package decorator;    
 2     
 3 public abstract class Humburger {    
 4         
 5     protected  String name ;    
 6         
 7     public String getName(){    
 8         return name;    
 9     }    
10         
11     public abstract double getPrice();    
12     
13 }   

 

 鸡腿堡--同person--具体的被装饰者类

 1     package decorator;    
 2         
 3     public class ChickenBurger extends Humburger {    
 4             
 5         public ChickenBurger(){    
 6             name = "鸡腿堡";    
 7         }    
 8         
 9         @Override    
10         public double getPrice() {    
11             return 10;    
12         }    
13         
14     }    

 

 配料的基类(装饰者,用来对汉堡进行多层装饰,每层装饰增加一些配料,相当于上面Decorator)

1 package decorator;    
2     
3 public abstract class Condiment extends Humburger {    
4         
5     public abstract String getName();    
6     
7 } 

 

 

 生菜(装饰者的第一层,相当于上面的decorator_zero)

 1     package decorator;    
 2         
 3     public class Lettuce extends Condiment {    
 4             
 5         Humburger humburger;    
 6             
 7         public Lettuce(Humburger humburger){    
 8             this.humburger = humburger;    
 9         }    
10         
11         @Override    
12         public String getName() {    
13             return humburger.getName()+" 加生菜";    
14         }    
15         
16         @Override    
17         public double getPrice() {    
18             return humburger.getPrice()+1.5;    
19         }    
20         
21     }    

 

 

 辣椒(装饰者的第二层,相当于上面的decorator_first)

 1 package decorator;    
 2     
 3 public class Chilli extends Condiment {    
 4         
 5     Humburger humburger;    
 6         
 7     public Chilli(Humburger humburger){    
 8         this.humburger = humburger;    
 9             
10     }    
11     
12     @Override    
13     public String getName() {    
14         return humburger.getName()+" 加辣椒";    
15     }    
16     
17     @Override    
18     public double getPrice() {    
19         return humburger.getPrice();  //辣椒是免费的哦    
20     }    
21     
22 }  

 

 
测试类:
 1     package decorator;    
 2         
 3     public class Test {    
 4         
 5         /**  
 6          * @param args  
 7          */    
 8         public static void main(String[] args) {    
 9             Humburger humburger = new ChickenBurger();    
10             System.out.println(humburger.getName()+"  价钱:"+humburger.getPrice());    
11             Lettuce lettuce = new Lettuce(humburger);    
12             System.out.println(lettuce.getName()+"  价钱:"+lettuce.getPrice());    
13             Chilli chilli = new Chilli(humburger);    
14             System.out.println(chilli.getName()+"  价钱:"+chilli.getPrice());    
15             Chilli chilli2 = new Chilli(lettuce);    
16             System.out.println(chilli2.getName()+"  价钱:"+chilli2.getPrice());    
17         }    
18         
19     }    

 结果:

鸡腿堡  价钱:10.0    
鸡腿堡 加生菜  价钱:11.5    
鸡腿堡 加辣椒  价钱:10.0    
鸡腿堡 加生菜 加辣椒  价钱:11.5  

 

 
 
文章参考:
http://blog.csdn.net/jason0539/article/details/22713711
http://www.cnblogs.com/chenssy/p/3357683.html
 
 
 
 

设计模式--结构型模式--装饰模式

标签:

原文地址:http://www.cnblogs.com/xfvipp/p/5413951.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!