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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

⽽花瓶就是组件了。

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

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

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个常见的设计模式。

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

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

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

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

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

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

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

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

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

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

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

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

装饰器模式（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种设计模式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种设计模式，我将分享一些记忆技巧。

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）：定义一个算法的骨架，具体步骤由子类实现。