c设计模式之装饰者模式(decoratorpattern)

合集下载

设计模式(三):“花瓶+鲜花”中的装饰者模式(DecoratorPattern)

设计模式(三):“花瓶+鲜花”中的装饰者模式(DecoratorPattern)

设计模式(三):“花瓶+鲜花”中的装饰者模式(DecoratorPattern)在前两篇博客中详细的介绍了""和“”,今天我们就通过花瓶与鲜花的例⼦来类⽐⼀下“装饰模式”(Decorator Pattern)。

在“装饰模式”中很好的提现了开放关闭原则,即类应该对扩展开放对修改关闭。

装饰者模式可以让我们在不对原来代码的修改的情况下对类进⾏扩展。

这也好⽐我们往花瓶⾥插花,我们在插花的时候是不会对花瓶以及原来的话进⾏任何的修改,⽽只管将我们新的花添加进花瓶即可。

这就是我们的装饰者模式。

当然本篇博客中所采⽤的语⾔仍然是Swift语⾔。

装饰者模式,⽤另⼀种表达⽅式就是“对原有的物体进⾏装饰,给原有的物体添加上新的装饰品”。

举个栗⼦,⽐如⼀个礼物,我们要对其进⾏包装,礼物是被装饰者(我们称为组件---Component),⽽包装盒以及包装盒上的花等等就是装饰品(我们成为装饰者---Decorator)。

如果换成花瓶与鲜花的关系,花瓶就是Component,⽽鲜花就是Decorator。

下⽅引⽤了装饰者模式的定义:装饰者模式:动态地将责任附加到对象上。

若要扩展功能,装饰着提供了⽐继承更有弹性的替代⽅案。

⼀、使⽤“类图”分析鲜花+花瓶的装饰关系与之前博客的风格类似,我们还是依托于实例来理解“装饰者模式”,我们就依托于花瓶与鲜花的关系来理解⼀下装饰者模式。

在之前的博客中我们提到过⼀条设计原则“封装变化”,也就是说要将变化的东西进⾏封装提取。

在“装饰者模式”中所使⽤的装饰就是变化的部分,也就是Decorator是变化的部分对应着我们的鲜花,因为往花瓶中插花的过程就是鲜花变化的过程,也就是为花瓶装饰的过程。

⽽花瓶就是组件了。

在“装饰者模式”中需要注意的是,这⾥所谓的装饰者不单单就是我组件添加的新的装饰品。

⼀个装饰者对象就是添加该装饰后的组件,也就是说装饰者=旧组件 + 新装饰品,理解这⼀点是⾮常重要的。

QY03装饰模式

QY03装饰模式

类爆炸!!
Beverage
description getDescription() Cost() //Other methods
HouseBlend DarkRoast Decaf Espresso HouseBlend Cost() Cost() Decaf Cost() Espresso HouseBlend Cost() Cost() HouseBlend Decaf Espresso Cost() Cost() Decaf Cost() Espresso HouseBlend Cost() Cost() Decaf Cost() Espresso HouseBlend Cost() HouseBlendWith Cost() Cost() Cost() Cost() Cost() SteamedMilkandMocha
HouseBlend
Cost()
DarkRoast
Cost()
Decaf
Cost()
Espresso
Cost()
基类的cost()代码应该是怎样的?
Public class Beverage { ... public double cost() {
只计算调料价格
} ...
}
子类的cost()代码应该是怎样的?
Public class DarkRoast extends Beverage { public DarkRoast() { description=“优质DarkRoast咖啡”; } public double cost() {
计算完整的咖啡价格, 包括调料的价格
}
} ...
Beverage
description
getDescription() cost() hasMilk() setMilk() hasSoy() setSoy() … //Other methods

设计模式.装饰模式(Decorator)

设计模式.装饰模式(Decorator)
需要扩展一个类的行为,但由 于继承为类带来了过多的复杂
性或者继承层次过深。
需要对一组基本功能进行排列 组合以产生非常多的功能,而 使用继承关系很难实现这样的 需求。
需要在不修改现有代码的情况 下对程序进行功能扩展。
02
装饰模式的实现方式
继承实现方式
1 2 3
优点
代码简洁,易于理解。
缺点
不够灵活,每增加一个新的装饰功能,都需要创 建一个新的子类,类数量会急剧增加,导致系统 庞大和复杂。
03 需要对一组基本功能进行排列组合以产生非常多 的功能。
对未来研究的展望
深入研究装饰模式的适用场 景和最佳实践,以便更好地 应用该模式解决实际问题。
研究如何将装饰模式与其 他设计模式结合使用,以 产生更好的设计效果。
ABCD
探索如何降低装饰模式的 复杂性,提高代码的可读 性和维护性。
关注新兴技术和编程语言对装 饰模式的影响,以便及时调整 和更新该模式的应用方式。
可能破坏封装性
在使用装饰模式时,需要注意不要破坏对象的封 装性。如果装饰器暴露了对象的内部状态或实现 了不应该暴露的方法,那么可能会导致系统的不 稳定性和安全性问题。
06
总结与展望
对装饰模式的总结
优点 装饰模式可以在不改变对象自身的基础上,动态地给对象添加一些额外的职责。
装饰模式可以在运行时选择性地添加或删除某些功能,提高了系统的灵活性。
统或类的整合和简化。
03
透明性不同
装饰模式对客户端是透明的,客户端可以无感知地使用被装饰的对象,
而外观模式则可能需要对客户端进行一定的定制,以提供简化的接口。
与桥接模式的比较
目标不同
装饰模式的目标是动态地给一个对象添加一些额外的职责, 而桥接模式的目标是将抽象部分与它的实现部分分离,使 它们都可以独立地变化。

23种设计模式记忆口诀

23种设计模式记忆口诀

23种设计模式记忆口诀设计模式是软件开发中常见的解决方案模板,它们能够解决许多常见的设计问题。

为了帮助记忆23种设计模式,可以使用下面这个口诀来记忆:Creational Patterns(创建型模式):1. Singleton(单例模式):一个类能产生一个实例,全局访问。

2. Builder(建造者模式):分步骤创建复杂对象,易拓展。

3. Factory Method(工厂方法模式):子类决定实例化哪个对象。

4. Abstract Factory(抽象工厂模式):创建一组相关对象,不依赖具体类。

5. Prototype(原型模式):通过复制现有对象来创建新对象。

Structural Patterns(结构型模式):6. Adapter(适配器模式):将类的接口转换为客户端希望的接口。

7. Bridge(桥接模式):将抽象部分与实际部分分离。

将对象组合成树形结构来表示部分整体的层次结构。

9. Decorator(装饰器模式):动态地给对象添加功能。

10. Facade(外观模式):提供一个统一的接口,简化客户端使用。

11. Flyweight(享元模式):共享细粒度对象,减少内存使用。

12. Proxy(代理模式):控制对其他对象的访问。

Behavioral Patterns(行为型模式):13. Chain Of Responsibility(责任链模式):将请求的发送者和接收者解耦,多个对象都可能处理请求。

将请求封装成对象,可以用参数化方式处理。

15. Iterator(迭代器模式):提供一种遍历集合的统一接口。

16. Mediator(中介者模式):将多个对象之间的复杂关系解耦。

17. Memento(备忘录模式):将对象的状态保存起来,以后可以恢复。

18. Observer(观察者模式):当一个对象改变状态时,依赖它的对象都会收到通知。

19. State(状态模式):对象的行为随状态的改变而改变。

编程中的设计模式:8个常见模式解析

编程中的设计模式:8个常见模式解析

编程中的设计模式:8个常见模式解析设计模式是软件开发中常见的一种解决问题的思想模式,它是一种经过多次实践总结出来的在特定情境下,对特定问题的解决方案。

设计模式通过将经典的经验进行抽象,然后形成模式来指导软件开发工程师进行设计和开发。

下面将介绍8个常见的设计模式。

1.工厂模式(Factory Pattern)工厂模式是一种创建型模式,用于创建对象的过程中隐藏了具体的实现细节,只暴露了一个工厂类的接口。

工厂模式可以根据不同的参数或条件,动态地返回不同的具体对象,达到解耦的效果,提高了代码的灵活性和可维护性。

2.单例模式(Singleton Pattern)单例模式是一种创建型模式,保证一个类只有一个实例,并提供全局访问点,同时对外部隐藏了具体的创建过程。

单例模式可以用于实现全局资源的管理,例如线程池、数据库连接等,避免了资源的创建和销毁过程中的开销问题。

3.观察者模式(Observer Pattern)观察者模式是一种行为型模式,定义了一种一对多的依赖关系,使得当一个对象的状态发生变化时,其相关依赖对象都能够得到通知和更新。

观察者模式可以实现松耦合的通信方式,增加了对象之间的交互性,提高了系统的可扩展性和可维护性。

4.策略模式(Strategy Pattern)策略模式是一种行为型模式,定义了一系列算法或行为,将它们封装起来并可以相互替换。

策略模式使得算法的变化不会影响到调用算法的客户端,提高了代码的可复用性和可维护性。

5.装饰器模式(Decorator Pattern)装饰器模式是一种结构型模式,可以动态地给一个对象添加一些额外的职责,而无需对原始对象进行修改。

装饰器模式通过组合的方式,将一系列装饰器对象包裹在被装饰对象的外部,从而在运行时动态地扩展对象的功能。

6.适配器模式(Adapter Pattern)适配器模式是一种结构型模式,用于将一个类的接口转换成客户端所期望的接口。

适配器模式中,适配器类是作为两个不兼容的接口之间的桥梁,将一个类的接口转换成另一个接口,从而可以让它们能够正常地协同工作。

装饰器模式(Decorator)——深入理解与实战应用

装饰器模式(Decorator)——深入理解与实战应用

装饰器模式(Decorator)——深⼊理解与实战应⽤ 本⽂为原创博⽂,转载请注明出处,侵权必究! 1、初识装饰器模式 装饰器模式,顾名思义,就是对已经存在的某些类进⾏装饰,以此来扩展⼀些功能。

其结构图如下:Component为统⼀接⼝,也是装饰类和被装饰类的基本类型。

ConcreteComponent为具体实现类,也是被装饰类,他本⾝是个具有⼀些功能的完整的类。

Decorator是装饰类,实现了Component接⼝的同时还在内部维护了⼀个ConcreteComponent的实例,并可以通过构造函数初始化。

⽽Decorator本⾝,通常采⽤默认实现,他的存在仅仅是⼀个声明:我要⽣产出⼀些⽤于装饰的⼦类了。

⽽其⼦类才是赋有具体装饰效果的装饰产品类。

ConcreteDecorator是具体的装饰产品类,每⼀种装饰产品都具有特定的装饰效果。

可以通过构造器声明装饰哪种类型的ConcreteComponent,从⽽对其进⾏装饰。

2、最简单的代码实现装饰器模式//基础接⼝public interface Component {public void biu();}//具体实现类public class ConcretComponent implements Component {public void biu() {System.out.println("biubiubiu");}}//装饰类public class Decorator implements Component {public Component component;public Decorator(Component component) {ponent = component;}public void biu() {ponent.biu();}}//具体装饰类public class ConcreteDecorator extends Decorator {public ConcreteDecorator(Component component) {super(component);}public void biu() {System.out.println("ready?go!");ponent.biu();}} 这样⼀个基本的装饰器体系就出来了,当我们想让Component在打印之前都有⼀个ready?go!的提⽰时,就可以使⽤ConcreteDecorator类了。

装饰者模式的使用方法和案例分享

装饰者模式的使用方法和案例分享

装饰者模式的使用方法和案例分享装饰者模式(Decorator Pattern)是一种常用的设计模式,在软件开发中十分实用。

它能够动态地将责任附加到对象上,从而实现对象功能的扩展,同时避免重复代码的产生。

本文将介绍装饰者模式的使用方法以及一些实际案例的分享。

一、装饰者模式的定义装饰者模式是指在不改变原有对象结构的情况下,动态地扩展该对象的功能。

该模式通过一种装饰器对象来包裹原有对象,并在运行时动态地添加新的行为。

二、装饰者模式的实现装饰者模式的实现需要定义一个包装类和一个抽象组件类。

包装类实现了抽象组件类,并定义了一个指向抽象组件类的指针,从而实现对抽象组件类的扩展。

抽象组件类是被装饰的类,定义了抽象接口。

三、装饰者模式的优点1. 可以动态地添加或删除功能。

2. 可以避免重复代码的产生,减少代码的复杂程度。

3. 可以提高代码的可扩展性和维护性。

四、装饰者模式的实际案例分享1. Java I/O模块Java I/O模块是一个典型的使用装饰者模式的实例。

Java I/O模块通过InputStream和OutputStream来处理输入输出流,通过FileInputStream和FileOutputStream来处理文件输入输出流,同时还可以通过BufferedInputStream和BufferedOutputStream来实现缓冲输入输出流和过滤输入输出流。

这些类的组合和复合就是通过装饰者模式实现的,从而实现了输入输出流的灵活性和可扩展性。

2. GUI开发中的控件美化在GUI开发中,控件美化也是一个典型的应用场景。

通过使用装饰者模式,可以动态地修改一个控件的外观和功能,而不需要修改源代码。

例如,可以通过直接继承一个控件类,实现控件的装饰,从而实现控件的美化。

3. 日志记录日志记录也是一个常见的应用场景。

通过使用装饰者模式,可以自定义不同类型的日志记录器,从而实现日志记录的灵活性和可扩展性。

例如,可以自定义一个输出到数据库的日志记录器,一个输出到文件的日志记录器等。

面向对象的软件设计实践

面向对象的软件设计实践

面向对象的软件设计实践随着现代信息技术的高速发展,软件开发已经成为了人们生活和工作中不可或缺的一部分。

而面向对象的软件设计方法已经成为了一种被广泛采用的设计方法,它可以有效地提高软件的可维护性、可扩展性和可重用性。

面向对象的软件设计方法以对象为中心,将实体的抽象化作为核心思想,利用类、继承、多态等概念,来描述系统中的各种实体对象及其相互关系。

采用这些概念,可以将系统中的复杂对象进行有效地分解,并将它们之间的关系以及行为特性进行描述,然后将这些描述用软件工具来实现。

面向对象的软件设计方法是一个非常重要的概念,也是软件开发工程学科中的基础概念。

下面,本文将从各个方面来介绍面向对象的软件设计实践。

一、面向对象的设计原则在进行面向对象的软件设计时,我们需要尊重一些基本原则。

这些原则可以提高我们软件设计的质量和效率。

以下是一些重要的面向对象的设计原则:1、单一职责原则(SRP)这一原则也叫“单一功能原则”。

它指出一个类应该只有一个单一的职责。

也就是说,一个类只应该有一个引起它变化的原因。

SRP原则可以帮助我们提高代码的可重用性和可维护性。

2、开闭原则(OCP)这一原则指出“开放-封闭”原则。

软件的设计应该是开放扩展的但是封闭修改的。

换句话说,对于那些高度可变的需求,我们应该保持系统的灵活性以使之适应这些变化,但是我们不应该去打破那些已经运作良好的模块。

3、接口隔离原则(ISP)这一原则指出,应该为每一个客户端定制一个接口,而不是为一个类定制一个庞大而臃肿的接口。

这个原则可以帮助我们提高系统的可扩展性和可维护性。

4、依赖倒置原则(DIP)这一原则指出,应该依赖于抽象而不是具体的实现。

通过DIP原则,我们可以减小不同模块之间的关联度,从而提高系统的模块化程度。

二、面向对象的设计模式面向对象的设计方法是建立在设计模式之上的,设计模式可以视为软件设计界的调配图谱。

在面向对象软件设计中,有很多模式可以提高我们的设计效率和质量。

24种设计模式

24种设计模式

24种设计模式Factory Pattern(⼯⼚模式):1. 创建对象的接⼝,封装对象的创建;2. 使具体化类的⼯作延迟到⼦类中。

(维护⼀类对象)AbstractFactory Pattern(抽象⼯⼚模型):该模式将⼀组对象的创建封装到⼀个⽤于创建对象的类中。

(解决的问题:要创建⼀组或者相互依赖的对象)。

Singleton Pattern(单例模式):该模式在⾯向纯粹的⾯向对象的范式中⽤于创建唯⼀的实例,值得注意的是Singleton不能被实例化,因此将其构造函数声明为protected或private类型。

Singleton Pattern经常与Factory Pattern结合使⽤,因为Factory对象只能有⼀个。

Builder Pattern(创建者模式):将⼀个复杂的对象的构建与它的表⽰分离,使得同样的构建构成可以创建不同的表⽰。

如建筑师画图纸,⽽⼯⼈建造房屋。

Prototype Pattern(原型模式):提供⼀个通过已存在对象进⾏新对象创建的接⼝(clone)。

(浅拷贝和深拷贝)Bridge Pattern(桥梁模式):将抽象部分与实现部分分开实现,使他们都可以独⽴地变化,并使⽤组合的⽅式将多维度的抽象⽅法联系在⼀起。

⽐如咖啡分⼩杯、中杯、⼤杯以及加奶和不加奶,则抽象部分为:⼩杯、中杯、⼤杯,⾏为为:加奶和不加奶。

Adapter Pattern(适配器模式):适配就是由“源”到“⽬标”的适配,⽽当中链接两者的关系就是适配器。

它负责把“源”过度到“⽬标”。

将⼀个类的接⼝转换成客户希望的另外⼀个接⼝。

Adapter模式使得原本由于接⼝不兼容⽽不能⼀起⼯作的那些类可以⼀起⼯作。

适配器模式分为两种:①⾯向类的设计模式;②⾯向对象的设计模式。

①⾯向类的适配器:该模式使⽤继承和接⼝实现的⽅式复⽤需要适配器的类。

②⾯向对象的适配器:该模式使⽤组合的⽅式实现需要复⽤的类。

Decorator模式(装饰模式):动态地给⼀个对象添加⼀些额外的职责。

23种设计模式记忆技巧

23种设计模式记忆技巧

23种设计模式记忆技巧设计模式是一种解决设计问题的方案,在软件开发过程中起到了重要的作用。

然而,记忆设计模式的名称、特征和用法有时可能会让人感到困难。

为了帮助大家记住常用的23种设计模式,我将分享一些记忆技巧。

1. 单例模式(Singleton Pattern):想象一个宇宙中只存在一个唯一的太阳。

2. 简单工厂模式(Simple Factory Pattern):把工厂当做一个有丰富经验的魔术师,可以根据参数创建魔术道具。

3. 工厂方法模式(Factory Method Pattern):把工厂当做一个可以生产各种不同产品的工厂。

4. 抽象工厂模式(Abstract Factory Pattern):想象一个超级工厂,可以生产各种不同类型的产品。

5. 建造者模式(Builder Pattern):抽象出建造过程,让一个团队可以用不同的组件构建出不同的产品。

6. 原型模式(Prototype Pattern):把对象看作是一个可复制的模板。

7. 适配器模式(Adapter Pattern):把一个接口转换成另一个接口,就像使用插头转换器。

8. 桥接模式(Bridge Pattern):想象一个人过河,桥是连接两岸的桥梁。

9. 装饰器模式(Decorator Pattern):想象一个圣诞树,可以在上面加入各种装饰品。

11. 外观模式(Facade Pattern):把一系列复杂的操作封装成一个简单的接口。

12. 享元模式(Flyweight Pattern):把对象分为内部状态和外部状态,尽量共享内部状态。

13. 代理模式(Proxy Pattern):想象一个忙碌的明星,通过经纪人代理各种事务。

14. 策略模式(Strategy Pattern):将不同的策略封装成不同的对象,可以根据需求动态选择策略。

15. 模板方法模式(Template Method Pattern):定义一个算法的骨架,具体步骤由子类实现。

23种设计模式及案例整理分享

23种设计模式及案例整理分享

23种设计模式及案例整理分享创建型模式⼯⼚模式⼯⼚模式(Factory Pattern)是 Java 中最常⽤的设计模式之⼀。

这种类型的设计模式属于创建型模式,它提供了⼀种创建对象的最佳⽅式。

在⼯⼚模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使⽤⼀个共同的接⼝来指向新创建的对象。

介绍意图:定义⼀个创建对象的接⼝,让其⼦类⾃⼰决定实例化哪⼀个⼯⼚类,⼯⼚模式使其创建过程延迟到⼦类进⾏。

主要解决:主要解决接⼝选择的问题。

何时使⽤:我们明确地计划不同条件下创建不同实例时。

如何解决:让其⼦类实现⼯⼚接⼝,返回的也是⼀个抽象的产品。

关键代码:创建过程在其⼦类执⾏。

应⽤实例: 1、您需要⼀辆汽车,可以直接从⼯⼚⾥⾯提货,⽽不⽤去管这辆汽车是怎么做出来的,以及这个汽车⾥⾯的具体实现。

2、Hibernate 换数据库只需换⽅⾔和驱动就可以。

优点: 1、⼀个调⽤者想创建⼀个对象,只要知道其名称就可以了。

2、扩展性⾼,如果想增加⼀个产品,只要扩展⼀个⼯⼚类就可以。

3、屏蔽产品的具体实现,调⽤者只关⼼产品的接⼝。

缺点:每次增加⼀个产品时,都需要增加⼀个具体类和对象实现⼯⼚,使得系统中类的个数成倍增加,在⼀定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。

这并不是什么好事。

使⽤场景: 1、⽇志记录器:记录可能记录到本地硬盘、系统事件、远程服务器等,⽤户可以选择记录⽇志到什么地⽅。

2、数据库访问,当⽤户不知道最后系统采⽤哪⼀类数据库,以及数据库可能有变化时。

3、设计⼀个连接服务器的框架,需要三个协议,"POP3"、"IMAP"、"HTTP",可以把这三个作为产品类,共同实现⼀个接⼝。

注意事项:作为⼀种创建类模式,在任何需要⽣成复杂对象的地⽅,都可以使⽤⼯⼚⽅法模式。

有⼀点需要注意的地⽅就是复杂对象适合使⽤⼯⼚模式,⽽简单对象,特别是只需要通过 new 就可以完成创建的对象,⽆需使⽤⼯⼚模式。

设计模式(OOD)学习

设计模式(OOD)学习

设计模式(OOD)学习设计模式(Object-Oriented Design Patterns)是在软件开发中用来解决经常出现的问题的一种经验总结和方法论。

设计模式通过提供一套经过验证的解决方案来帮助开发人员更高效地设计和组织代码。

本文将介绍设计模式的概念、常见的设计模式分类以及一些常用的设计模式示例。

设计模式的概念设计模式是一种软件设计中的抽象,它描述了解决常见问题的一种方法。

它们不是一种具体的算法或代码实现,而是一种在特定情况下可重复使用的解决方案。

设计模式的目标是提高代码的可重用性、可读性和可维护性。

常见的设计模式分类常见的设计模式可以根据其目标和应用场景进行分类。

以下是几个常见的设计模式分类:1. 创建型模式(Creational Patterns)创建型模式关注对象的实例化过程。

它们提供了一种将对象的创建和使用分离的方法,隐藏了对象的创建细节。

- 单例模式(Singleton Pattern):保证一个类只有一个实例,并提供全局访问点。

- 工厂模式(Factory Pattern):通过使用工厂方法来创建对象,而不是直接使用new操作符。

- 抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们的具体类。

- 原型模式(Prototype Pattern):通过克隆现有对象来创建新对象。

- 建造者模式(Builder Pattern):将一个复杂对象的构建过程与其表示分离,使得同样的构建过程可以创建不同的表示。

2. 结构型模式(Structural Patterns)结构型模式关注类和对象的组合,通过定义对象之间的关系来实现更大的结构。

- 适配器模式(Adapter Pattern):将一个类的接口转换成客户希望的另一个接口。

- 装饰器模式(Decorator Pattern):动态地将新功能添加到对象中。

- 代理模式(Proxy Pattern):为其他对象提供一个代理以控制对这个对象的访问。

23种设计模式的经典运用

23种设计模式的经典运用

23种设计模式的经典运用介绍设计模式是解决软件设计中常见问题的可重复使用的解决方案。

本文将介绍23种经典的设计模式,并给出它们在实际开发中的应用示例。

通过学习这些设计模式,您将增加对软件设计的理解,并能够更好地解决问题。

创建型设计模式1.工厂方法模式(F a c t o r y M e t h o d)工厂方法模式通过定义一个创建对象的接口,但由子类决定实例化具体类。

这种方法可以延迟实例化过程,具有更高的灵活性和可扩展性。

应用场景:-在一个系统中,希望客户端与具体类的实例化解耦。

-希望通过增加具体类的扩展来增加系统的灵活性。

2.抽象工厂模式(A b s t r a c t F a c t o r y)抽象工厂模式提供一个接口,用于创建相关或依赖对象组。

这种模式将对象的实例化推迟到子类中,从而实现了解耦。

应用场景:-当一个系统独立于其产品的创建、组合和表示时。

-当需要一个系列的相互依赖的对象而无需指定其具体类时。

3.单例模式(S i n gl e t o n)单例模式确保一个类只有一个实例,并提供一个全局访问点。

这种模式常用于控制对资源的访问,例如数据库连接或日志文件。

应用场景:-当需要一个类的唯一实例,并且该实例需要被多个客户端共享时。

-当需要限制系统中特定类的实例数量时。

4.原型模式(P r o to t y p e)原型模式通过复制现有对象来创建新对象。

这种模式对于创建需要消耗大量资源的对象非常有用,可以通过克隆现有对象来提高性能。

应用场景:-当一个系统的某些对象的创建比较昂贵时。

-当需要避免构造函数调用,而直接通过复制现有对象来创建新对象时。

5.建造者模式(B ui l d e r)建造者模式将一个复杂对象的构建过程与其表现分离,使得相同的构建过程可以创建不同的表现。

应用场景:-当想要构建一些复杂对象时,如生成器。

-当需要创建对象的过程具有多个步骤,并且每个步骤都可以按需选择或省略时。

结构型设计模式6.适配器模式(A da p t e r)适配器模式将一个类的接口转换为客户端所期望的另一个接口。

Spring中常见的设计模式——装饰者模式

Spring中常见的设计模式——装饰者模式

Spring中常见的设计模式——装饰者模式一、装饰者模式的应用场景装饰者模式(Decorator Pattern)是指在不改变原有对象的基础上,将功能附加到对象上,提供了比继承更有弹性的方案(扩展原有对象的功能),属于结构型模式。

装饰者模式适用于以下场景:•扩展一个类的功能或给一个类添加附加职责。

•动态给一个对象天机功能,这些功能可以再动态的撤销。

以做煎饼果子为例演示装饰者模式是怎么装的:首先做一个煎饼果子抽象:public abstract class Battercake {protected abstract String getMsg();protected abstract Integer getPrice();}然后,做一个基本的煎饼果子:public class BaseBattercake extends Battercake{@Overrideprotected String getMsg() {return "煎饼";}@Overrideprotected Integer getPrice() {return 5;}}创建扩展套餐的抽象装饰者:public class BattercakeDecorator extends Battercake {//静态代理委派private Battercake battercake;public BattercakeDecorator(Battercake battercake) { this.battercake = battercake;}@Overrideprotected String getMsg() {return battercake.getMsg();}@Overrideprotected Integer getPrice() {return battercake.getPrice();}}创建加鸡蛋装饰类:public class EggDecorator extends BattercakeDecorator { public EggDecorator(Battercake battercake) {super(battercake);}@Overrideprotected String getMsg() {return super.getMsg() "add an egg";}@Overrideprotected Integer getPrice() {return super.getPrice() 1;}}客户端:public class BattercakeTest {public static void main(String[] args) {//基本版Battercake battercake = new BaseBattercake();//加蛋battercake = new EggDecorator(battercake);//再加battercake = new EggDecorator(battercake);//跟静态代理区别在于静态代理不是is-a关系晶体代理会做功能增强,使同一个职责变得不一样//装饰者模式更多考虑扩展}}二、装饰者模式和适配器模式对比装饰者模式和适配器模式都是包装模式(Wrapper Pattern),装饰者模式是一种特殊的代理模式,二者对比如下:装饰者模式适配器模式形式是一种非常特别的适配器没有层级关系,装饰者模式有层级关系定义装饰者和被装饰着实现同一接口,主要目的是为了扩展后依旧保留旧的oop关系适配器和被适配这没有必然的关系,通常采用继承或代理的形式进行包装关系满足is-a关系满足has-a关系功注重覆盖、扩展注重兼容、转换能设前置考虑后置考虑计三、装饰模式在源码中的应用JDK中的I/O,如BufferReader,InputStream,OutputStream.Spring的缓存,myabtis 的TransactionalCache(事物相关缓存):public class TransactionalCache implements Cache {private static final Log log = LogFactory.getLog(TransactionalCache.class);private final Cache delegate;...public TransactionalCache(Cache delegate) {this.delegate = delegate;...}...}四、装饰者模式的优缺点优点:•装饰者模式是继承的有力补充,比继承灵活,可以再不原有对象的情况下动态的给一个对象扩展功能,即插即用。

设计模式-装饰模式总结及实例

设计模式-装饰模式总结及实例
}
};
class BigTrouser : public Finery
{
pShow()
{
printf("跨裤");
__super::Show();
}
};
class Sneakers : public Finery
{
public:
virtual void Show()
实现方式(UML类图)
实现代码
#include <stdio.h>
class Person
{
public:
Person() : name(0){}
Person(char* _name) : name(_name){}
virtual void Show()
{
printf("装扮的%s",name);
}
virtual void Show()
{
printf("领带");
__super::Show();
}
};
class LeatherShoes : public Finery
{
public:
virtual void Show()
{
printf("皮鞋");
__super::Show();
}
};
int main()
kk->Decorate(pqx);
dtx->Decorate(kk);
dtx->Show();
printf("\n第二种装扮:\n");
LeatherShoes* px = new LeatherShoes();

软件开发中的设计模式及其应用

软件开发中的设计模式及其应用

软件开发中的设计模式及其应用随着计算机技术的快速发展,需要在开发软件时使用一些标准化的技巧和方法。

设计模式就是这些技巧和方法中的一个,它是编写高质量、易于维护和可重用的代码的利器。

设计模式将重复性的问题进行分类,并提供了一组通用的解决方案,这使得软件开发人员可以更快、更轻松地编写出高质量的代码。

在本文中,我们将介绍一些常用的设计模式,以及它们在实际软件开发中的应用。

1. 工厂模式(Factory Pattern)工厂模式是一种创建型设计模式,用来创建对象。

它将创建具体对象的过程委托给子类,由子类完成对象的创建过程,并返回对象。

使用工厂模式的好处是,它可以将对象的实现与客户端代码完全分离开来。

客户端只需要知道调用工厂方法(创建对象),而无需关心具体实现细节。

工厂模式适用于需要创建大量对象的开发场景,可以有效地降低系统的内存开销。

它还能够通过工厂的配置,动态地改变对象的创建方式,提高系统的灵活性和可扩展性。

2. 单例模式(Singleton Pattern)单例模式是一种创建型设计模式,它用来确保在整个应用程序中,一个类只有一个实例,并提供一个全局访问点。

单例模式在需要管理全局资源或共享状态时非常有用。

单例模式有多种实现方式,最常用的方法是通过私有构造函数和静态方法来实现。

这种方法可以确保只有一个类的实例,并提供一个全局访问点。

3. 装饰器模式(Decorator Pattern)装饰器模式是一种结构型设计模式,它提供了一种动态地将责任添加到对象上的方法。

装饰器模式允许我们通过在运行时添加新的功能,而不是通过编写新的子类来实现这些功能。

装饰器模式的基本思想是,创建一个装饰器类,该类包装了要装饰的对象,并提供了与原始对象一致的接口。

装饰器类可以在运行时添加新的行为,而不影响原始对象。

使用装饰器模式的好处是,它可以让我们动态地添加功能,而不需要从头开始重新设计类的结构。

此外,装饰器模式遵循单一责任原则,因此可以将不同的装饰器组合在一起,构建出复杂的对象。

反射技术使用到设计模式的例子

反射技术使用到设计模式的例子

反射技术使用到设计模式的例子反射是一种在运行时动态地获取类的信息并操作类或对象的能力。

它能够在不知道类的具体结构的情况下,通过类的名称或对象的实例来获取类的方法、字段、属性等信息,并能够动态地调用它们。

反射技术在软件开发中有广泛的应用,尤其在设计模式中,可以辅助实现一些灵活的设计和编程技巧。

下面列举了10个使用反射技术与设计模式结合的例子。

1. 工厂方法模式(Factory Method Pattern)在工厂方法模式中,通过反射可以实现动态加载具体的工厂类和产品类。

通过读取配置文件或者其他方式获取到类的名称,然后利用反射来创建工厂对象和产品对象,实现了工厂方法的动态性和灵活性。

2. 单例模式(Singleton Pattern)在单例模式中,通过反射可以绕过单例模式的限制,强制创建新的实例。

通过反射可以获取到私有的构造方法,并设置其可访问性为true,然后再创建新的实例。

这种方式一般不推荐使用,因为它会破坏单例的原则。

3. 观察者模式(Observer Pattern)在观察者模式中,通过反射可以动态地注册和注销观察者。

通过反射可以获取到观察者的方法,并动态地调用这些方法,实现观察者的通知和更新。

4. 桥接模式(Bridge Pattern)在桥接模式中,通过反射可以动态地切换和扩展桥接的实现。

通过反射可以获取到实现类的信息,并动态地创建和切换不同的实现类,实现桥接的灵活性和可扩展性。

5. 适配器模式(Adapter Pattern)在适配器模式中,通过反射可以动态地适配不同的接口。

通过反射可以获取到适配器的方法和目标接口的方法,并动态地调用它们,实现适配器的功能。

6. 装饰器模式(Decorator Pattern)在装饰器模式中,通过反射可以动态地添加和删除装饰器的功能。

通过反射可以获取到装饰器的方法和目标对象的方法,并动态地调用它们,实现装饰器的功能。

7. 策略模式(Strategy Pattern)在策略模式中,通过反射可以动态地选择和切换不同的策略。

C#设计模式系列:装饰模式(Decorator)

C#设计模式系列:装饰模式(Decorator)

C#设计模式系列:装饰模式(Decorator)1. 装饰模式简介 装饰模式动态地给⼀个对象添加额外的职责。

例如⼀幅画有没有画框都可以挂在墙上,画就是被装饰者。

但是通常都是有画框的。

在挂在墙上之前,画可以被蒙上玻璃,装到框⼦⾥,所以在画上加⼀层画框,并把它们组合成⼀个整体——有框的画。

这样随着不断有新的装饰的加⼊,就给商品不断地打上包装,变成⼀个功能更让⼈满意的商品。

这种不断打包装的过程就是装饰。

1.1 定义 装饰模式提供了⼀种给类增加功能的⽅法。

它通过动态地组合对象,可以给原有的类添加新的代码,⽽⽆须修改现有代码。

因此引⼊bug或产⽣意外副作⽤的机会将⼤幅度减少。

1.2 使⽤频率 中等2. 装饰模式结构图2.1 结构图2.2 参与者 装饰模式参与者: ◊ Component:定义⼀个对象接⼝,可以给这些对象动态地添加职责 ◊ ConcreteComponent:定义⼀个对象,可以给这个对象添加⼀些职责 ◊ Decorator:维持⼀个指向Component的指针,并定义⼀个与Component接⼝⼀致的接⼝ ◊ ConcreteDecorator:负责向ConcreteComponent添加功能 在装饰模式中,Decorator定义了⼀个装饰接⼝类。

因为Decorator与ConcreteComponent继承同⼀个接⼝,所以继承Decorator的类ConcreteDecorator可以使⽤ConcreteComponent的⽅法,再在ConcreteDecorator⾥⾯加⼊⼀些新的⽅法,也就是装饰,就成为了⼀个包装好的装饰类。

3、装饰模式结构实现 Component.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.DecoratorPattern.Structural{public abstract class Component{public abstract void Operation();}} ConcreteComponent.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.DecoratorPattern.Structural{public class ConcreteComponent : Component{public override void Operation(){Console.WriteLine("ConcreteComponent.Operation()");}}} Decorator.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.DecoratorPattern.Structural{public abstract class Decorator : Component{protected Component component;public void SetComponent(Component component){ponent = component;}public override void Operation(){if (component != null){component.Operation();}}}} ConcreteDecoratorA.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.DecoratorPattern.Structural{public class ConcreteDecoratorA : Decorator{public override void Operation(){base.Operation();Console.WriteLine("ConcreteDecoratorA.Operation()"); }}} ConcreteDecoratorB.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.DecoratorPattern.Structural{public class ConcreteDecoratorB : Decorator{public override void Operation(){base.Operation();AddedBehavior();Console.WriteLine("ConcreteDecoratorB.Operation()"); }void AddedBehavior(){}}} Program.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using DesignPatterns.DecoratorPattern.Structural; namespace DesignPatterns.DecoratorPattern{class Program{static void Main(string[] args){// Create ConcreteComponent and two DecoratorsConcreteComponent c = new ConcreteComponent();ConcreteDecoratorA d1 = new ConcreteDecoratorA();ConcreteDecoratorB d2 = new ConcreteDecoratorB();// Link decoratorsd1.SetComponent(c);d2.SetComponent(d1);d2.Operation();}}} 运⾏输出:ConcreteComponent.Operation()ConcreteDecoratorA.Operation()ConcreteDecoratorB.Operation()请按任意键继续. . .4、装饰模式应⽤分析 装饰模式适⽤情形: ◊ 在不影响其他对象的情况下,以动态、透明的⽅式给单个对象添加职责 ◊ 处理那些可以撤销的职责 装饰模式的特点: ◊ ⽐静态类更灵活。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

C# 设计模式之装饰者模式(Decorator Pattern)
1.概述
装饰者模式,英文名叫做Decorator Pattern 。

装饰模式是在不必改变原类文件和使用继承的情况下,动态地扩展一
个对象的功能。

它是通过创建一个包装对象,也就是装饰来
包裹真实的对象。

2.特点
(1)装饰对象和真实对象有相同的接口。

这样客户端对象就可以和真实对象相同的方式和装饰对象交互。

(2 )装饰对象包含一个真实对象的引用
(reference )(3)装饰对象接受所有来自客户端的请求。

它把这些请求转发给真实的对象。

( 4 )装饰对象可以在转发这些请求以前或以后增加一些附加功能。

这样就确保了在运行时,不用修改给定对象的
结构就可以在外部增加附加的功能。

在面向对象的设计中,
通常是通过继承来实现对给定类的功能扩展。

3.应用范围
1.需要扩展一个类的功能,或给一个类添加附加职责。

2.需要动态的给一个对象添加功能,这些功能可以再动态的撤销。

3.需要增加由一些基本功能的排列组合而产生的非常大
量的功能,从而使继承关系变的不现实
4.当不能采用生成子类的方法进行扩充时。

一种情况是,可能有大量独立的扩展,为支持每一种组合将产生大量的子类,使得子类数目呈爆炸性增长。

另一种情况可能是因为类定义被隐藏,或类定义不能用于生成子类。

4.优点
1.Decorator 模式与继承关系的目的都是要扩展对象的
功能,但是Decorator 可以提供比继承更多的灵活性。

2.通过使用不同的具体装饰类以及这些装饰类的排列组合,设计师可以创造出很多不同行为的组合。

(这一条更能体现)
5.缺点
1. 这种比继承更加灵活机动的特性,也同时意味着更加多的复杂性。

2. 装饰模式会导致设计中出现许多小类,如果过度使用,会使程序变得很复杂。

3.装饰模式是针对抽象组件 ( Component )类型编程。

但是,如果你要针对具体组件编程时,就应该重新思考你的
应用架构,以及装饰者是否合适。

当然也可以改变Component 接口,增加新的公开的行为,实现“半透明”的装饰者模
式。

在实际项目中要做出最佳选择
6.设计原则
1. 多用组合,少用继承。

利用继承设计子类的行为,是在编译时静态决定的,而且所有的子类都会继承到相同的行为。

然而,如果能够利用组合的做法扩展对象的行为,就可以在运行时动态地进行扩展。

2. 类应设计的对扩展开放,对修改关闭。

8. 模式简化(最后会给出 2 种写法仅供参考)
1. 如果只有一个Concrete Component 类而没有抽象的Component 接口时,可以让Decorator 继承Concrete Component 。

2. 如果只有一个Concrete Decorator 类时,可以将Decorator 和Concrete Decorator 合并。

9.代码示例
( 1 )抽象接口
///
/// 定义Component 对象接口
/// public abstract class Component
{
public abstract void Operation();// 一个抽象的职责}
///
/// 具体对象
///
class ConcreteComponent : Component {
public override void Operation()
{
Console.WriteLine(" 具体对象的操作");
}
}
//装饰者抽象类
abstract class Decorator : Component
{ protected Component component;
public void SetComponent(Component component)
{ ponent = component; } public override void
Operation()
if (component != null) {
component.Operation();
}
}
} class ConcreteDecoratorA : Decorator
{ public override void Operation()
{ base.Operation(); // 首先运行原Compnent 的Operation (),再执行本类的功能,如AddedBehavior, 相当于对原Component 进行了装饰Console.WriteLine(" 具体装饰对象 A 的操作");
}
}
class ConcreteDecoratorB : Decorator
{ public override void Operation()
{ base.Operation(); // 首先运行原Compnent 的Operation (),再执行本类的功能,如AddedBehavior, 相当于对原Component 进行了装饰Console.WriteLine(" 具体装饰对象 B 的操作");
2)无抽象接口
public class Car
{
public virtual void Description()
{
Console.Write(" 基本");
}
} public class ESPDecorator : Car
{
Car car;
public ESPDecorator(Car car)
{ this.car = car;
}
public override void Description()
{ car.Description();
Console.WriteLine(" 带有ESP 功能");
public class OtherDecorator : Car
{
Car car;
public OtherDecorator(Car car)
{ this.car = car;
}
public override void Description()
{
car.Description();
Console.WriteLine(" 带有其它功能");
}
}
代码调用
//第一种
ConcreteComponent c = new ConcreteComponent();
ConcreteDecoratorA d1 = new ConcreteDecoratorA();
d1.SetComponent(c);
ConcreteDecoratorB d2 = new ConcreteDecoratorB();
d2.SetComponent(c);
d2.Operation();
//第二种
Car car = new ESPDecorator(new OtherDecorator(new Car()));
car.Description();
Console.Read(); 人生若只如初见,何事西风悲画扇? 等闲变却故人心,却道故人心易变. 标签: 设计模式, 装饰者模式。

相关文档
最新文档