JAVA测试装饰者模式

最新推荐文章于 2025-12-22 15:57:21 发布

转载最新推荐文章于 2025-12-22 15:57:21 发布 · 53 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/assassin666/p/4793457.html

文章标签：

#java

本文对比装饰者模式和继承在增强原有功能时的优劣，并通过具体代码实例展示两者之间的区别。装饰者模式提供了一种灵活的方式，避免了通过继承带来的类数增多和耦合性增高的问题，使程序更易于扩展。

 1 package shb.java.demo;
 2 /**
 3  * 测试装饰者模式
 4  * @package :shb.java.demoJava02
 5  * @author shaobn
 6  * @Describe :
 7  * @Time: 2015-9-9 上午12:17:00
 8  */
 9 public class TestDecrator {
10 
11     /**
12      * @author shaobn
13      * @Describe :
14      * @param args
15      * @Time : 2015-9-9 上午12:16:49
16      */
17     public static void main(String[] args) {
18         // TODO Auto-generated method stub
19         CampusActivity ca = new AdvancedAct(new CampusInnerAct());
20         ca.play();
21         CampusActivity ca_2 = new AdvancedAct(new CampusOuterAct());
22         ca_2.play();
23     }
24 
25 }
26 interface CampusActivity{
27     
28     void play();
29 }
30 class CampusInnerAct implements CampusActivity{
31     public void play(){
32         System.out.println("和小伙伴去打篮球");
33     }
34 }
35 class CampusOuterAct implements CampusActivity{
36     public void play(){
37         System.out.println("和小伙伴去市中心逛街");
38     }
39 }
40 class Campus__ implements CampusActivity{
41     public void play(){
42         
43     }
44 }
45 class AdvancedAct implements CampusActivity{
46     private CampusActivity ca;
47     public AdvancedAct(CampusActivity ca){
48         this.ca = ca;
49     }
50     public void play(){
51         ca.play();
52         System.out.println("骑着电动车去打排球，开着汽车去参加唱歌");
53     }
54     
55 }

 1 package shb.java.demo;
 2 /**
 3  * 测试装饰者模式
 4  * @package :shb.java.demoJava02
 5  * @author shaobn
 6  * @Describe :
 7  * @Time: 2015-9-9 上午12:17:00
 8  */
 9 public class TestDecrator_2 {
10 
11     /**
12      * @author shaobn
13      * @Describe :
14      * @param args
15      * @Time : 2015-9-9 上午12:16:49
16      */
17     public static void main(String[] args) {
18         // TODO Auto-generated method stub
19         AdCampusInnerAct acia = new AdCampusInnerAct();
20         acia.play();
21         AdCampusOuterAct acoa = new AdCampusOuterAct();
22         acoa.play();
23     }
24 
25 }
26 interface CampusActivity{
27     
28     void play();
29 }
30 class CampusInnerAct implements CampusActivity{
31     public void play(){
32         System.out.println("和小伙伴去打篮球");
33     }
34 }
35 class AdCampusInnerAct extends CampusInnerAct{
36     public void play(){
37         super.play();
38         System.out.println("骑着电动车和小伙伴去打排球");
39     }    
40 }
41 class CampusOuterAct implements CampusActivity{
42     public void play(){
43         System.out.println("和小伙伴去市中心逛街");
44     }
45 }
46 class AdCampusOuterAct extends CampusOuterAct{
47     public void play(){
48         super.play();
49         System.out.println("开着汽车出去唱歌");
50     }
51 }
52 class Campus__{
53     public void play(){
54         
55     }
56 }
57 class AdCampus__ extends Campus__{
58     public void play(){
59         //增强功能......
60     }
61 }

第一段为使用装饰者模式，第二段为使用继承。

其实我们从两段代码可以看出，我们的目的是想让原有的功能增强，所以才衍生出更加丰富的方法，因此我们自然会想到继承。同时有一个问题也随之出现，当我们使用继承的时候，发现需要增加的类变得很多时，我们都需要重新写一个类去继承父类，从而重写方法。这样会增加很大的负担，而且耦合性很高，不易于程序的扩展。随之而来，装饰者模式到来。我们只需定义一个接口的子类，然后拿到同一个接口的引用，继而去增强属于该接口引用下的子类对象的方法即可。

两段代码比对，比较明显看出优劣。

如有错误，希望大家纠正。

不早了，睡觉了。。。。

2015-09-09

转载于:https://www.cnblogs.com/assassin666/p/4793457.html