JAVA设计模式初探之装饰者模式

最新推荐文章于 2023-04-14 17:00:00 发布
最新推荐文章于 2023-04-14 17:00:00 发布
阅读量292 收藏
点赞数
分类专栏： java设计模式 文章标签： Java java设计模式 继承 设计 装饰者设计模式

这个模式花费了挺长时间，开始有点难理解，其实就是

定义：动态给一个对象添加一些额外的职责,就象在墙上刷油漆.使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活。
设计初衷:通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的。

 

 要点：装饰者与被装饰者拥有共同的超类，继承的目的是继承类型，而不是行为


   实际上Java 的I/O API就是使用Decorator实现的。

 

[java] view plain copy
print ?
  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. }  
//定义被装饰者
public interface Human {
	public void wearClothes();

	public void walkToWhere();
}

//定义装饰者
public abstract class Decorator implements Human {
	private Human human;

	public Decorator(Human human) {
		this.human = human;
	}

	public void wearClothes() {
		human.wearClothes();
	}

	public void walkToWhere() {
		human.walkToWhere();
	}
}

//下面定义三种装饰，这是第一个，第二个第三个功能依次细化，即装饰者的功能越来越多
public class Decorator_zero extends Decorator {

	public Decorator_zero(Human human) {
		super(human);
	}

	public void goHome() {
		System.out.println("进房子。。");
	}

	public void findMap() {
		System.out.println("书房找找Map。。");
	}

	@Override
	public void wearClothes() {
		// TODO Auto-generated method stub
		super.wearClothes();
		goHome();
	}

	@Override
	public void walkToWhere() {
		// TODO Auto-generated method stub
		super.walkToWhere();
		findMap();
	}
}

public class Decorator_first extends Decorator {

	public Decorator_first(Human human) {
		super(human);
	}

	public void goClothespress() {
		System.out.println("去衣柜找找看。。");
	}

	public void findPlaceOnMap() {
		System.out.println("在Map上找找。。");
	}

	@Override
	public void wearClothes() {
		// TODO Auto-generated method stub
		super.wearClothes();
		goClothespress();
	}

	@Override
	public void walkToWhere() {
		// TODO Auto-generated method stub
		super.walkToWhere();
		findPlaceOnMap();
	}
}

public class Decorator_two extends Decorator {

	public Decorator_two(Human human) {
		super(human);
	}

	public void findClothes() {
		System.out.println("找到一件D&G。。");
	}

	public void findTheTarget() {
		System.out.println("在Map上找到神秘花园和城堡。。");
	}

	@Override
	public void wearClothes() {
		// TODO Auto-generated method stub
		super.wearClothes();
		findClothes();
	}

	@Override
	public void walkToWhere() {
		// TODO Auto-generated method stub
		super.walkToWhere();
		findTheTarget();
	}
}

//定义被装饰者，被装饰者初始状态有些自己的装饰
public class Person implements Human {

	@Override
	public void wearClothes() {
		// TODO Auto-generated method stub
		System.out.println("穿什么呢。。");
	}

	@Override
	public void walkToWhere() {
		// TODO Auto-generated method stub
		System.out.println("去哪里呢。。");
	}
}
//测试类，看一下你就会发现，跟java的I/O操作有多么相似
public class Test {
	public static void main(String[] args) {
		Human person = new Person();
		Decorator decorator = new Decorator_two(new Decorator_first(
				new Decorator_zero(person)));
		decorator.wearClothes();
		decorator.walkToWhere();
	}
}

运行结果：

其实就是进房子找衣服，然后找地图这样一个过程，通过装饰者的三层装饰，把细节变得丰富。

关键点：
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、装饰者模式的设计原则为：对扩展开放、对修改关闭，这句话体现在我如果想扩展被装饰者类的行为，无须修改装饰者抽象类，只需继承装饰者抽象类，实现额外的一些装饰或者叫行为即可对被装饰者进行包装。所以：扩展体现在继承、修改体现在子类中，而不是具体的抽象类，这充分体现了依赖倒置原则，这是自己理解的装饰者模式。


说的不清楚，有些只可意会不可言传的感觉，多看几遍代码，然后自己敲出来运行一下，基本上就领悟了。


下面这个例子也有助于理解 装饰的流程和作用

现在需要一个汉堡，主体是鸡腿堡，可以选择添加生菜、酱、辣椒等等许多其他的配料，这种情况下就可以使用装饰者模式。


汉堡基类（被装饰者，相当于上面的Human）

[java] view plain copy
print ?
  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. }    
package decorator;  
  
public abstract class Humburger {  
      
    protected  String name ;  
      
    public String getName(){  
        return name;  
    }  
      
    public abstract double getPrice();  
  
}
鸡腿堡类（被装饰者的初始状态，有些自己的简单装饰，相当于上面的Person）
[java] view plain copy
print ?
  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. }    
package decorator;  
  
public class ChickenBurger extends Humburger {  
      
    public ChickenBurger(){  
        name = "鸡腿堡";  
    }  
  
    @Override  
    public double getPrice() {  
        return 10;  
    }  
  
}

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

[java] view plain copy
print ?
  1. package decorator;    
  2.     
  3. public abstract class Condiment extends Humburger {    
  4.         
  5.     public abstract String getName();    
  6.     
  7. }    
package decorator;  
  
public abstract class Condiment extends Humburger {  
      
    public abstract String getName();  
  
}

 

生菜（装饰者的第一层，相当于上面的decorator_zero）

[java] view plain copy
print ?
  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. }    
package decorator;  
  
public class Lettuce extends Condiment {  
      
    Humburger humburger;  
      
    public Lettuce(Humburger humburger){  
        this.humburger = humburger;  
    }  
  
    @Override  
    public String getName() {  
        return humburger.getName()+" 加生菜";  
    }  
  
    @Override  
    public double getPrice() {  
        return humburger.getPrice()+1.5;  
    }  
  
}


辣椒（装饰者的第二层，相当于上面的decorator_first）

[java] view plain copy
print ?
  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. }    
package decorator;  
  
public class Chilli extends Condiment {  
      
    Humburger humburger;  
      
    public Chilli(Humburger humburger){  
        this.humburger = humburger;  
          
    }  
  
    @Override  
    public String getName() {  
        return humburger.getName()+" 加辣椒";  
    }  
  
    @Override  
    public double getPrice() {  
        return humburger.getPrice();  //辣椒是免费的哦  
    }  
  
}


测试类

[java] view plain copy
print ?
  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. }    
package decorator;  
  
public class Test {  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        Humburger humburger = new ChickenBurger();  
        System.out.println(humburger.getName()+"  价钱："+humburger.getPrice());  
        Lettuce lettuce = new Lettuce(humburger);  
        System.out.println(lettuce.getName()+"  价钱："+lettuce.getPrice());  
        Chilli chilli = new Chilli(humburger);  
        System.out.println(chilli.getName()+"  价钱："+chilli.getPrice());  
        Chilli chilli2 = new Chilli(lettuce);  
        System.out.println(chilli2.getName()+"  价钱："+chilli2.getPrice());  
    }  
  
}

输出

[java] view plain copy
print ?
  1. 鸡腿堡  价钱：10.0    
  2. 鸡腿堡 加生菜  价钱：11.5    
  3. 鸡腿堡 加辣椒  价钱：10.0    
  4. 鸡腿堡 加生菜 加辣椒  价钱：11.5    
鸡腿堡  价钱：10.0  
鸡腿堡 加生菜  价钱：11.5  
鸡腿堡 加辣椒  价钱：10.0  
鸡腿堡 加生菜 加辣椒  价钱：11.5


 

作者：jason0539

微博：http://weibo.com/2553717707

博客：http://blog.csdn.net/jason0539（转载请说明出处）

提交最后一行代码
关注
专栏目录
decorator在java中_装饰模式（Decorator）
weixin_39737001的博客
03-01 297
装饰(Decorator)模式又称包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。我们通过日常使用的手机换代来解释什么是装饰模式。手机总体来看存在三个大的版本，分别是"黑白屏时代"、"半智能时代(即NOKIA的天下)"和"只能手机(即Android、IOS)"，如下图：上图中，手机的黑白屏就是装饰模式的基础构建，其他代的手机都是在黑白屏手机基础上进...
Java设计模式-装饰者模式
12-21
装饰者模式（Decorator Pattern）是一种结构型设计模式，它允许在运行时给对象增加新的行为或责任，而无需修改其源代码。这种模式通过创建一个与原对象具有相同接口的新对象（装饰者），并把原对象作为其内部成员，...
Java中的装饰器模式（Decorator）
Versus666的博客
06-22 417
1前言 Java中面向可复用性和可维护性的设计模式大体上分为三类：创建型模式（Creational patterns）、结构型模式（Structural patterns）、行为类模式（Behavioral patterns），本文将主要介绍结构型模式中的装饰器模式（Decorator pattern）。 2 装饰器模式简介 2.1 定义 一种用于代替继承的技术，无需通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。 2.2模式类...
java设计模式之装饰者模式
m0_47944994的博客
11-17 2246
java设计模式之装饰者模式
Java 设计模式之装饰者模式
来自上海的这位朋友
04-14 518
本文介绍了 Java 设计模式之一的装饰者模式。装饰者模式是一种结构性设计模式，它允许我们动态地将行为添加到对象中，而无需通过继承来实现。文章首先讲解了装饰者模式的基本原理，通过将对象包装在装饰器对象中来实现。然后，通过一个简单的案例来演示如何使用装饰者模式为咖啡添加额外的调料，动态地改变咖啡的行为，从而提高了代码的可维护性和可扩展性。最后，总结了装饰者模式的优点，通过将行为添加到对象中，而无需通过继承来实现，提高了代码的可维护性和可扩展性。
重学java的设计模式
05-09
本文将着重探讨创建型模式、结构型模式和行为模式这三大类设计模式，并结合六项设计原则进行深入解析。 首先，我们来看创建型模式。创建型模式关注于对象的创建，它们提供了创建对象的灵活方式，使得代码更具复用性...
Java装饰器设计模式初探
09-01
【Java装饰器设计模式】是一种结构型设计模式，它的核心思想是通过在对象外部增加新的行为，而不是修改原有的代码，从而扩展对象的功能。这种模式遵循开闭原则，即对扩展开放，对修改关闭，使得软件系统更加灵活且...
Java 设计模式最佳实践
最新发布
04-09
在这个主题中，我们将深入探讨一些关键的设计模式，并提供实践指导。 一、单例模式（Singleton） 单例模式确保一个类只有一个实例，并提供一个全局访问点。在Java中，可以通过枚举、双重检查锁定（Double-Checked ...
Java设计模式之装饰者模式
weixin_49190101的博客
03-14 257
Java设计模式之装饰者模式 在开始之前，先简单了解一下什么是装饰者模式？装饰者模式好比你新买的iPhone13手机，他能正常运作，可以打电话，拍照，上网浏览CSDN，但是你又怕手机摔坏，于是你花钱去贴了一个手机膜，还买了手机壳，对于手机来说，他有了手机膜和手机壳，但是不会影响拍照和上网，那么这就算一个装饰，用手机膜和手机壳装饰了手机，但是没有改变手机原有的结构和功能，下面我用大家最常见的奶茶为例，详细讲解装饰者模式。 首先，大家可以看一下这张图片 结合这张图片，再结合代码，相信你会理解的更清楚 抽象类奶
Java设计模式-装饰器模式(Decorator)
qq_37400096的博客
09-24 1117
使用的场景：1、扩展一个类的功能。2、动态增加功能，动态撤销。
装饰者模式---汉堡实例
wuxinliulei的专栏
04-05 3083
装饰者模式：动态地将责任附加到对象上，若要扩展对象，装饰者模式提供了比继承更弹性的替代方案  要点： 装饰者与被装饰者拥有共同的超类，继承的目的是继承类型，而不是行为 装饰者包含一个超类的对象，这样，可以在被装饰者行为前或者行为后加上新的行为，甚至取代原有的行为 装饰者会使程序中出现很多小类，增加使用难度 使用场景：对象由主体+许多可选的部件或者功能构成，使用继承或者接口会产生很多类，且很
Java设计模式 -10- 装饰器模式（Decorator模式）
Android系统工程师--小馬佩德罗
07-02 1689
Java设计模式 -9- 装饰器模式（装饰设计模式）装饰器模式的定义与特点优点：缺点：装饰器模式的结构与实现1. 模式的结构2. 模式的实现装饰器模式的应用实例装饰器模式的应用场景装饰器模式的扩展 上班族大多都有睡懒觉的习惯，每天早上上班时间都很紧张，于是很多人为了多睡一会，就会用方便的方式解决早餐问题。有些人早餐可能会吃煎饼，煎饼中可以加鸡蛋，也可以加香肠，但是不管怎么“加码”，都还是一个煎饼。在现实生活中，常常需要对现有产品增加新的功能或美化其外观，如房子装修、相片加相框等，都是装饰器模式。 在软件开发
设计模式-装饰者模式（6）
Nimikyの议事大厅
11-27 516
装饰者模式定义：动态给一个对象添加一些额外的职责,就象在墙上刷油漆.使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活。
Java设计模式（装饰设计模式）
0xc
07-08 580
作用：改写已存在的类的某个方法或某些方法，装饰设计模式（包装模式）场景：DataSource数据源连接池，获取Connection后的close不能关闭，而是放入连接池中，就需要使用装饰者设计模式口诀：1、编写一个类，实现与被包装类相同的接口。（具备相同的行为）2、定义一个被包装类类型的变量。3、定义构造方法，把被包装类的对象注入，给被包装类变量赋值。4、对于不需要改写的方法，调用原有的方法。5、...
java装饰者模型_Java—装饰者设计模式
weixin_35702533的博客
02-25 161
一、装饰者设计模式概念：可以扩展原有对象的功能(比继承更灵活)，即定义一个接口二、使用多线程为例子2.1 接口中需要返回值，如何做？public class Demo {public static void main(String[] args) {new Runnable() {@Overridepublic void run() {// 此方法中需要返回对象，如何做// 可以通过成员变量的方式...
装饰者模式
热门推荐
lansuiyun的专栏
09-15 1万+
装饰者模式：动态地将责任附加到对象上，若要扩展对象，装饰者模式提供了比继承更弹性的替代方案  要点： 装饰者与被装饰者拥有共同的超类，继承的目的是继承类型，而不是行为 装饰者包含一个超类的对象，这样，可以在被装饰者行为前或者行为后加上新的行为，甚至取代原有的行为 装饰者会使持续中出现很多小类，增加使用难度 使用场景：对象由主体+许多可选的部件或者功能构成，使用继承或者接口会产生很多类，且很
装饰者模式-Decorator
正走向大牛的菜鸟
06-24 148
装饰者模式：动态地将责任附加到对象上，若要扩展对象，装饰者模式提供了比继承更弹性的替代方案  要点：装饰者与被装饰者拥有共同的超类，继承的目的是继承类型，而不是行为 装饰者包含一个超类的对象，这样，可以在被装饰者行为前或者行为后加上新的行为，甚至取代原有的行为 装饰者会使程序中出现很多小类，增加使用难度 使用场景：对象由主体+许多可选的部件或者功能构成，使用继承或者接口会产生很多类，且很...
JAVA设计模式探索：设计之道
"JAVA设计模式《设计之道》涵盖了全部23种Java设计模式，并通过详细的例子和UML类图进行阐述，旨在帮助读者理解和应用这些模式。书籍内容涉及设计原则、重构、各种特定设计模式的实践，以及如何通过设计满足客户需求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值