设计模式，快速入门笔记精讲原创

嗯。大家好，我是软件183陈豪，然后呢，下面呢，我们将正式进入到设计模式的学习，然后在这一章中呢，我将给大家介绍简单的介绍一下设计模式的诞生与发展，还有设计模式的定义与分类，另外呢，还要给大家介绍一下我们将要学习的学习的G常用的设计模式。然后还会简单的介绍一下设计模式的优点，嗯，还有最后介绍一下它那个设计模式的，呃，七大原则。首先呢，呃，在介绍设计模式之前，给大家介绍一下这个模式的诞生。其中呢，它它这个模式，它最初的起源，它不在于咱们的软件行业，而是起源于建筑行业，它世界上第一个就是系统研究的设计，设计模式的人是美国加利福尼亚大学的一个呃研究所所长。叫Christopher。

Alexander。然后这个人呢？呃，他是一个呃，他被我们尊称为设计模式的嗯，设计模式之父，然后在20世纪70年代的时候，他的原他的团队，呃研究了大量的建筑和城市规划的一些呃模式，然后并将这些模式记录到他的他的基本的一个经典的著作中。然后其中的一本就是嗯，建建筑模式语言，然后城镇建筑构造。然后其中呢，它它它的模式中的一个有三个三个基本要素，其中的一个是呃。然后叫做环境。其就是属于模式可适用的一个前提条件，然后还有一个第二个机子素是嗯，也可以称之为problem。就是在特定条件下要解决的一个目标的一个问题。然后第三个是solution，然后这个呢，是对目标问题求解过程中的一个，就是物理关系的一个技术，也就是咱们如何去解决这个问题的方法。

那么简单的说，什么是模式呢？嗯。模式就是我们在现实生活中他不断出现的问题，然后就是前人呢，他呃总结出了一些比较成功的并且有效的一些方案。然后我们学习模式的过程呢，其实就是对前人一些专家经验的一个学习的过程。然后其中呢，这个Alexander然后给出的一个模式的一个经典的定义。就是每个模式都描述，都描述了一个在我们的环境中不断出现的问题。然后描述了该问题的解决方案的核心。然后通过这个这种方式呢，我们可以无数次的使用啊这些。已有的解决方案就是不需要再进行重复并且相同的工作了。

简单的说呢，就是模式，就是在特定的环境下。解决问题的方案，大家可以注意到，在这里，在这个定义中呢，它有三个关键的关键句。嗯，首先呢，是在呃，特定的环境中。说明它每个模式呢，它都有一个它所适用的一个环境，然后其次呢。在每一类的设计模式中呢，它都是针对于某一特定的问题。因此呢，我们要知道它这个设计模式，它到底是针对于什么样的一个问题。啊，我们呢，也不能滥用模式，或者是错用模式，最后呢，我们要学习这个设计模式啊，它怎么解决这个问题的。然后这是我们学习的一个非常很重要的一个关键，也就是我们刚才说到三个要素中的一个合格，然后去如何来解决。然后其实呢，在呃，另外呢，在20世纪80年代末的时候呢，就是我们软件这个工程界才开始关注了这个al佛啊啊这个。

嗯，Under Alex under，然后这个博士呢，他在住宅公共建筑啊，还有那个城市规规划这三个领域进行了一个重大突破。然后呢，其中呢，它最具有标志性的是四个人。然后其中呢，他这四个人呢，啊，我们把他们称之称之为一个四人组。就是g of for go，也就是G，这个定义是从这儿来的。然后呢，他们在他认为这四个人在1995年的时候啊，写出了也就是世界上第一本嗯，第一本设计模式的著作。呃，就是设计模式可复用，面向对象软件的基础。

他在这本书中呢，它就是归纳发表了23种在软件开发过程中使用频率最高的设计模式。啊，当然这是只是23种使用频率最高的，当然模式是有很多种，它是啊，这模式呢，是设，其实设计模式是成千上万的啊，只不过是就是归他归纳了就23种使用频率比较高的，然后他也做了大量的问卷调查，然后就是统计分析，最后得到的这23种。所以呢，他们希望通过这些模式呢，就是来统一沟通他咱们在面向对象方法在分析设计和实现，嗯，这之间的一个嗯嗯算是鸿沟吧，然后嗯，这就是这个四人组和他们的这个著作。

下面呢，说一下呃设计模式的呃几个基本要素吧，然后第一嗯，软件名称问题，还有解决方案，还有效果。呃呃，其实还有实例代码，还有相关的一些设计模式，其中的那个关键的四个基本要素，主要是包括下面四个。它第一个呢是那个软件，嗯，模式名称，它每个模式名称名模式，每个模式呢，它有自己的名字，通常是用一到两个词来描述，然后可以根据模式的问题啊，特点或者解决方案啊，还有它的功能和效果来命名。通常情况下呢，我们就可以根据名字啊，特别是它的英文名字，就是就可以知道这个模式是干嘛用的。就是比如说像有像像有经验的一些开发人员呢，他在使用设计模式的时候。在给类和包取名，取名的时候他就会有意识的。

他就有意识的把这些设计名、设计模式的名字给融入进去。然后就像咱们可能在看一些系统里面的时候，他们可能。他看一些系统的时候，他他可能在那个类类的名字可能叫做XYZ那个factory。然后呢，就可以从这个名字上就可以看出来，他这肯定是一个工厂类。啊，如果我们看到或者一个类里面有adapter啊，或者是builder，那那就可以以为这个啊，它这个它这个类的设计呢，使用到了适配器模式，或者是呃，监测的模式。然后第二个呢。嗯，他这个第二个奇描述是问题。就是这个设计模式，嗯，它是为了解决什么样的问题啊。什么样的问题，其嗯其次啊，它什么呃，使用了这个设计模式，嗯，包括它的那个使用条件，那它的意图啊，还有一些它的使用的环境。

嗯，接下来呢，就是我们将学习设计模式的啊核心内容啊，也就它那个解决方案，它这个解决方案呢，就是嗯，这个模式是如何来解决咱们所上面所描述的这个问题的。然后最后我们还要分析一下这个模式的效果。它这个效果呢，就是呃，包括它的优点，还有它的缺点。然后以及这个模式的适用环境。啊，就是还有呃，并且呢，它其实咱们的每一个设计模式它都不是完美的，它就是每一个模式它都有自己的优缺点，然后嗯。嗯。接下来呢，我们看一下那个。设计模式的一个分类吧。

其实设计模式。定义与分类设计模式，什么设计模式呢？其实设计模式简单的来说就是呃，Design喷，然后它是一套嗯，可反复被反复使用，多数人知晓的经过分类编目的代码，设计经验的总结，然后是对软件设计过程中反复出现问题成功解决方案的一些描述。在我刚才说的那个定义里面有四个关键，第一呢是反复使用。然后再者呢，他并不是嗯一两个团队，然后他是被大家就是很多人知道的。然后并且在很多项目中会使用到，然后在后面呢，大家也会了解到，它那个每个设计模式有着不同的分类，然后不同不同的分类，下面呢，它都会有几种不同的设计模式。最后呢，嗯，设计模式是对代码设计经验的总结。

然后呢，这些设计。他这些设计经验呢，他将会指导我们如何去设计出一个呃高质量的一个呃软件系统。然后呢，就是我们使用设计这个呢，就是我们使用设计的，使用设计的模式，到底嗯，提到有一个什么样的目的呢？它首先是呃，第一是提高一个代码的那个可重用性。也就是咱们可以把这个代码进行反复的使用。然后第二个呢，就是能够让代码更容易的让别人去理解。第三个呢，就是提高代码的一个可靠性。这就是他的一个目的，下面呢，我们来看一下这个。设计模式的一个三个分类。其中的设计模式。

它它其实是有两种两种分类方法的，首先呢，如果是按照嗯目的目的来进行分类的话，就分成三个类型，一种是这个创建型模式。呃，另外是结构型模式，还有就是行为型模式。行为型模式，然后这个创建型模式呢，它是嗯，关心这个如何去创建对象啊，包括他什么时候去创建，什么时候在什么地方啊去创建，然后以及它是怎么样进行创建的。然后结构型模式，呃，这个结构，嗯，不好意思，这个结构型模式呢，它是。就是类似于是一种搭积木吧，就是。如何把一个类和对象的组合？

呃，组合到一起，形成一个更加庞大而又复杂的系统，用于处理类或对象的一个组合。而这个行为型模式呢？行为型模式它是用于描述呃，类和对象之间嗯是如何交互，交互并且去去怎样分配职责的。那么在这在这三类的这个呃呃设计模式中呢，创建型模式其实是相对比较简单的，而这个行为型呢，它的难度嗯比这两个啊比较难度比较大点，然后它这个行为型设计模式它也是呃数量最多的一个，从上面可以看得出来，使用型设计模式包含了这是。呃，十一十一个。然后呢，就是说完按那个目的来分类，其实还是可以就是按范围进行一个分类的。

那么就是我们按照范围来进行分类的，首先要主要是考虑到的是就是设计模式用来，它是用来处理类与类之间的关系，还是用来处理对象与对象之间的关系。就是你根据这个范围，我们就可以把它分为类模式，还有一个对象模式。它这个类模式呢，啊，其实这个，嗯，从上面就是这这一行来说的，它就是一个类模式啊，下面的这些就是一个对象模式。类模式呢，它主要用来处理类和它这个子类之间的关系。然后这他这个关系呢，是通过一个静态的继继承继承建立，然后就是一旦一个类继承了另外一个类，然后这个嗯，在处于运行的时候，它是不能被改变的。也就是说它的这个负类呢，它不能进行一个动态的一个改变。然后呢，嗯，在编译时刻就被确定下来，它是一种静态的关系。

而这个对象型的这个设计模式，它是处理对象间的关系，就是这些关系呢，它在运行时的时是变化的。然后它更具有动态性，所以说呢，咱们目前的这些设计模式，模式中呢，大部分都是一个对象模式。嗯。嗯，接下来呢，我们将会也会介绍介绍到那个G的23种的一个设计模式。然后在1995年，嗯，他们那个就是GF，他们这个四人组呢，他们在那个出所中，嗯，发表的时候。呃，它这个大部分都是对象模式嘛，然后一共是23种。然后其中呢，19.5种是属于这个对象设计模式。那么为什么会出现就是这个0.5呢？其实就因为中间的这个适配器模式。

它有两种那个嗯两它它有两种不同的结构，就是它可以既作为那个类模式，也可以作为一个对象的一个嗯模式，所以呢，我们我们所以呢是3.5个类模式，然后19.5个设计模式。嗯，这就是按照范围来分类，那么按照按照目的来分类的话，就其中呢，就是具有嗯，五种创建性模式，七种结构性模式，然后还有11种行为性模式。接下来就是对创建型设计模式的一个，嗯，简单的介绍，简单的介绍，其中呢，它的使用频率最高的呢，就是工厂方法，还有一个就是抽象工厂方法。嗯，其中呢，就是咱们为了更好的学习这个两个设计模式，咱们又介绍了一个。咱们接在接下来的会介绍一个就是不是GF设计模式的一个，就是就是二简单的简单工厂啊模式，所以呢，有的时候我们可能称那个23种，不是不是23种设计模式，就是一般情况可能会说是24种设计模式，所以就因为引入了这个，嗯，不是GF的一个设计模式，简单工厂模式，所以说我们会。

可能会有的时候称之为它，它是24个设计模式。就是有了这个简单工厂的设计模式呢，嗯，我们可以更好的帮助我们去学习工厂方法模式，还有这个抽象工厂模式。其其次呢，使用频率，嗯，其次于就是这个单利模式。在就是在我们的开发中呢，它使用频率也是非常高的，其次呢，就是这个原型，还有那个建造者模式。其中呢，呃结构，嗯另外的结构性模式它有七种，一般呢，咱我这儿的排序是按照它这个首字母啊，就是英文，英文的一个首字母，像adapt，这个adapt适配器是那个A开头的，然后这个桥基是bridge，然后是B开头，一般情况是按照这个呃字母进行排序的。

然后在这个所有的结构型模式中呢。除了这个响源模式以外啊，其他的这个设计模式使用频率都都是还很不错的。然后其中呢，使用频率最高的一个是这个外观模式。嗯，最后一类呢，是那个，嗯，行为型设计模式。在go中呢，它有嗯十种设计模式，在这11种呢，他们这些使用频率就是嗯，都很很不一样，参差不齐，然后呢。它有有有使用频率非常高的，就比如这个，呃，观察者还有迭代器。这个迭代器，然后也有也有使用比较少的就是这个解释器，还有这个，呃，访问者模式。

然后呢，在我们，呃，后续的一些学习中呢，我们会会对这其中的24种设计模式进行一个详细的并且深入的一个讲解。另外呢，给大家呃，分析一下我们为什么要使用设计模式。为什么使用，就是说到他的优点。其第一呢，它是一个，嗯。呃，专家经验的一个积累。就是我们学习完设计模式以后呢，嗯，就是我们遇到类似于类似的问题的时候，我们可以去重用这些呃专家的经验，并且呃，所有的设计模式它都是有，它都是以一种呃非常标准的类图或者是观念代码的方式呈现给广大的那个开发人员的。嗯，是一种相对标准的形式啊，你如果你自己想的话，当然也可能也是会解决的，但是可能方法不是那么严谨吧。

嗯，然后他嗯，他他就是以这种以一种标标准的方式方式吧，就是可以方便大家的，嗯，沟通呢和交流，然后他这里面是融入了呃很多专家的一个经验，然后是以一种标准的形式，嗯，提供给广大的开发人员的。然后其次呢，第二。他这个设计模式，它提供了。一套就是通用的一个设计词汇，还有一个通用的语言，就像嗯，给大家举个例子，就像大家如果在一个呃。项目，嗯，项目团队里的话就是如果大家都学过设计模式。我们在那个开发的时候，就可以用一些模式的名词进行交流。就比如说嗯，那个嗯，张三啊，说我这个地方用到了啊某某某设计模式，比如说就是适配器模式的，那么如果李四也学过这个设计模式，那么李四他呢，就可以很快的看看懂张三呢他的这个设计的意图。

然后呢，就可以使他的这个设计方案更加的通俗易懂，就是这样这样呢，就方便了咱们开发人员呢之间的一个进行沟通交流。使得那设计方案更加通俗易懂，而如果你不采用设计吗？每个人都有每个人的方法啊，那那你那张三写了的话，那张四嗯，完全不理解张三到底用的什么，所以所张就会增加它的复杂的复杂复杂度。然后第三个呢。就是设计模式，嗯，可以让我们更加简简简单的复用成功的一些设计的和体系的一个结构。就是很多设计模式呢，我们一旦去学会了啊，当我们碰到嗯类似的问题的，就可以直接进行复用，就是所以所以说呢，它这个嗯，就是那个呃，设计模式，它的那个第一本书，它的那个副标题就叫做那个可复用面向对象软件的基础。

啊，这就它的含义所在，就是我们可以直接的进行服用。然后第四个。它就是使得，呃，使得咱们的设计方案更加的灵活，然后就是并且易于的一个修改。然后呢，大部分它这个设计模式，嗯，它都是，嗯提供一个抽象层，然后它这个抽象层呢，嗯，很重要的一个目的就是提高了咱这个系统的一个。嗯，可扩展性，然后所以所以说呢，咱们合理的使用设计模式，就会让我们的软件系统啊，我们的那个面向对象的软件具备更好的一个灵活性，可扩展性，还有一个呃。叫做嗯，可维护性。

然后第五个呢，就是我们将提高这个软件系统的开发效率和这个软件的质量，就是咱们可以在一定程度上去节约咱们的一个设计成本。就是你如果我们说我啊，我们没有学习这个设计模式的话，就是就当我们面对嗯，某个问题啊，我们可能会花很多的时间嗯和精力呢，去思考一个很好的解决方案啊，但是如果我们一旦掌握了这个相应的设计模式。啊，我们就可以啊，很方便的重用这些设计模式，嗯，第一第一呢，咱们可以提高效率，然后嗯，另外呢，可以这些设计模式，嗯，它都是在成千上万的项目中，它就是得到了很多次的一个验证，然后可以就是这比我们就是重新的去设计一个解决方案，它具有更好的一个可靠性。机，同时它会更好的满足咱们所说到的一个，呃，系统的一个更好的一个灵活性啊，可污染性，还有它的一个可维护性。

最后呢，就是。嗯，我觉得呢，就是对大家很有帮助的一个就是。学习咱这个设计模式呢，它这个整个过程，它有助于嗯，我们就更深入的去理解，嗯，像咱们那个面向对象的一个思想。就是很多人，他在学完这个面向对象之后呢，他对于。这个接口抽象类还有一个对于什么时候就是用继承啊，什么时候用关联，它都不是特别的去特别理解的，然后就是嗯，什么时候包括什么时候去使用这个接口来提高它的这个可扩展性啊，或者是同时也不知道它的什么是可扩展性。嗯，就比如通过咱们的设计模式学习呢，就可以更加深入的去了解。面向对象的一个内涵，思想进化。就是也可以呃，方便阅读和学习现有的一些类库，还有其他系统的一些源代码，因为大部分那个比较好的系统，它都是采用这些设计模式所设计的。

嗯，所以说就可以通过参考我就可以提高咱们就是在软件设计嗯中的一些水平和一个代码质量。我们呢，在后面后面的学习过程中，会详细的去介绍嗯，这每一个设计模式。这个呢，就是嗯，设计模式的一个优点。嗯。我讲的这个呢，可能嗯比较，因为现在还没有涉及到那个类图，或者还有一些代码，可能会显得比较无聊吧，就是主要是文本性的学习，我我我也我也很烦，我也相信大家肯定也不太喜欢这种，但是没办法。他每一种肯定是要先先进行这样的学习的。下面呢，就是我们。

嗯，来学习一下，就是设计模式的七大原则。就是在这里，由于这个咱们时间我不想拉的太长，因为咱们这个文本文文本的讲解拉的太长了，大家肯定就没有什么。嗯，兴趣了，所以说呢，在这我。呃，先简单的介绍一下前前前三种或者是四种吧，一会儿再看时间。所以说在这个在这个模块我们将学习到这七种，嗯，其实是七种，嗯嗯，面向对象的一个设计原则。分别是三一值的原则，开辟原则。理事代换原则啊，依赖倒转原则，接口隔离原则，合成复用原则，比米特法则。在在这个设计原则中呢，我们在这个设计原，这个设计原则呢，嗯，是我们后续嗯学习设计模式的一个基础。

那么首先呢，我们来了解一下，就是啊，什么是面向对象设计原则，嗯。我们首先是我们从我们软件的一个可维护性，可复用性。讲起，然后什么是软件的可维护性呢？那就是，呃，是指软件能够被理解、改正、适应及扩展的这个难易程度。嗯，这这一条呢，通俗来讲就是。嗯，我们可以在软件里面是否能够很方便的去增加功能，嗯，还有删除功能，或者是修改系统原有的一个功能。然后第二点呢。嗯。指这个可复用性，可复用性呢，它是指软件能够呃重复使用的一个难易程度。

也就是说呢，软件，嗯，也就是指我们的软件，我们的代码能够在这个项目中，它这个进行进行重用的一个难易程度。第三那个面向对象的一个设计目标，呃，目标之一呢是呃。既支持可维护性，也支持可复用性，也就是在于支持可维护性复用。然后一方面呢，需要呃实现设计方案或源代码的复用，另一方面呢，就是确保系统能够易于扩展和修改，具有良好的一个可维护性。嗯。面向对象设计原则呢，它是为了支持呃可维护性复用而诞生的，然后它的目的是提高软件的一个可维护性或者是可复用性。然后在嗯，我们后面的学习，呃，我们后面学习的面向对象设计原则，它都是一种。

指导性的原则。指导我们去如何设计出那个高质量的那个面向对象系统，而并非而并非是强制性原则。然后也就是说我们不这样做呢，我们这不不按照这个这些原则来做，也能把这些软件开发出来。但是呢，嗯，就是如果我们随心所欲的设计出来的这些软件，就是可能会出现某些问题，它的那个可维护性或者是可复用性，可能没有我们使用这个。设计原则这么好？然后呢，咱们在这个呃学，在设计模式的学习的过程中呢，就是我们在讲设计模式的优缺点时。他也会经常的提到，就是嗯，在后面讲讲这个设计模式优缺点的会我们会提到这个。这个模，这个设计模式会符合某某的法则，然后其又违背了某某某设计设计模式设计原则，然后每一种设计模式呢，都符合一个或者多个的，呃，面向对象设计原则。

当然有些设计模式它可能符合符合的比较多，然后也有可能是比较少，然后面向对象设计原则呢，它是用于评价一个设计模式嗯的使用效果的一个非常重要的一个指标。嗯，在接下来的学习过程中，嗯就嗯将要学习七下以下的这七种啊，设计模式，设计模式原则。啊，就这些设计模式原则，他们使用频率嗯比较高，有些来说也相对比较也相对比较低吧，接下来我们将进行一个详细的对每个设计模式设计原则的一个详细的一个讲解。其中呢，第一个，嗯，我们要学习到的是。

单一、单一、单一职责原则。其中呢，这个单一的原则是最简单的一个面向对象的一个设计原则。嗯，它的主要的作用是用于控制，嗯。的一个力度的一个大小。就是说这个类的力度大小，它形容就是。他一个累呢，不能太累了，就是累，累干什么，干的东西太多了，他就累了，然后就是不能把所有的事情都交给他去做。然后就是一个对象呢，他应该。包含它有，嗯，包含一个。包含一个单独的一个呃职责，并且这个嗯。该职责呢，被完整的封装的一个内容。啊，这也就意味着呢，就是我们在设计出呃一个类的时候，不能把所有的事情啊都交给同一个类进行实现，就是换句话说呢，就是。

就一个类而言。应该仅有一个引起它变化的原因，如果它有多多一个就使得它进行变化的原因，这就意味着这个类呢，它这个职责太重了。啊，它会累的，然后所以说我们需要对这个类的这个职责呢，进行对它进行一个分解。其中的这个。一个类啊，大到模块，小到方法，承担的责任，承担的职责越多，它被复用的可能性就越小。这样呢，我给大家举一个例子。就六。例如一个按钮，嗯，一个按钮，然后在一个系统中。我们去重用这个按钮的话，就是很这个是很多方便的，很方便的。

然后就是因为在其他其他地方都需要这个按钮，所以说如果是啊，如果是一个登录界面的话，它这个复用的几率就比较低了。就是我们只有在登录的时候才会用到啊，在其他地方用登录界面的可能性比较低，所以说呢啊，这个一个类或者是一个模块，它的这个力度越小，它被那个进行复用的，复用起来呢，重用起来呢越方便啊，它的它的这个力度越大呢。嗯，他就。它的重用性就越小。另外呢，嗯，就是当当一个职责变化时，嗯。可能会影响到其他职责的运作。所以说呢，一个类的职责越多，那么将将来它发生改变的一个几率呢，它也就越高。因此呢，我们需要将这些职责呢进行一个分离。

然后将不同的职责封装到不同的类种。嗯，也就是呢，嗯。也也，嗯嗯。分分离到不同的内容，也也就是咱们将不同的变化原因不同有不同变化原因的一个这些方法封装到不同的内容。单一职责原则呢，它其实就是实现一个高内聚低耦合的一个呃直导方针。下面呢，就是咱们通过一个呃，具体的一个实例，让大家进一步的去了解到什么是单一职责原则。就是下面的是一个是一个CS架构的一个系统。呃，它的这个登录界面的登录类的一个实现。就是它这个啊，这就是咱们的一个类图。嗯，它这个动物类呢，它包含了呃下面一系列的一个方法，这个in它是初始化界面，然后display是呃显示界面。

嗯，While是一个实现一个校验功能，然后get connection是连接数据库的。然后放在这个放在user，嗯。是从数据库中根据它这个用户名或者是密码去查找这个用户是不是在。然后最后呢，还还有一个main方法，呃，作为咱这个程序的一个总的一个入口。这样看的，这样看这个登录类，嗯，他这个职责嗯，实在是太多了，然后他就是啊，有着很很多能够引起它变化的一个维度。然后如果我们要去修改页面的话，那就需要啊修改第一个和第二个啊方法。然后如果我们要去改变这个数据库的话。我我们就这个第四个方法就需要进行一个修改啊，如果我们要修改四个语句，那么第五个find user也要进行一个修改。

那么如果我们要去改变入口啊，那这个闷嗯也就会去改变，这也就意味着这个动入功能，它引起呃，它变异化的这个原因太多了，所以说它职责过重，所以说呢，我们使用这个单一值的原则对它进行一个重构。接下来呢，这就是一个重构方案，然后我们将不同的这个变化啊原因封装到不同的类里面，首先呢，这个main class。它是作为一个系统，一个入口。然后其中它有这个函数，另外的这个logo log logo form啊在界面里包含，嗯嗯，包含了界面的一个显示和呃，界面的显示和界面的一个初始化啊功能。然后U道，它是封装了一些数据库的一些东西。

然后DBU是。负责连接数据库，也就是说呢，咱们将原来的那六个方法分别分装到了这四个不同的类里面，它每一个类呢，它职责就比较清晰，就是我们要去利用这个类去做什么东西。这样呢，就使使得咱们整个系统的更符合单一职责原则，单一职责原则。然后呢，第二下面我们来介绍一下第二个啊，嗯，第二个面向对象的一个设计原则。开闭原则，然后开闭原则是面向对象里面，它是最重要的一个原则。就是它也是咱们面向对象啊，面向对象的可复用设计的第一块机制，然后在在我们后续的一些讲解设计模式之中呢，会经常提到这个设计，这个设计原则。

简单的说就是。这个开闭原则。是指，嗯，软件实体呢。他应该对扩展开放，对修改关闭。就是怎么去理解我刚才说的那句话呢，就是说。咱们这个软件让我要增加功能呢。嗯，就是要扩展功能是很方便的。对扩展开放，这就是对扩展开放，然后嗯，我又不需要对原来的系统进行修改，嗯，所以说我对修改是关闭的。这个原则是那个，呃，Maya，然后191988年提出的，然后就是在。设计在开，嗯在开辟原则的定义中呢，嗯嗯，这个呢，嗯，软件实体，呃可以是一个软件模块。

啊，也可以呢，是由一个啊或者多个类组成的一个局部的结构，或者一个独立的类。开闭原则呢，它简单的简单，简单的说就是。呃，咱这个软件实体呢，尽量在不改变呃原有代码的情况下进行一个扩展，也就意味着啊，我们不需要修改源代源代码，但是可以向系统中去增加新的功能。或者是嗯，修改原有系统的功能。另外呢，咱们那个开闭原则呢，它的呃，核心是一个抽象化。这就意味着我们，嗯，可以为系统啊，就是提供一个抽象层。像目前大家就是如果使用到一些Java框架，或者是嗯一些类库。就是为什么我们可以拿过来直接重用，而不需要修改呢？

其中就是修改其中的源代码，就是，呃，就是他们很多就做了一个抽象层，里面用了大量的接口，我们经常说这个接口那么重要，那么这个接口呢，是一个很重要的作用，它就是为了扩展。它就是我们在软件里面，嗯，提供。提供一个抽象的，然后如果，所以说如果我们希望我们的系统能够支持，呃，能够符合呃这个呃开辟原则的话。我们最关键的就是要学会做一个稳定的一个抽象层。然后其次呢，再根据它的子类。嗯，也就是说通过一个，嗯，通过一个具体层。来，来提供不同的实现。然后根据它这个面对对象多肽或者子类的一个对象，就是可以覆盖呃负类的对象子类的方法。

嗯，也可以覆盖负类的方法。嗯，所以说就是我们。嗯，将来如果呃需要扩展的话，我们可以通过子类来进行扩展。开闭，开闭原则又可以叫做呃可变性封装原则。可变性封装原则呢，指的是我们要找到一些将来系统，嗯，可能会。发生可能会发生变化的地方。将这些，将这些呃地方的抽象出来，形成接口，形成抽象层。然后再针对于这个，呃，抽象抽象编程，然后通过它一系列不同的子类呢去体现变化，嗯，可以将每一种变化封装到一个子类中。如果将来我们要更换，我们只需要更换它的子类即可了，然后就是嗯，我们会讲，就是我们有一些方式可以使得更换子类，就是不也无需修改源代码。

接下来呢，根据这个开闭原则，我们来也来讲一个简单的事例。就是。某图形界面，它提供提供了各种不同形状的一个按钮。客户端呢，嗯，可针对这些按钮进行编程，然后用户可能会改变需求。就是它要求使用不同的这个按钮，例如就是这里大家看到的这个circle button button，圆形按钮，Rectangle button，呃，矩形按钮。那么呃，用户可能在原始的一个设计方案中呢，他使用的这个圆形按钮。后来呢，他又希望使用这个矩形按钮。嗯，那么在PPTPPT中的这个设计方案呢？呃，大家可以看到啊，这个里面，在这个界面我们是直接定义了一个圆形按钮。

然后或者是一个矩形按钮的一个对象。那么呢，我们如果是想要去更换这个按钮的话，我们就需要找到log inform这个界面中的这个去修改它的源代码。这样呢，就违背了一个开辟原则，就是咱们修改它的源代码了。那么我们应该怎么做呢？就是根据这个，呃，开闭原则，我们对这个进行一个重构。下面来看一下我们的这个重估的一个方案。在这个重构方案中呢，就是。我们引入了一个抽象的一个按钮的按钮类。然后再把这个圆形按钮和这个长方形按钮都作为抽象类的，呃，抽象按钮的一个子类。它这两个子类呢，实现了抽象按钮中声明的这个view的一个这个抽象方法，然后并且在不同的。

这个circle子类或者是tale子类中啊，提供了不同的一个实现。然后呢，在这个呃，Log inform这个登录界面中，我们关联关联一个这个抽象的，这个抽象抽象类的按钮对象大家大家注意这啊，我们是啊，针对于这个负类编程。就是再将子类的名字，我们在后续中也会讲到，我们可以就是把它放置到啊配置文件中，再反射出一个子类的一个对象啊，去覆盖啊负类对象在软件里面呢，就是我们出现父类的对象可都可以用子类的子类来代替。这也是我们接下来学学的那个理事代换原则。我们我们将会，我们将会要提到，就是因此我们根据这个针对于这个负类编程。啊，我们在运行的时候，就通过读取它这个配置文件。嗯，反射生成一个子类的对象。然后子类呢，来覆盖这个父类，子类呢来覆盖这个负类。

然后从而使得我们在更换具体按钮的时候呢，不用修改咱们已有的这些源代码。就是只需要修改一下咱们这的配置文件，就是你如果是用circle button，你就去把这个circle button这个类的名字写到这儿，如果你用这个red button，你就把这个类名字写到这。嗯。就是如果说呢，我们将来又出现了，嗯，椭圆按钮啊，或者是临线按钮，我们只需要做两件事情。第一个呢，在这儿增加一个新的一个按钮。在这增加一个新的按钮类。就是也是作为这个抽象，嗯，按钮的一个子类，刚才我我跟大家也说过啊，出现那个负类的地方呢，它都是可以用词来代替的啊，因此呢，就是这个这个新的这个椭圆按钮。

可以把它们放到我们的登录界面中，因此我们嗯，再打开这个配置文件，把这个配置文件中的这个嗯。把这个配置文件中的这个类名改成子类的名字，然后对于原有系统的这些代码呢。我们不需要做任何的一个修改。这就符合开边的了。就是咱们没有对它进行被对原有的这个系统代码进行修改，而我们只增加了，并没有去修改它。然后呢，就是。大家注意，我们在系统中就是增加一个类不修改源代码啊，然后我们增加一个新的类的源代码，这个不叫修改系统，也不叫修改原有系统，就是另外呢，咱们这个修改配置文件。修改配置文件，这个也不叫修改源代码，就是因为呢，这个文这个配置文件它是一个嗯，文本文件，它这个文件它不需要编译，然后所以说呢，我们可以用用一些文本编辑器，就比如说记事本呢，我们就用这些工具可以直接进行修改。

然后在就是目前我们很多的项目中呢，就是嗯，我们的一些可以变化的东西，我们就把它放到啊ML或者是properties那些配置文件中。我们通过配置文件呢。将就是将系统的。每一个部分。组合到一起就是来提高它的这个灵活性和它的可扩展性。嗯，接下来呢，我们来介绍一下，嗯，第三个面向对象的一个设计原则，理事代换原则。理事代换原则呢，简单的说就是。呃，所有引引用基类啊，也就是说父类的地方都能透明的使用到它的子类的对象。

啊，这是一个非常重要的一个，呃，面向对象设计原则，然后这也就意味着我们可以针对于这个负类进行编程。就是在运行的时候呢，我们用，呃，我们再用不同的子类去替换父类，就是如果我们要替换子类就对，嗯，原有的代码不需要做任何的改动，改改动。然后这个。嗯，这个理事代换原则，它是由。嗯，2008年的一个图林奖得主，她也是美国的第一位啊，第一位计算机科学女博士。然后麻省理工学院教授，嗯，这个叫什么。巴嗯，芭芭拉，芭芭拉迪科夫，然后和他的一个，嗯，和他这个这个教授就是在1994年提出的。然后就是下面这儿呢，是对爸爸了，还有那个进行。

一个简单一个介绍，它是它是目前世界上知名的一个。It女科学家的一个，嗯，女科家之一，然后她是美国计算机，嗯科学家，2008年的一个图灵奖得主，然后。她也是，嗯，他也，他同时也是第二位就是获得图灵图灵奖的一个女科学奖，女科学家，然后呢，在2014年，他也获得这个冯诺伊曼奖。啊，他得的这些奖都是在咱们这个计算机界都是非常高的一些奖项，最高的一个奖项，然后就是啊，他也同时也是。嗯，美国的工程院院士，然后还有这个。啊，美国艺术与科学院院士，还有这个美国计算机协会会士，然后呢，现任是麻麻省理工的一个教授，然后他也是。

呃，美国第一个那个计算机科学的一个女博士。是，她是在R界就是非常有影响力的一位女性吧。回归正题。然后再。乙是代换原则中的啊。简单的说就是。呃，将软件中的一个基类对象替换成它的子类对象，程序不会产生任何错误和异常。反过来呢，他不一定成立，呃。就举个例，嗯，举一个例子啊，例如我喜欢动物。我喜欢动物的话，那就意味着所有的动物我都喜欢。但如果啊，如果你插入一个狗，哎哎，我喜欢我我喜欢狗，然后如果是个猫，我也喜，我也我也我也喜欢，然后是猪的话我也喜欢，但因为我是针对于父类编成嘛，所以说说它所有的子类我都是可以接受的嘛，这些什么猫狗猪了，都是动物的一个子类嘛。

但反过来啊，我我我我说我喜欢狗的话，但不代表我喜欢所有狗嘛，对不对。然后这是我们需要，这是我们需要去做一个强制类型的一个转换。就是看这个啊，动物啊，它能不能转换成狗。啊，如果能转成狗，哎，这个时候呢就可以，我们程序没有问题，但如果转换异常了，嗯我们，嗯，我们那个程序呢，就需要抛出一个异常，就是类型不匹配嘛。嗯，如果一个软件实施体使用使用的是一个子类的一个对象，那么它啊，那么它不一定啊，能够使用积类对象，我们想我们讲那个积类对象转换成子类的对象。这个呢是一个强制转换，然后呢，在这个转换过程中呢，我们可能就是去抛出异常。

然后就是为了我们能够，嗯，更好的嗯，更好的嗯，那个使得系统符合这个开辟原则呢，我们就是在。程序中尽量的要使用鸡类类型。嗯，对对象进行一个定义，也就是说我们使用这个。呃，负类进行一个编程。然后在运行的时候再确定它的这个子类。接下来呢，我们看一个，呃，简单的案例呢，然后就是。某系统某系统，嗯，需要对一些重要的数据啊，比如说用户密码进行一个加密处理。然后嗯，在这个，嗯，有两个不同的一个加密类，一个是嗯。嗯，一个一个是CA，还有CB。我们直接看例图吧。嗯，然后我们在这个数据操作类中呢，我们针对于这两个具体的啊编程加密算法进行编程，实际上我们在使用过程中间呢，就是我们通常会使用到这两个加密算法中的一个。

嗯，我们呢，就是在闷的这个闷闷闷方法中。我们可以呃呃进一个C，然后然后把它注入到我们的数据库，呃，操作类类里面，然后采用A来进行一个编程。那么呢，如啊，我们有时候也可能会采用CB。采用CB，然后我们就会在这里面一个啊CB的一个对象。然后这个CB类型的一个加密对象注入到我们这个数据库的这个操作类里面呢，啊，那么如果我们要是啊频繁的在这两个啊算法之间做一个选择。那如果我们采用如图的这种，嗯。嗯，设计方案的话，那我们每一次在这个更换加密类的时候呢，就需要去修改。

嗯，这个客户类就是我们。我们就是去修改改它这个源代码了，我们就会违背咱们规定的那个开闭原则。就是我，我举一个例子，就是例如我们刚开始调用CFAA来进行编程，然后在encrypt里面调用CFAA的这个加密方法。那那么毫无疑问，我们这个c interpreter就是针，就是针对于C进行编编码的，那么如果我们后续呢，嗯，改成这个CB。那么就需要修改一下了。啊，就是咱们这个data operator，然后这个数据操作类的源码在in incryator里面，这个要用到CB的一个加密方，加密方法。啊，同时呢，我们啊采用这个加密对象不一样呢，我们就需要啊对这个克林类。然后也就是这客户类我们要进行一个啊相应的一个修改，这样呢，它就违背了咱们这个开边的就是咱们对这个原有的代码进行了修改。

就是我们为了能够使系统嗯更好的符合开辟原则呢，我们对。呃，进行了，我们对这我们对这里进行一个简单的一个重构。你这个不是李四。李四代换原则嘛，怎么又讲到开辟原则上去了，刚才是是刚才是那个它是违背了这个开辟原则，因为就是我刚才讲到，如果是刚一开始使用的这个CPA，然后嗯，知道你接着讲理四的代换原则吧，就不要再讲开B了，是吧，不是老师说，我是说他这个在这个理事代换的原则里面，他用到这个，它进行替换的时候，他违背的这个开辟原则啊，我知道就是说又又说到这个理事代换它是怎么去解决这个。

啊啊，行，你说吧啊。在这个里面呢，我们就是啊，对它进行一个重构，然后我们将这个C和B做成了这个C和A的一个子类。然后根据嗯，笔试代换原则呢，就是出现这个负类的地方，我们都可以用它的子类一个去进行一个代替。啊，这也就是意味着我们这里如果用CA进行一个做加密的话，啊，在CB的加密方法中，我们就可以去覆盖CA的一个加密方法，如果我们就是如果要使用到了这个c four b的一个加密方法的话，我们就可以将这个c four b放置到这个呃，配置文件中的，让它不能再反射出一个CB的一个对象。嗯，再然后把它注入进去。就是因为这个理事代换原则呢，咱们就呃，负类对象能够被这个子类对象这个进行一个代替。

啊，所以说呢，我们如果在配置文件里面用的是CB进行运行的时候呢，C和B的对象就会嗯，覆盖到覆盖覆盖CA的一个对象，所以说我们在这个数据库操作呃类里面最终调用的加密方法是使用的是CB的一个对象，CB的方法。就是我们如，如果我们不需要嗯使用CB的话，我们就直接把这个配置文件里里面这个嗯改成C就行了。然后如果我们整个方法就是还有它的参数都是C定义的，那么cva的这个对象就是可以传进来。我们你要用这个inccrycry，然后这个方法的时候，用的也是那个C的方法。然后在这里我们采用这个，呃，父类还有子类的这种应用结构呢，就是我们将来啊，如果如果又出现了一个新的啊，一个加密方法，就比如说CC和C。

然后我们只需要将这个啊，假如这有一个CC的话，我们只需要。将这个做成A的子类。就是也是一个继承的一个关系，然后或者是做成B的子类也行，我们再修改一下这样的配置文件。就是程序在运行的时候呢，呃，就会将这个C和C的这个对象取代这里面的这个C和A的一个对象。嗯，所以说呢，就是像这种理事代换原则是我们系统扩展的一个基础，就是它也是我们实现那个开闭原则的一个基础。我觉得这个例子吧，不是很好，红号你再想想，因为呢，他讲这个理事替换吧，主要是说你在在在这个用复力吧，嗯，指向子类的时候呢。它有时候呢，可能是替换不了是吧，你可以有多个类是吧？来来讲一下，你这只有一个CA，有一个CB，其实我记得原来有个例子叫里脊鸟是不是鸟，所以说它里边呢，有有一些其他的方法导致呢，就是说复类没法再指向子类是不是。

啊，你比方说子类都有个FLY对吧，它可以都指向子类，但是呢，有的例子呢，增加了其他的函数，它没法去指向了，所以就导致没法进行这个代换，对吧，他说主要讲的这个意思，你这个例子啊，没有什么错误，但是呢，感觉有点大家可能会被你的开辟给绕进去，嗯。啊，嗯。行吧，你再找找一个好的例子，我记得什么，找这个例子倒没错哈，行吧，你继续吧。我想着今天就先这样了，因为也一个小时。一个小时了是吧，对咱们以后呢，就大家尽量讲解，不要超过一般的三四十分钟啊，别讲太多了，讲太多呢，第一呢大家也接受不了，第二呢，就是说什么，然后咱们有人录屏是吧，录屏可以到此就就为止了，大家呢下边呢有什么问题呢，可以问问咱们录屏的目的呢，还是让大家呢回去。