装饰模式
装饰模式又名包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。
定义：动态给一个对象添加一些额外的职责,使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活。
设计初衷:通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的。
装饰模式的结构
装饰模式使用原来被装饰的类的一个子类的实例，把客户端的调用委派到被装饰类。装饰模式的关键在于这种扩展是完全透明的。
装饰模式类图如下：
在装饰模式中的角色有：
● 抽象构件(Component)角色：给出一个抽象接口，以规范准备接收附加责任的对象。
● 具体构件(ConcreteComponent)角色：定义一个将要接收附加责任的类。
● 装饰(Decorator)角色：持有一个构件(Component)对象的实例，并定义一个与抽象构件接口一致的接口。
● 具体装饰(ConcreteDecorator)角色：负责给构件对象“贴上”附加的责任。
源代码：
/**
* @author: Col.Mai
* @date:2014-9-23 下午11:07:34
* @description :<p>抽象角色构件</P>
**/
public interface Component {
void sampleOperation();
}
/**
* @author: Col.Mai
* @date:2014-9-23 下午11:08:40
* @description :<p>具体构件角色</P>
**/
public class ConcreteComponent implements Component {
public void sampleOperation() {
//TODO 写相关业务代码
}
}
/**
* @author: Col.Mai
* @date:2014-9-23 下午11:09:58
* @description :<p>装饰角色</P>
**/
public class Decorator implements Component {
private Component component;
public void sampleOperation() {
// 委派给构件
component.sampleOperation();
}
public Decorator(Component component){
this.component = component;
}
}
/**
* @author: Col.Mai
* @date:2014-9-23 下午11:13:36
* @description :<p>具体装饰角色</P>
**/
public class ConcreteDecorator extends Decorator {
public ConcreteDecorator(Component component) {
super(component);
}
@Override
public void sampleOperation() {
super.sampleOperation();
// 写相关的业务代码
}
}
- 在上面的装饰类里，有一个私有的属性component,其数据类型是构件（Component）
- 此装饰类实现了构件（Component）接口
- 接口的方法也值得注意，每一个实现类的方法都委派给父类，但并不单纯地委派，而是有功能增强。
下面举个简单的例子，我记的我小时候看过一个动画片叫《战神金刚》，当时非常喜欢看，放学后就盯着电视连饭都不吃，为此没少挨揍，这个动画片讲的是几个小朋友团队合作组成战神金刚消灭强大的敌人，在组成战神金刚前，他们分别是单独的对象，在组成时他们分别组成身体、头部、腿部、手部从而完成战神金刚(时间久远具体剧情也忘记了，组成部分只是靠回忆猜测，不要在意这些细节，主要是以此为例)。
类图如下：
代码如下：
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:39:24
* @description :<p>抽象构件角色（战神金刚）</P>
**/
public interface Robot {
/**
* 组成某个部位
*/
void composition();
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:49:27
* @description :<p>具体构件角色</P>
**/
public class ConcreteRobot implements Robot{
public void composition() {
System.out.println("组成战神金刚！");
}
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午1:18:48
* @description :<p>装饰者角色</P>
**/
public class Decorator implements Robot{
private Robot robot;
public Decorator(Robot robot){
this.robot = robot;
}
public void composition() {
robot.composition();
}
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:47:06
* @description :<p>装饰身体</P>
**/
public class Decorator4Body extends Decorator {
public Decorator4Body(Robot robot) {
super(robot);
}
public void composition() {
System.out.println("我来组成身体!");
super.composition();
}
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:47:28
* @description :<p>装饰手部</P>
**/
public class Decorator4Hand extends Decorator {
public Decorator4Hand(Robot robot) {
super(robot);
}
public void composition() {
System.out.println("我来组成手部!");
super.composition();
}
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:44:20
* @description : <p> 装饰头部 </P>
**/
public class Decorator4Head extends Decorator {
public Decorator4Head(Robot robot) {
super(robot);
}
public void composition() {
System.out.println("我来组成头部!");
super.composition();
}
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:46:27
* @description :<p>装饰腿部</P>
**/
public class Decorator4Leg extends Decorator{
public Decorator4Leg(Robot robot) {
super(robot);
}
public void composition() {
System.out.println("我来组成腿部!");
super.composition();
}
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:55:34
* @description :<p>xxx功能描述</P>
**/
public class Client {
public static void main(String [] args){
Robot robot = new ConcreteRobot();
Robot obj = new Decorator4Body(new Decorator4Head(new Decorator4Leg(new Decorator4Hand(robot))));
obj.composition();
}
}
我来组成身体! 我来组成头部! 我来组成腿部! 我来组成手部! 组成战神金刚！
装饰模式的简化
大多数情况下，装饰模式的实现都要比上面给出的示意性例子要简单。
有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类。甚至在只有两个ConcreteDecorator类的情况下，都可以这样做。如下图所示：
还是组成《战神金刚》的例子，看我们简化后如何做。
类图如下：
源码：
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:39:24
* @description :<p>抽象构件角色（战神金刚）</P>
**/
public interface Robot {
/**
* 组成某个部位
*/
void composition();
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:49:27
* @description :<p>具体构件角色</P>
**/
public class ConcreteRobot implements Robot{
public void composition() {
System.out.println("组成战神金刚！");
}
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:47:06
* @description :<p>装饰身体</P>
**/
public class Decorator4Body implements Robot {
private Robot robot;
public Decorator4Body(Robot robot) {
this.robot = robot;
}
public void composition() {
System.out.println("我来组成身体!");
robot.composition();
}
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:47:28
* @description :<p>装饰手部</P>
**/
public class Decorator4Hand implements Robot {
private Robot robot;
public Decorator4Hand(Robot robot) {
this.robot = robot;
}
public void composition() {
System.out.println("我来组成手部!");
robot.composition();
}
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:44:20
* @description : <p> 装饰头部 </P>
**/
public class Decorator4Head implements Robot {
private Robot robot;
public Decorator4Head(Robot robot) {
this.robot = robot;
}
public void composition() {
System.out.println("我来组成头部!");
robot.composition();
}
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:46:27
* @description :<p>装饰腿部</P>
**/
public class Decorator4Leg implements Robot {
private Robot robot;
public Decorator4Leg(Robot robot) {
this.robot = robot;
}
public void composition() {
System.out.println("我来组成腿部!");
robot.composition();
}
}
/**
* @author: Col.Mai
* @date:2014-9-26 上午12:55:34
* @description :<p>xxx功能描述</P>
**/
public class Client {
public static void main(String [] args){
Robot robot = new ConcreteRobot();
Robot obj = new Decorator4Body(new Decorator4Head(new Decorator4Leg(new Decorator4Hand(robot))));
obj.composition();
}
}
输出
我来组成身体! 我来组成头部! 我来组成腿部! 我来组成手部! 组成战神金刚！
相关推荐
### Java装饰模式详解 #### 一、装饰模式概述 装饰模式是一种结构型设计模式，它允许向对象添加新的功能，而无需修改其原有结构。这种模式通过创建包含其他对象的对象来扩展功能，使得可以在不破坏封装性的前提下...
在Java中，装饰模式通常通过继承和组合来实现，它为对象提供了增加新功能的方式，同时保持了对象的接口不变。这种方式使得我们可以动态地给一个对象添加一些额外的职责，而不会影响到其他对象。 装饰模式的核心思想...
装饰模式和动态代理模式是Java编程中两种非常重要的设计模式，它们都在代码的扩展性和灵活性方面发挥着关键作用。下面将分别对这两种模式进行详细解释，并结合手写的数据库连接池和动态代理模式的使用进行深入探讨。...
Java中的装饰模式通常涉及到继承和组合的使用。 在给定的资料中，我们可以看到以下几个关键的文件： 1. `Compoent.java`：这是组件接口或抽象类，定义了装饰模式的基本行为。所有具体组件（ConcreteCompoent）和...
在Java中，装饰模式的核心在于抽象组件（Component）接口、具体组件（Concrete Component）类、抽象装饰（Decorator）类以及具体装饰（Concrete Decorator）类。首先，我们定义一个抽象组件接口，它定义了所有组件...
通过设计组装和升级大众CC来说明装饰模式，有一个VolkCC类实现Volk接口，设计一个CCDecorator实现Volk这个接口，在ConcreteCCDecorator这个具体装饰角色中进行功能的增加和重写。
装饰模式是一种设计模式，它允许在不改变对象自身的情况下，动态地给对象添加新的行为或职责。这种模式常用于在不修改源代码的情况下扩展对象的功能，或者为对象提供额外的职责。在本例中，"项目经理接到一个项目，...
在Java中，装饰者模式通常通过继承和组合来实现，它提供了一种比继承更灵活的方式来扩展对象的功能。下面将详细讲解装饰者模式的核心概念、工作原理以及如何在Java中应用。 ### 一、装饰者模式的基本概念 1. **...
在Java中，装饰模式通常通过继承和组合来实现，提供了比子类化更灵活的方式来扩展对象的功能。 装饰模式的核心概念包括以下几个部分： 1. 抽象组件（Component）：定义一个接口，所有目标对象和装饰对象都要实现这...
装饰模式是一种设计模式，属于结构型模式，其主要目的是在不改变对象本身的基础上，通过向对象添加新的行为或属性来扩展其功能。这种模式遵循“开闭原则”，即对扩展开放，对修改关闭。 在装饰模式中，有四个关键...
【Java 装饰模式详解】 装饰模式（Decorator Pattern）是一种结构型设计模式，它可以在不修改原有对象的基础上，通过添加新的职责来扩展对象的功能。装饰模式的核心在于它定义了一个与原类一致的接口，使得装饰类和...
Java装饰模式，也被称为Decorator模式，是一种设计模式，它允许在运行时向对象添加新的行为或职责，而不必通过继承的方式来扩展类。这种模式提供了一种比使用子类更加灵活的方式来扩展对象的功能。 装饰模式的核心...
【Java装饰模式（Decorator Pattern）】装饰模式是一种结构型设计模式，它允许在不修改已有对象的基础上，通过添加额外的功能来扩展对象的行为。这种模式的关键在于装饰类与被装饰类有相同的接口，使得它们可以互换...
2. **动态性**：装饰模式允许我们在运行时动态地为对象添加新功能，而无需修改代码。 3. **组合性**：通过多个装饰者的叠加，可以实现更复杂的功能，这比使用继承来扩展功能更加灵活。 4. **职责分离**：装饰者模式...
Java IO 与 装饰模式 在Java编程中，输入输出（IO）处理是程序设计中的重要组成部分，用于读取、写入和处理数据。Java IO库提供了一整套类来支持各种类型的输入输出操作，包括文件、网络、内存等。而装饰模式是一种...
在Java中，装饰者模式通常涉及到继承和接口的使用。装饰者模式的核心思想是，定义一个抽象组件接口（Component），然后创建一个实现了这个接口的类（ConcreteComponent）。接着，创建一个抽象装饰者接口（Decorator...
本章可以称为“给爱用继承的人一个全新的设计眼界”。我们即将再度探讨典型滥用问题。你将在本章学到如何使用对象组合的方式，做到在运行时装饰类。为什么呢？一旦你熟悉了装饰者的技巧...——《Head First 设计模式》
装饰模式是一种设计模式，它允许我们在不修改原有对象的基础上，通过添加新的行为或属性来扩展对象的功能。在"装饰模式小猪快跑游戏模拟"这个实例中，我们看到这种模式被巧妙地应用到了一个名为“小猪吃苹果”的游戏...
装饰模式（Decorator Pattern）是Java设计模式中的一种结构型模式，它允许在运行时动态地向对象添加新的行为或职责，而不会破坏封装性。这种模式可以用来将多个功能组合在一起，同时保持类的可扩展性和灵活性。在...
- 装饰模式：动态地给对象添加一些额外的职责，比继承更加灵活。 - 外观模式：为复杂的子系统提供一个简单的接口。 - 代理模式：为其他对象提供一种代理以控制对这个对象的访问。 - 模板方法模式：定义一个操作...