面向对象设计原则和23个设计模式的笔记

Gof的23种设计模式从2005年初听说设计模式，到现在虽然已经8年多了，但GoF的23种模式依然盛行，当然GoF提出这些模式的年代更加久远（1995年）。

在工作的过程中，陆陆续续接触了GoF的大部分模式，我记得在2008年的时候就想总结一下设计模式（最近想做的两件事情），最后因为各种原因也没有完成。

最近这段时间正好是职业空档期，没什么事儿做，就把之前看过的设计模式翻出来整理了一下，于是就有了上面几篇文章。

整理设计模式的过程，也是一个深刻理解面向对象设计的过程。

通过对各个模式的回顾，让我更能够明白前辈们关于面向对象设计提出的各种“最佳实践”，特别是S.O.L.I.D，我觉得在这里再说一次，也不算矫情。

S：单一职责原则（Single Responsibility Principle, SRP），一个类只能有一个原因使其发生改变，即一个类只承担一个职责。

O：开放-封闭原则（Open-Close Principle, OCP），这里指我们的设计应该针对扩展开放，针对修改关闭，即尽量以扩展的方式来维护系统。

L：里氏替换原则（Liskov Subsititution Principle, LSP），它表示我们可以在代码中使用任意子类来替代父类并且程序不受影响，这样可以保证我们使用“继承”并没有破坏父类。

I：接口隔离原则（Interface Segregation Principle, ISP），客户端不应该依赖于它不需要的接口，两个类之间的依赖应该建立在最小接口的基础上。

这条原则的目的是为了让那些使用相同接口的类只需要实现特定必要的一组方法，而不是大量没用的方法。

D：依赖倒置原则（Dependence Inversion Principle, DIP），高层模块不应该依赖于低层模块，两者应该都依赖于抽象；抽象不依赖于细节，而细节应该依赖于抽象。

这里主要是提倡“面向接口”编程，而非“面向实现”编程。

设计模式，从本质上讲，是针对过去某种经验的总结。

面向对象程序设计课堂笔记1.面向对象编程(OOP)的概念：OOP是一种编程范式，其核心思想是将现实世界的事物抽象成类、对象等概念，通过封装、继承、多态等特性来实现代码的复用、可维护性和可扩展性。

2. 类和对象的概念：类是一种抽象的概念，用来描述一类具有相同特征与行为的事物；对象是类的一个具体实例，它具有该类定义的属性和行为。

3. 封装的概念：封装是OOP的一种基本特性，它将数据和行为封装在一个类中，外部无法直接访问类内部的数据，只能通过类提供的公共接口(方法)访问和修改数据。

4. 继承的概念：继承是OOP的一种基本特性，它允许子类继承父类的属性和行为，并可以在此基础上扩展和重写父类的方法。

5. 多态的概念：多态是OOP的一种基本特性，它允许不同的对象对同一消息做出不同的响应，即同一方法在不同对象上的表现形式不同。

6. 接口的概念：接口是一种抽象的概念，用来描述一个类所提供的方法和属性，而不涉及具体的实现细节。

它可以让多个类实现相同的接口，从而提高代码的灵活性和可扩展性。

7. 设计模式的概念：设计模式是一种被广泛应用的编程思想，它提供了一套经验丰富的解决方案来解决常见的软件设计问题，如单例模式、工厂模式、观察者模式等。

8. SOLID原则的概念：SOLID原则是面向对象设计的基本原则，它由5个原则组成，分别是单一职责原则、开闭原则、里式替换原则、接口隔离原则和依赖倒置原则。

这些原则旨在提高代码的可读性、可维护性和可扩展性。

9. UML图的概念：UML图是一种用来描述软件系统结构和行为的标准化图形语言，它包括用例图、类图、时序图、活动图等多种类型，可以帮助开发人员更好地理解和设计软件系统。

10. 实践中的应用：在实际的编程中，需要根据具体的业务需求和设计要求来运用面向对象的思想和技术进行程序设计。

同时，也需要不断学习和掌握新的技术和工具，以提高自己的编程能力和水平。

设计模式Design Pattern面向对象研究的新领域起源Gof (Gang Of Four，“四人帮”)设计模式什么叫模式？设计模式：研究现状设计模式的研究现状模式的分类(gof提出的23个)类Factory Method Adapter (类)InterpreterTemplate Method对象Abstract FactoryBuilderPrototypeSingletonAdapter (对象)BridgeCompositeDecoratorFacadeFlyweightProxyChain of ResponsibilityCommandIteratorMediatorMementoObserverStateStrategyVisitor模式Bridge(桥梁)案例最初的设计需求变化：鸟类要会飞如果增加一种鸟类“企鹅”呢？改进方法：对“飞”使用多态改进方法：再次使用继承如果增加“游泳”行为呢？继承只会使得问题越来越复杂继承是面向对象的基本法宝啊？？设计原则1：组合优先继承复用的优点继承复用的缺点优点组合复用的点组合复用的缺组合优先例1：如果使用继承来描述：使用“组合”思路考虑问题响区分“Is-A”与“Has-A”问题换一个角度看问题是什么导致设计的不完美？设计者的理想设计原则2：封装可变性“发现变化点”“封装变化点”“封装变化点”“封装变化点”“使变化点和不变点独立开来”“鸟类”和“行为”什么关系？拥有鸟儿拥有飞、游泳的行为使用桥梁模式的效果增加增加增加原有代码不需要改动！使用桥梁模式的效果设计原则3：开-闭原则结构意图适用性应用举例1：“小朋友画画”蜡笔和毛笔的差别体现了Bridge模式应用举例2传统的设计Draw()Draw()Draw()应用Bridge 模式DrawLine()DrawCircle()DrawLine()DrawCircle()Draw()Draw()Draw()DrawLine()DrawCircle()分析设计原则：开-闭原则、封装可变性“开-闭”原则解释设计原则：开-闭原则、封装可变性Bertrand Meyer设计原则：开-闭原则、封装可变性玉帝遵照“开-闭”原则维护天庭秩序设计原则：开-闭原则、封装可变性分析设计原则：开-闭原则、封装可变性分析设计原则：开-闭原则、封装可变性“封装可变性原则”。

软件设计师的面向对象设计和设计模式在软件开发领域，面向对象设计和设计模式是软件设计师必备的核心知识。

面向对象设计是一种以对象为核心的设计思想，强调将系统的功能模块划分为独立的对象，并通过对象之间的交互实现系统的整体功能。

而设计模式则是针对常见问题的解决方案，通过提供经过实践验证的设计方法来解决软件开发中的复杂性。

一、面向对象设计的基本原则面向对象设计的基本原则有四个：单一职责原则、开放封闭原则、里氏替换原则和依赖倒置原则。

1. 单一职责原则：一个类只应该有一个单一的功能或职责。

这样可以确保类的职责清晰明确，降低代码复杂度，提高代码的可维护性。

2. 开放封闭原则：软件实体应该是可扩展的，但是不可修改的。

通过对扩展进行开放，对修改进行封闭，可以实现代码的复用性和可维护性。

3. 里氏替换原则：子类对象应该能够替换父类对象，并且保持程序的逻辑行为不发生变化。

这样可以保证系统的稳定性和灵活性。

4. 依赖倒置原则：高层模块不应该依赖于低层模块，二者都应该依赖于抽象。

通过依赖倒置可以减少模块间的耦合性，提高代码的可拓展性。

二、常用的设计模式1. 创建型设计模式创建型设计模式包括：Singleton（单例模式）、Factory Method（工厂方法模式）、Abstract Factory（抽象工厂模式）、Builder（建造者模式）、Prototype（原型模式）等。

这些模式主要用于对象的创建，根据实际需求选择合适的创建型模式，可以提高系统的灵活性和可维护性。

2. 结构型设计模式结构型设计模式包括：Adapter（适配器模式）、Bridge（桥接模式）、Composite（组合模式）、Decorator（装饰者模式）、Facade （外观模式）、Proxy（代理模式）等。

这些模式主要用于对象的组合和组织，通过结构型模式可以实现系统的灵活性和可扩展性。

3. 行为型设计模式行为型设计模式包括：Observer（观察者模式）、Strategy（策略模式）、Template Method（模板方法模式）、Command（命令模式）、State（状态模式）等。

面向对象程序设计听课笔记一、面向对象程序设计基本概念1.1 什么是面向对象程序设计面向对象程序设计是一种程序设计方法，它以对象为中心，将系统看作一组对象的集合，对象之间通过消息传递进行通信和合作。

面向对象程序设计强调抽象、封装、继承和多态等概念，从而使得程序更易于维护、扩展和重用。

1.2 面向对象程序设计的特征面向对象程序设计具有以下特征：- 封装：将数据和相关的操作封装到对象中，隐藏内部实现细节，提供统一的接口。

- 继承：通过继承机制，可以将已有的类的属性和方法继承到新的类中，并在此基础上进行扩展。

- 多态：同一个方法在不同对象中有不同的行为，使得代码更灵活、可复用。

1.3 面向对象程序设计的优点面向对象程序设计具有以下优点：- 代码重用：通过继承和多态等特性，可以提高代码的重用率，降低开发成本。

- 可维护性：封装性使得内部实现对外部不可见，可以减少代码耦合，使系统更易于维护。

- 扩展性：通过继承和多态，系统可以更容易地进行功能扩展，适应需求变化。

- 抽象性：面向对象程序设计可以更好地进行问题领域的建模，提高系统的抽象能力。

二、面向对象程序设计的基本原则和模式2.1 单一职责原则单一职责原则要求一个类应该只有一个引起变化的原因，即一个类应该只负责一个职责。

这样可以降低类的复杂度，提高代码的易读性和可维护性。

2.2 开放-封闭原则开放-封闭原则要求软件实体应该对扩展开放，对修改封闭。

即当需求变化时，不应该修改原有的代码，而是通过扩展来实现功能的变化。

2.3 里氏替换原则里氏替换原则要求在一个系统中，子类型必须能够替换掉它们的基类型而不改变系统的任何属性。

这意味着继承关系应该是合理的、可靠的。

2.4 接口隔离原则接口隔离原则要求一个类对另一个类的依赖应该建立在最小的接口上。

这样可以降低依赖关系的耦合度，提高系统的灵活性和可维护性。

2.5 依赖倒置原则依赖倒置原则要求高层模块不应该依赖于低层模块，二者都应该依赖于抽象。

23种设计模式详解设计模式是指面向对象编程中，经过多次验证、被广泛接受的代码实现方法。

这些设计模式可以帮助开发者更快地解决问题，提高代码的可读性、可维护性、可扩展性。

目前，常用的设计模式有23种。

下面，我们来详细介绍一下这23种设计模式。

1. 单例模式(Singleton)单例模式是一种只允许生成一个实例的模式。

在实例化对象时，单例模式的生成过程比较特殊，需要先判断该类是否已经实例化过，如果已经实例化，则直接返回已有的实例对象，否则再进行实例化。

2. 工厂模式(Factory)工厂模式是一种生产对象实例的设计模式。

它将对象实例的生成过程封装在一个工厂类中，客户端需要对象时，只需要调用工厂类中对应的方法即可。

3. 抽象工厂模式(Abstract Factory)抽象工厂模式是一种扩展了工厂模式的模式。

它可以生成一系列相关或相互依赖的对象实例。

具体实现时，通常需要定义一个抽象工厂类和一些具体工厂类，来生产各种相关的对象实例。

4. 建造者模式(Builder)建造者模式是一种用于构建复杂对象的模式。

它将一个复杂对象的构建过程分解成多个简单的步骤，然后通过一个指挥者来管理这些步骤的执行，最终构建出一个复杂的对象。

5. 原型模式(Prototype)原型模式是一种通过复制已有对象来创建新对象的模式。

一般来说，系统中的对象包含大量相同或相似的部分，通过复制对象可以帮助我们节省生成对象的时间和资源。

6. 适配器模式(Adapter)适配器模式是一种将不兼容接口转换为兼容接口的模式。

具体实现时，需要定义一个适配器类，该类实现了客户端所期望的接口，而且还包装了原有不兼容的接口，使其能够兼容客户端期望的接口。

7. 桥接模式(Bridge)桥接模式是一种将抽象部分与其实现部分分离开来的模式。

具体实现时，需要定义抽象部分和实现部分的接口，然后定义一个桥接类，将抽象部分和实现部分联系起来。

8. 组合模式(Composite)组合模式是一种将具有相同属性和方法的对象组合成树形结构的模式。

面向对象23种设计模式系列（一）-创建型设计模式本章是面向对象23种设计模式系列开篇，首先我们来看下什么是设计模式？面向对象23种设计模式：1、面向对象语言开发过程中，遇到的种种场景和问题，提出了解决方案和思路，沉淀下来就变成了设计模式。

2、解决具体问题的具体招数---套路---站在前辈的肩膀上。

3、没有什么设计模式是完美无缺的，一种设计模式就是解决一类问题，通常设计模式在解决一类问题的同时，还会带来别的问题，我们设计者要做的事儿，就是要扬长避短，充分发挥长处！设计模式可以大概分为三大类：1、创建型设计模式：关注对象的创建。

2、结构型设计模式：关注类与类之间的关系。

3、行为型设计模式：关注对象和行为的分离。

我们要做的就是学习核心套路，这里就不做过多的描述，如果有机会会通过具体例子再和大家分享。

下面我们正式进入本章主题。

创建型设计模式：关注对象的创建。

（5个）1、单例模式（Singleton Pattern）单例模式：就是限制了对象的创建，重用了对象。

保证进程中，某个类只有一个实例。

即使是单例，变量也不是线程安全的，单例不是为了保证线程安全。

单例的好处就是单例，就是全局唯一的一个实例。

应对一些特殊情况，比如数据库连接池(内置了资源) ，全局唯一号码生成器。

单例可以避免重复创建，但是也会常驻内存，除非是真的有必要，否则就不要使用单例。

1.1、单例模式经典写法（懒汉式）using System;using System.Threading;namespace Singleton Pattern{/// <summary>/// 懒汉式单例模式（经典写法）/// 单例类：一个构造对象很耗时耗资源类型。

/// </summary>public class Singleton{/// <summary>/// 构造函数耗时耗资源/// </summary>private Singleton(){long lResult = 0;for (int i = 0; i < 10000000; i++){lResult += i;}Thread.Sleep(2000);Console.WriteLine("{0}被构造一次", this.GetType().Name);}/// <summary>/// 全局唯一静态重用这个变量/// volatile 促进线程安全让线程按顺序操作/// </summary>private static volatile Singleton _singleton = nul l;/// <summary>/// 引用类型对象/// </summary>private static readonly object lockSingleton = n ew object();/// <summary>/// 公开的静态方法提供对象实例/// </summary>/// <returns>/// </returns>public static Singlet on CreateInstance(){if (_singleton == null) //_singleton已经被初始化之后，就不要进入锁等待了 {//保证任意时刻只有一个线程进入lock范围//也限制了并发，尤其是_singleton已经被初始化之后，故使用了双if 来解决并发限制问题lock (lockSingleton){//Thread.Sleep(1000);//Console.WriteLine("等待锁1s之后才继续。

1.⾯向对象设计模式和原则设计模式简介:每⼀个模式描述了⼀个在我们周围不断重复发⽣的问题,以及该问题解决⽅案的核⼼.设计模式描述了软件设计过程中某⼀类常见问题的⼀般性的解决⽅案。

⾯向对象设计模式描述了⾯向对象设计过程中、特定场景下、类与相互通信的对象之间常见的组织关系。

设计模式与⾯向对象⾯向对象设计模式解决的是“类与相互通信的对象之间的组织关系，包括它们的⾓⾊、职责、协作⽅式⼏个⽅⾯。

⾯向对象设计模式是“好的⾯向对象设计”，所谓“好的⾯向对象设计”是那些可以满⾜“应对变化，提⾼复⽤”的设计。

从编程语⾔直观了解⾯向对象各种⾯向对象编程语⾔相互有别，但都能看到它们对⾯向对象三⼤机制的⽀持，即： “封装、继承、多态”– 封装，隐藏内部实现– 继承，复⽤现有代码– 多态，改写对象⾏为(override 覆写/重写)OOPL的三⼤机制“封装、继承、多态” 可以表达⾯向对象的所有概念，但这三⼤机制本⾝并没有刻画出⾯向对象的核⼼精神。

换⾔之，既可以⽤这三⼤机制做出“好的⾯向对象设计”，也可以⽤这三⼤机制做出“差的⾯向对象设计”。

不是使⽤了⾯向对象的语⾔（例如C#），就实现了⾯向对象的设计与开发！因此我们不能依赖编程语⾔的⾯向对象机制，来掌握⾯向对象。

任何⼀个严肃的⾯向对象程序员（例如C#程序员），都需要系统地学习⾯向对象的知识，单纯从编程语⾔上获得的⾯向对象知识，不能够胜任⾯向对象设计与开发。

⾯向对象的好处是降低改变的影响!扩展⽐改变好,不需要重新编译!对象是什么？– 从概念层⾯讲，对象是某种拥有责任的抽象。

– 从规格层⾯讲，对象是⼀系列可以被其他对象使⽤的公共接⼝(供别⼈使⽤)。

– 从语⾔实现层⾯来看，对象封装了代码和数据。

(对象封装了⾏为和状态)从设计原则到设计模式• 针对接⼝编程，⽽不是针对实现编程– 客户⽆需知道所使⽤对象的特定类型，只需要知道对象拥有客户所期望的接⼝。

• 优先使⽤对象组合，⽽不是类继承– 类继承通常为“⽩箱复⽤”，对象组合通常为“⿊箱复⽤”。

面向对象程序设计听课笔记面向对象程序设计（Object-Oriented Programming，简称OOP）是一种编程范式，它使用“对象”来设计软件和应用程序。

以下是关于面向对象程序设计的一些基本概念和特性的听课笔记：对象（Object）：对象是现实世界事物的抽象，包含了数据（属性）和方法。

类（Class）：类是对对象的抽象，描述了具有相同属性和方法的对象的集合。

类定义了对象的结构。

封装（Encapsulation）：封装是面向对象编程的一个重要原则。

它隐藏了对象的内部状态，只通过对象的方法进行交互。

这增加了代码的安全性和可维护性。

继承（Inheritance）：继承是从已有的类派生出新的类。

新类继承了原始类的属性和方法，并且可以添加或覆盖它们。

这允许代码的重用，并形成一种“is-a”关系。

多态（Polymorphism）：多态是指一个接口可以有多种实现方式，或者一个对象可以表现出多种形态。

多态增加了代码的灵活性和可扩展性。

抽象（Abstraction）：抽象是通过隐藏对象的某些细节，只展示必要的信息，使得使用者可以集中精力处理更高级别的概念。

消息传递（Message Passing）：在面向对象编程中，对象之间的通信通常通过发送和接收消息来实现。

消息是一个对象向另一个对象请求服务的方式。

设计模式（Design Patterns）：设计模式是解决常见问题的最佳实践。

它们提供了一种框架，可以在不同的情境下复用。

接口（Interfaces）：接口定义了一组方法，但不提供这些方法的实现。

实现接口的类必须提供这些方法的实现。

这允许了代码的灵活性和可扩展性。

异常处理（Exception Handling）：异常处理是处理程序运行时可能出现的错误或异常情况的一种机制。

它有助于提高程序的稳定性和可靠性。

以上是面向对象程序设计的一些基本概念和特性。

理解和掌握这些概念和特性是编写高质量面向对象程序的关键。

面向对象程序设计听课笔记一、引言面向对象程序设计是一种重要的程序设计方法，它以对象为中心，将问题分解为一系列的对象，并通过对象之间的交互来解决问题。

本次听课将深入探讨面向对象程序设计的基本原理、特点和应用实践。

二、面向对象程序设计的基本原理1. 对象对象是面向对象程序设计的基本单位，可以是现实世界中的实体，也可以是程序中的抽象概念。

对象包含属性和方法，能够对外部环境做出响应。

2. 封装封装是面向对象程序设计的重要特点，它将对象的属性和方法封装在一起，对外部隐藏对象的实现细节。

这样可以提高程序的安全性，降低耦合性，也便于维护和复用。

3. 继承继承是面向对象程序设计的另一个基本特点，它允许一个类继承另一个类的属性和方法，实现了代码的重用和扩展。

通过继承，可以构建更为复杂的对象和类层次结构。

4. 多态多态指的是同一个方法调用可以根据不同的对象具体实现而具有不同的行为。

通过多态，程序可以更加灵活地处理不同的对象，提高代码的可读性和扩展性。

三、面向对象程序设计的应用实践1. 类的设计与实现在面向对象程序设计中，类是对象的模板，它定义了对象的属性和方法。

在应用实践中，需要合理设计和实现类，包括考虑类的单一责任、高内聚、低耦合等原则。

2. 对象的交互与通信面向对象程序设计强调对象之间的交互和通信，通过消息传递实现对象之间的调用和协作。

在实践中，需要设计对象之间的合理通信方式，确保系统的正常运行。

3. 设计模式的应用设计模式是面向对象程序设计的重要组成部分，它提供了一些通用的解决方案来解决常见的设计问题。

在实践中，需要灵活运用设计模式，提高程序的可维护性和扩展性。

四、总结与展望面向对象程序设计是一种强大的程序设计方法，它提供了一种有效的方式来组织和管理程序的复杂性。

本次听课通过深入讨论面向对象程序设计的基本原理和应用实践，对我们深入理解和运用面向对象程序设计具有重要意义。

希望在未来的学习和工作中，能够更加灵活、高效地运用面向对象程序设计方法解决实际问题。

设计模式目 录一、 行为模式 (2)1、 命令模式 (2)2、 观察者模式 (2)3、 策略模式 (3)4、 责任链模式 (4)5、 迭代器模式 (5)6、 中介者模式 (5)7、 状态模式 (6)8、 模板方法模式 (7)9、 访问者模式 (7)10、 备忘录模式 (8)11、 解释器模式 (9)二、 结构型模式 (9)12、 适配器模式 (9)13、 桥接模式 (10)14、 组合模式 (11)15、 装饰模式 (11)16、 外观模式 (12)17、 代理模式 (12)18、 享元模式 (13)三、 创建型模式 (14)19、 工厂方法模式 (14)20、 抽象工厂模式 (14)21、 建造者模式 (15)22、 原型模式 (16)23、 单件模式 (17)一、 行为模式1、命令模式将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。

自己的理解：将命令的发起者与命令的执行者分离，实现他们之间的松耦合关系。

这样可以方便地添加和实现各种不同命令。

参与者：mand声明执行操作的接口。

2.ConcreteCommand将一个接收者对象绑定于一个动作。

调用接收者相应的操作，以实现Execute。

3.Invoker要求该命令执行这个请求。

4.Receiver知道如何实现与执行一个请求相关的操作。

任何类都可能作为一个接收者。

2、观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

自己的理解：当一个主题发生变化后，多个观察者需要作出反应时，可以将这些观察者在其观察的主题处进行注册。

当该主题变化后，就通知所有在它这里注册的观察者。

主题的更新与观察者的反应分离，这样实现主题和观察者之间的松耦合关系。

参与者：1.Subject（目标）目标知道它的观察者。

可以有任意多个观察者观察同一个目标。

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)外观模式提供一个统一的接口，用于访问子系统中的一群接口。

面向对象程序设计课堂笔记一、什么是面向对象程序设计。

面向对象程序设计（Object-Oriented Programming，OOP）是一种编程范式，它将现实世界看作由各种对象组成，每个对象都具有不同的属性和行为，并且可以与其他对象进行交互。

二、面向对象程序设计的三大特征。

1. 封装（Encapsulation）。

封装是指将数据和操作数据的方法进行封装，构成一个类。

通过对外提供公共的方法和属性，类的内部实现可以隐藏起来，保证类的安全性和可维护性。

2. 继承（Inheritance）。

继承是指子类可以继承父类的属性和方法，并且可以在此基础上进行扩展。

这样可以提高代码的复用性和可维护性，同时也有助于层次化设计。

3. 多态（Polymorphism）。

多态是指同一个类的对象可以呈现不同的形态。

多态的实现是通过继承和接口实现的。

多态可以提高代码的灵活性和可扩展性。

三、面向对象程序设计的基本要素。

1. 类（Class）。

类是面向对象程序设计的基本组成单位，是一种抽象数据类型。

类的属性和方法决定了对象的特征和行为。

2. 对象（Object）。

对象是类的实例，每个对象都有自己的属性和方法，可以与其他对象进行交互。

3. 属性和方法（Property and Method）。

属性和方法是类的两个基本元素，属性是对象的特征或状态，方法是对象具有的行为或动作。

4. 继承（Inheritance）。

继承是一种代码复用的方式，子类可以继承父类的属性和方法，并且可以在此基础上进行扩展。

继承可以实现代码的层次化设计。

5. 重载（Overload）和重写（Override）。

重载是指在一个类中定义多个同名方法，但是参数类型、个数或顺序等不同，以提供更多的操作方式。

重写是指子类重写父类的方法，可以实现多态的功能。

6. 接口（Interface）。

接口是一种规范，规定了类必须实现的一组方法。

它可以实现多态和代码的松耦合。

四、面向对象程序设计的思想和技术。