- 抽象类和混入类
接口又叫抽象类，需要在子类中实现，抽象类不能被实例化，非抽象类叫做具体类。
混入类给其他的类提供公共接口，可以被多个对象继承，作为对象的一部分。
- 对象的组合和继承
对象的继承：是在编译时候确定的，不能在运行时动态改变父类。父类代码的任何改变都会直接影响找到子类。
对象的组合：是通过获得其他对象的引用而在运行时动态定义的。运行时还可以用一个相同的对象替换另一个对象。
优先使用对象组合，而不是继承。但是使用继承要比创建新的构件容易，而且在编译时就确定。
使用组合将会有更好的复用性。
- 委托
委托是一种组合方法。例如一个对象要获得求圆对象的面积方法，我们只需在对象中定义一个求圆面积的方法并将圆对象的引用作为参数传入，从而委托圆对象返回自己的面积。
因为委托是基于对象组合的，也具有动态性，比静态的继承更难理解。
- 参数化类型
参数化类型，在定义类时不指定类型，在创建对象时以参数形式传入。传入什么参数就创建什么参数类型的对象。
- 懒汉和饿汉初始化
懒汉初始化：在需要使用的时候创建（注意考虑线程安全防止多次创建），饿汉初始化：在编译的时候就创建。
文章以下所有的斜体表示抽象类和对象，正常字体表示具体类和对象。
- 四人组GOF23
GoF（Gang of Four），中文名——四人组。
- SOLID设计七大原则
创建型模式
- 1.AbstractFactory—抽象工厂模式
1.将客户与类的实现分离。
2.客户通过抽象的接口操纵实例。
3.产品的类名被隔离，即它们不出现在客户代码中。
被抽象出来的接口就好像一个工厂（有造产品的方法），生产者（实现造产品的方法）根据不同的产品提供不同的造产品的方法。
工厂 – –> 产品，工厂根据方法生产出一模一样的产品。
缺点是：难以支持新种类的产品。
1 | class factory // 工厂 |
- 2.Build（生成器）—对象创建行模式
根据生成器里面的标志，决定使用生成器里面哪种方法进行生成。
1 | class Build // 接口抽象类 |
将具体的bulid算法和对象独立开，build中有各种各有的build算法，使用哪种算法取决于reader。
它将构造代码和表示代码分开，客户不需要知道产品具体的创建和装配方法。
bulid本身自己并不会创建和装配，build_A才会具体的创建和装配。
抽象工厂模式和build模式，都可以用来构建产品，只是抽象工厂侧重于快速构建一个一个的相同产品，build模式侧重于怎样一步一步的构建产品的过程。先ops_A–>ops_B–>ops_C.
- 3.Factory Method（工厂方法）–对象创建型模型
别名：虚构造器（工厂方法）
定义一个用于创建对象的接口，让子类决定实例化哪一个类。使一个类的实例化延时到子类。
当一个类不知道它应该创建什么样的对象的时候。
当需要委托另外一个类来帮助创建一个对象的时候。
就是在接口里面定义一个创建对象方法让别人去实现。
用于分层思想实现，上层只使用接口里面的函数，而下层负责实现里面的函数，上层委托下层，下层向上层提交工厂方法。
上层使用的参数对象都是虚的，它们具体的实现都在下层。上层就是一个工厂，只是提供了一个生成的环境，知道这个工厂能造什么产品，工厂怎么造产品的作业指导书是需要下层提供。
工厂方法主要用于工具包和框架中。
- 4.Prototype（原型）–对象创建型模式
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
构建一个通用的类（框架），通过在此框架扩展其它类。
实现一个原型管理器，所有的原型串起来。用于客户检索用，原型管理器即注册表。
克隆和实例化一个对象效果一样，会申请空间。克隆完后可再修改其中需要改变的地方，在抽象类添加一个init函数。
如对象里面有引用则需要进行深拷贝。
- 5.Singleton（单例模式）–对象创建型模式
保证一个应用的一个类只能被实例化一次，每次返回这个类的对象。
静态模式创建：在编译时分配空间，饿汉模式，动态模式创建：懒汉模式需要加锁并双重检测加voaliter，或者使用内部类，类里面包含一个类用于实例化对象。
结构型模式
- 6.Adapter（适配器）–类的结构型模式
适用于对一个以存在的类，但它的接口不符合你的需求。
对一个已存在的类进行扩展操作。
适配器使用多重继承，继承需适配和被适配类。
双向适配器。
类的适配器模式使用继承，对象的适配器模式使用的组合。
- 7.Bridge（桥接）–对象结构型模式
将接口和其实现部分分离，一个接口不一定只能绑定在一个实现上，在运行时可以动态改变实现。
改变一个实现类，并不需要重新编译abstraction类和它的客户端程序。
实现的细节对客户透明。
抽象接口在设计编译的时候就被确定，而接口的额实现是在运行的时候动态加载，这使得抽线接口和实现部分可以独立进行改变。
对它的接口和实现部分进行桥接。接口是稳定的，怎么实现是变化的。
事先知道抽象和实现两者是独立演化的，实现是有多种的。
- 8.Composite（组合）–对象结构型模式
将对象组合成树形的结构以表示“部分 - 整体”的层次结构。使得用户对单个对象和组合对象的使用具有一致性。
简单的Text和Line等小类，另外定义一个容器类包含这些小类。
将多个类组合起来挂载到一个容器类，提供一个统一的抽象接口给用户添加、删除、遍历，这有利于减少维护类的个数，减少程序复杂度。
rtthread的设备IO管理器就是使用组合模式实现。
组合类需要提供一个接口给各个小类实现。组合类中有一个由于串联存放这些接口实现的集合对象。
小类的基本对象也可以是组合类，这样小类又包含很多小小类，可以组成一个复杂的树形结构。
如果需要频繁的对组合对遍历查找，可以在组合类中设计一些缓存子节点的变量。
- 9.Decorator（装饰）–对象结构型模式
动态地给一个对象添加一些额外的职责。扩展对象功能。
采用继承的机制扩展父类，更加好的方法是保存引用的方法，比静态继承更灵活，防止多个子类继承产生许多新的类。
被添加进入的功能称为装饰品，用来装饰父类的。
装饰的对象接口必须与它所装饰的接口是一致的。所有的被装饰者必须有一个公共的父类。
策略模式可以改变对象的内核，而装饰模式仅改变对象的外观。
- 10.Facade（门面、外观）–对象结构型模式
为子系统定义一个一致的界面，Facade模式定义一个高层的接口，这个接口使得子系统更加容易使用。
将一个系统划分成为若干个子系统有利于降低系统的复杂性。一个常见的设计目标是使子系统间的通信和相互依赖关系达到最小。达到该目标的途径之一是就是引入一个外观。
编译器的外观可方便大多数程序员使用,同时对少数懂得如何使用底层功能的人,它并不隐藏这些功能，外观也叫用例。就是一个系统的使用场景。用户看得见的。
由于用户操作的是外观，程序中各个子系统被独立开。
如果用户想实现更加定制化的功能可以直接跨过外观。
客户通过发送请求的的方法给Facade通信，Facade将这些消息转发给适当的子系统对象。
使用Facade的客户端程序不需要直接访问子系统对象。
Facade模式有助于建立层次结构。
Facade模式可以消除复杂的循环依赖关系，这一点在客户程序和子系统分别实现的时候尤为重要。
- 11.Flyweight（享元）–对象结构型模式
运用共享技术有效地支持大量细粒度的对象。
每个共享对象是独立的，在不同实例下和普通的对象是一样的。
共享对象的粒度不可太小否则系统开销会过大。
共享对象不能保存除共享对象外的外部的状态，共享对象必须独立和别的对象无关。
共享对象池，保存一类共享对象。
频繁使用的对象有必要作为共享对象。
共享对象需要保证它的线程安全。
一般是一些不可变的对象来作为共享对象。
共享对象只会被创建一次，并保存在共享池中。下次如果有需要用到已有的共享对象只需要引用这个对象而不必再创建。
必须保证共享对象被创建后不会再修改，以保证其线程安全。
共享模式通常和组合模式一起使用。
- 12.Proxy（代理）–对象结构型模式
为其他对象提供一种代理以控制对这个对象的访问。
用一个简单的占用空间的小的对象，暂时表示一个大的对象，在需要正真用到大的对象的时候实例化大的对象，然后小的对象指向大的对象，外部通过这个小的对象访问大的对象，小的对象是大的对象的一个代理。
在正真需要对象的时候才分配空间初始化，而不是一开始就分配初始化好，用一个小的对象表示它，证明它的存在。
实例化的对象的操作由代理在需要的时候完成。
小对象代理大对象叫做虚代理。
还有远程代理、保护代理、智能指引。
保护代理：可以通过代理设置一道访问权限。
远程代理：类似映射，不同的地址空间访问。
智能指引：在访问一个对象的时候提供一些附加操作，检查是否已经锁定它，以确保其他对象不能改变它。
Proxy:保存一个引用使得代理可以访问实体。
subject：定义一个代理和实体的共用接口，这样在任何使用实体的地方都可以使用代理。
代理根据其种类在适当的时间向实体转发请求。
适配器模式是提供一个与适配对象不同的接口，而代理则相反，提供一个与被代理对象相同的接口。
装饰模式与代理的实现部分相似，但装饰的目的不一样。装饰是为了增加扩展功能，而代理是为了控制对象的访问。
小结：
适配器和桥接：适配器是对两个已经存在的类，使它们能相互沟通，适配器相当于一个翻译员。桥接是使用者事先知道了一个抽象会有很多实现，而设计的将抽象和实现分离，因为抽象和实现在以后需要独立演化。
门面和适配器：门面是定义一组新的接口，同一给对外访问。而适配器是复用原有接口。
代理模式和装饰模式：装饰模式是为了扩展对象的功能，而代理模式是为了控制对象的访问。两个模式的出发目的不同。
装饰模式和组合模式：装饰模式通过生成子类来给类添加功能。这避免了静态实现所有的功能，导致子类的急剧增加。而组合模式不同，组合模式通过构造一个新的容器类，将具有相同接口的类同一处理，把多个对象当做一个对象处理。它的重点不再修饰，而正在表示。将多个相似的类用一个类就可以表示出来。装饰模式和组合模式目的截然不同，而且恰好互补，因而通常将这两个模式在一起使用。
行为型模式
- 13.Chain of Responsiblity（责任链）–对象行为型模式
一个链表的所有节点候选对象可以处理请求，具体谁处理是隐式的，可以是候选对象中的任一个。
对于一个节点若可以处理，处理之，否则转发给下一个节点，直到这个请求被处理
降低了耦合度，对象无需知道具体是哪个对象处理请求，只需要向整条责任链发送请求。
也有可能整条责任链没有一个节点可以处理这个请求。
当一个事件产生，这个事件就沿责任链传播，责任链常和组合模式一起使用，组合的容器用来挂载处理对象。
- B站上的责任链
使多个对象都有机会处理请求，从而避免请求者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
一个请求可以分解成很多小的检测，如果小的检测失败整个检测返回失败（状态机是转移状态），否则继续下一步小的检测，这些小的检测通过一个链表连接起来。全部检测通过才正真转发给请求的接收者。
- 14.Command（命令）–对象行为型模式
将一个请求封装成一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队或记录日志，以及支持可撤销的操作。
这就是main_task工作队列的实现方法。封装命令类，创建命令调用类（存放命令的链表和执行命令），实例化命令对象，放入命令调用对象，命令调用对象执行list中所有的命令。
抽象出来待执行的动作以参数化某对象，你可以用过程语言的回调函数表达这种参数化机制。
所谓回调函数是指函数现在某处注册，而他将在稍后某个需要的时候被调用。
将调用操作的对象与知道如何实现该操作的对象解耦。
在被放入历史列表前必须被拷贝的命令起到一种原型的作用。
- 15.Interpreter（解释器）–类的行为模式
给定一个语言（如正则表达式、SQL语句），定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
当一种特定类型的问题经常发生，可以定义一个语句表示这一特定问题发生，一个解释器子类专门解释这个语句。
抽象语法树：抽象语法树中所有的节点所共享。
易于改变和扩展文法。
- 16.Iterator（迭代器）–对象行为模式
提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。
一个聚合对象例如列表。
迭代器主要是将聚合对象和他的遍历操作分离，使得聚合对象不需要在其内部实现遍历的操作。分离出迭代器可以有复用性，复用于各种聚合对象，而且可以在迭代器里面丰富各不同遍历操作，前序遍历、中序遍历、后序遍历。
rtthread的rt_list函数集就相当是一个迭代器，它让只要包含rt_list对象的对象都能使用这个迭代器进行遍历、插入、删除等操作。
index：记录当前的遍历节点信息。
外部迭代器和内部迭代器：
外部迭代器：由用户自己实现，可以更加灵活，必须用户自己手动推进遍历的步伐，显示的向迭代器请求下一个元素。
内部迭代器：客户只需要向迭代器发送一个迭代的指令，迭代器内部自动完成整个遍历。
谁定义遍历算法：如果是聚合对象本身实现遍历算法，在遍历的过程中迭代器只是用来储存当前迭代的状态，这种迭代器又称为游标。
在迭代的时候，删除、插入聚合对象是非常危险的，可能导致一个对象漏掉或被两次迭代。可以先复制一份聚合对象，保证插入删除操作不会影响迭代操作。
- 17.Mediator（中介者）–对象行为模式
用一个中间对象来封装一系列的对象交互，使各个对象不需要显式地互相引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
虽然一个系统分割成许多小的对象可以增强其复用性，但大量对象互相连接的激增会降低其可复用性。最坏的情况各个对象之间耦合紧密，不可分割。
将集体行为封装在一个单独的中介者对象来避免各个对象之间的紧耦合。中介负责协调各个对象工作，成为一个中转中心。
1)列表框告诉它的操作者它被改变了。
2)导控者从列表框中得到选中的选择项。
3)导控者将该选择项传递给人口域。
4)现在入口域已有正文,导控者使得用于发起一个动作(如“半黑体” , “斜体”)的某个按钮可用。
解决问题：
一组对象定义良好但他们之间通信复杂，产生相互依赖的关系难以理解。
一个对象引用很对其他对象并且直接与这些对象通信导致难以复用这个对象。
想定制一个分布在多饿类中的行为，但又不想生成太多的子类。
同事对象：各个对象
中介者使对象控制集中化，中介者和门面模式的区别：中介者是为了对象间协同工作对内来说的，门面模式是提供给客户使用的是对外来说的，中介模式类似于适配器模式，使对象和对象能够沟通。门面模式是对子系统进行抽象，从而提供宇哥方便的总接口，它的协议是单向的，而中介模式协议是双向的。
- 18.Memento（备忘录）–对象行为模式
在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，在以后就可以将该对象恢复到原先保存的状态。
别名：token
一个备忘录是一个对象，它储存另一个对象在某一瞬间的内部状态，这个瞬间状态叫做备忘录的原发器。当需要生成一个备份的时候，向原发器请求一个备忘录。
备忘录可以让其他对象直接得到一个对象的状态，而有不会暴露对象的实现细节并破环对象的封装性。
原发器new一个备忘录，从Memento获取状态到备忘录并返回这个备忘录指针。
备忘录是被动的，只有创建备忘录的原发器才会对它的状态赋值和检索。
- 19.Observer（观察者）–对象行为模式
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，多有依赖于它的对象都得到通知并自动更新。
别名：依赖，发布-订阅
关键对象：目标、观察者
一个目标也可以有任意数目的依赖它的观察者。一旦目标发生改变，所有的观察者都得到通知。作为对这个通知的响应，每个观察者都将查询目标以使其状态与目标的状态同步。
ConcreteObserver观察者维护一个指向目标的引用，以便在收到通知时观察者和目标进行状态同步。
观察者模式运行独立地改变目标和观察者，你可以单独复用目标对象而无需同时复用其观察者，反之亦然。
它也运行你在不该动目标和观察者的情况下增加观察者。
此模式类似与，notify工具：区别update的是具体的参数而 不是对象引用。
目标的每个观察者都符合抽象的Observer类的简单接口，目标和观察者不是紧密耦合，因此它们可以处于一个系统中不同的抽象层次。一个处于较低层次的目标对象可以和一个处于较高层次的观察者通信并通知它。
Observer类的简单接口：回调的函数的封装，属于观察者的。
支持广播，一对多。
观察多个目标的时候，必须扩展update接口以使观察者知道是哪个目标送来的通知然后去检查哪个目标。
拉模型和推模型：拉模型强调的是目标不知道它的观察者，而推模型假定目标知道一些观察者需要的信息。推模型可能难以复用因为它做出了假设，拉模型效率较差。
拉模型：目标除最小通知外，什么也不送出去。在此之后由观察者显式地向目标询问细节。
推模型：目标向观察者发送关于改变的详细信息，而不管观察者需要与否。
解决以上冲突：显示的指定感兴趣的改变，扩展目标的注册接口，让观察者注册仅对自己感兴趣的事件，以提高更新效率。类似与mqtt里面的主题概念。订阅主题，只接收与主题相关的数据。linux里面的消息队列也是基于这样的思想，队列会有一个主题链表，订阅的主题才会收到，首先查主题链表，不在这条主题链表上的消息收不到。
对以上增加一个更改管理器：
更改管理器分别实现不同的更新协议。当不存在多重更新是使用简单变化管理器就可以满足。
changManager是中介者模式的一个实现，中介两个已存在的目标和观察者对象。通常一个系统只有一个changManager，这里可以用单例模式实现。
RTOS的软件定时器就是基于观察者模式，启动一个软件定时器就是创建了一个观察者，硬件定时器（目标）中断中，改变管理器每1ms检查一次它的观察者如果有超时的定时器，则通知该观察者（软件定时器）。观察者接收到通知就知道它的定时时间到了。
观察者结合中介者模式，通过在中介中封装复杂的更新协议，作为更新管理器。
使用单例模式保证系统中只存在一个更新管理器，并且是可全局访问的。
- 20.State（状态）–对象行为模式
允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
别名：状态对象
这一模式引入一个TCPState的抽象类。
Context：环境，定义客户感兴趣的接口，维护一个指向ConcreteState子类的引用。
State：定义一个接口以封装与Context的一个特定状态相关的行为。抽象出来给客户调用的。
简而言之：Context中的State引用在不同的时候指向不同的对象实现。不同的时候表现出不同的行为。
状态模式：每个状态的行为定义成一个类，使得可以很容易地添加删除新的状态和转换，不用在Context的实现内部遍布使用case、if等判断，增加一个状态需要修改代码逻辑，使维护变得复杂。状态模式使得每个状态相互独立结构和程序意图清晰。使得状态转换显式化。
状态的State可以被共享，不光Context对象可以使用这个状态，其他的包含State引用的对象也可以使用。
上面都是说的哪个状态使用什么行为，具体到底谁负责控制状态的转换：需要在Context中增加一个设置状态的接口，显式地进行状态转换。
在ConcreteState中可以有一个指向下一个状态的后继状态，隐式进行状态的转换，类似一个责任链模式。但这种模式会时状态和状态之间产生依赖。
更好的方法是实现一个状态表，将状态的转换关系定义在一个状态表中。通过查表进制状态转换，这种叫做表驱动的状态机。
- 21.Strategy（策略）–对象行为型模式
定义一系列算法把他们一个个封装起来，并且使用他们可以互相替换。使得算法可以独立于它的客户而变化。
如果客户程序直接包含具体的算法实现，会使客户程序变得复杂。
不同的时候需要不同的算法。
当客户和算法混在一起时，要想新增或者修改一个算法变得时分困难。
将算法封装成一个个策略解决上述问题。
一个个算法被封装成策略定义在代码里面，需要使用的时候实例化并把Composition内的compositor引用指向该策略。
使用策略可以避免暴露复杂的与算法相关的数据结构。
一个个算法变成独立的可被其他对象复用。使算法易于切换、易于理解、易于扩展。
- 22.Template Method（模板方法）–类的行为型模式
定义一个操作的算法骨架，而将一些步骤延迟到子类。使得子类可以不改变一个算法的结构即可以重定义该算法的某些特定步骤。
就是抽像出一些特定步骤，并定义这些步骤的执行步骤（骨架），特定的执行步骤的细节延时到子类显示。这个抽象出来的骨架就叫做模板。
AbstractClass定义抽象的原语操作，具体的子类将实现他们。
模板方法是一种代码复用的基本技术，模板方法导致一种反向控制结构，即“别找我们，我们找你”，指一个父类调用子类的操作。
钩子操作：提供一种缺省的行为，子类可以在必要时进行扩展。缺省即公共的操作在父类就存在，在子类做其他的步骤补充。
钩子操作是强制执行的公共操作子类不必重写这些公共操作。子类需要把握哪些操作需被重新定义哪些是不需要重写的。
模板方法模式和工厂方法模式非常相似，只是模板方法里面多了一个实现算法骨架的模板方法。客户可以直接使用模板方法，或者使用各个步骤实现自己想要的步骤。
一次性实现算法不变的部分，并把它在TemplateMethod实现好。
1 | void TemplateMethod(void) |
- 23.Vistor（访问者）–对象行为模式
表示一个作用于某对象结构的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
简单说就是在一个原有的对象接口里面实现一个accept函数，accept函数接收一个Vistor对象指针，在Vistor对象里面实现一个访问函数这个函数接收一个this指针以访问对象里面所有的成员。Vistor是需要用户自己定义实现，类似于给原来的对象传一个Vistor对象指针（一个升级包，升级包可以访问对象里面的所有成员）以扩展原有对象的功能或者改变原有对象的私有成员的值。
一个使用Visitor模式的客户必须创建一个ConcreteVisitor对象，然后遍历该对象结构，并用该访问者访问每一个元素。
每个对象将有一个相关的Visitor类。这个抽象的类为每个ConcreteElement类声明一个VisitorConcreteElement操作。
行为模式的讨论
封装变化：当一个程序的某方面的特征经常发生改变时，这些模式就定义一个封装这方面的对象。这样当该程序的其他部分依赖这个方面时，他们都可以与此对象协作。通常封装一个抽象类。例如：
策略模式封装一个算法。
状态模式封装一个状态。
中介者模式封装对象之间的协议。
迭代器模式封装访问和遍历一个聚集对象中各个构建的方法。
对象作为参数：访问者模式（访问者作为参数）、命令模式（封装一个command对象作为参数）、备忘录模式（备忘录对象传给要恢复源的对象）。
对发送者和接收者解耦：当合作的对象直接互相引用时，它们互相依赖，这可能对整个系统的分层和复用产生负面影响。命令、观察者、中介者和职责链等模式都用于解决这个问题。
出少数例外情况，各个行为设计模式之间是互相补充和互相加强的关系。
原子操作（原语操作）：
内核或微核提供核外调用的过程或函数称为原语(primitive)。
原语是一段用机器指令编写的完成特定功能的程序,在执行过程中不允许中断。
在多进程（线程）的操作系统中不能被其它进程（线程）打断的操作就叫原子操作，文件的原子操作是指操作文件时的不能被打断的操作。
原子还有一层意思，当该次操作不能完成的时候，必须回到操作之前的状态，原子操作不可拆分。
所有原子操作是同步的，而且不可被外部中断（内中断可以，不过一般是致命错误处理）。
也就是说，原子操作是中断安全的。
结论
面向对象软件的生命周期分为几个阶段：原型阶段、扩展阶段、巩固阶段。
名词
抽象耦合：若类A维护一个指向抽象类B的引用，则称A抽象耦合于B。
相识关系：一个类指向另一个类，则这两个类之间有相识关系。
具体类：不含抽象操作的类，它可以实例化。
黑箱复用：一种基于对象组合的复用方式。这些被组合的对象不开放各自的内部细节，因此叫做“黑箱”。白箱复用反之。
耦合：软件构件之间互相依赖的程度。
委托：一种实现机制，即一个对象把发给它的请求转发/委托给另一个对象。而受委托的对象将代表原对象执行请求操作。
动态绑定：在运行时将一个请求与一个对象及其一个操作关联起来。C++中只有虚函数可以被动态绑定。
封装：其结构是将对象的表示和实现隐藏起来。在对象之外看不到其内部表示，也不能直接对其进行访问。操作是访问和修改对象表示的唯一途径。
框架（用例、外观）：一组相互协作的类，形成某类软件的一个可复用设计。矿建将设计划分一组抽象类，并定义他们各自的责任及相互之间的合作，以此来指导体系结构级的设计。开发者通过继承框架中的类和组合其实例来定制该框架以生成特定的应用。用例：用来描述系统中一个用户场景的一组对象集合，对象互相协作。
继承：一个实体是基于另一个实体定义的，子类继承父类的接口和实现。继承分接口继承和实现继承，接口继承：以一个或多个已有的接口为基础定义新的接口。实现继承：以一个或多已有实现为基础定义新的实现。
实例变量：定义部分对象表示的数据。C++中使用术语”数据成员“。
交互图：展示对象间请求流程的一种示意图。
接口：一个对象所有操作定义的型构的集合。接口刻划了一个对象可响应的请求的集合。
混入类：一种被设计为通过继承与其他类结合的类。混入类通常是抽象类。
对象(object) ：一个封装了数据及作用于这些数据的操作的运行实体。
对象组合(object composition)： 组装和组合一组对象以获得更复杂的行为。
对象图(object diagram ) ：描述运行时刻特定对象结构的示意图。
对象引用(object reference) ：用于标识另一对象的一个值。
操作( operation ) ：对象的数据仅能由其自身的操作来存取。对象受到请求时执行操作。在C++中,操作称为成员函数,而Smalltalk使用术语“方法”。
重定义(overriding)： 在一个子类中重定义(从父类继承下来的)操作。
参数化类型( parameterized type)： 一种含有未确定成分类型的类型。在使用时,将未确定类型处理成参数。在C++中,参数化类型称为模板( template )。
父类( parent class) ：被其他类继承的类。Smalltalk又称之为超类(superclass ), C++中又称之为基类(base class),有时又称为祖先类( ancestor class )。
多态( polymorphism ) ：在运行时刻接口匹配的对象能互相替换的能力。
私有继承( private inheritance ) ：在C++中,一种仅出于实现目的的继承。
协议( protocol ) ：接口概念的扩展,包含指明可允许的请求序列。
接收者(receiver ) ：一个请求的目标对象
请求( request) ：一个对象当受到其他对象的请求时执行相应的操作。通常请求又称为消息。
型构(signature)： 一个操作的型构定义了它的名称、参数和返回值。
子类(subclass ) ：继承了另一个类的类。在C++中,子类又称为派生类(derived class )。
子系统( subsystem ) ：一组相互协作的类形成的一个相对独立的部分,完成一定的功能。
子类型(subtype)： 如果一个类型的接口包含另一类型的接口,则前一类型称为后一类型的子类型。
超类型( supertype)： 为其他类型继承的父类型。
工具箱(tookit ) ：一组提供实用功能的类,但它们并不包含任何具体应用的设计。
类型(type)：一个特定接口的名称。
白箱复用( white-box reuse) ：一种基于类继承的复用。子类复用父类的接口和实现,但它也可能存取其父类的其他私有部分。
三种图示例：
- 本文作者： 龙兄嵌入式
- 本文链接： https://hexo.880755.xyz/1970/01/01/zblog/download/90.GOF23设计模式/