精华内容
下载资源
问答
  • 创建型设计模式包含哪些
    千次阅读
    2021-03-13 03:09:28

    创建型模式中总共包含5个设计模式:

    1.抽象工厂模式(Abstract Factory)

    2.建造者模式(Builder)

    3.工厂方法模式(Factory Method)

    4.原型模式(Prototype)

    5.单例模式(Singleton)

    接下来分别进行总结。

    抽象工厂模式

    提供一个创建一系列或相关依赖对象的接口,而无需指定它们具体的类

    实战例子:变更数据库方面的应用

    首先定义一个行为的interface 里边包含了插入删除等行为举例 interface Idepartment

    然后根据不同的数据库动作类来实现这个接口这样每种数据库都有了自己的实现插入删除等的方法

    举例

    class accessDepartment implements Idepartment

    再建立一个数据库的interface 里边包含了创建数据库的方法

    举例 interface Ifactory

    然后根据不同的数据库创建类来实现这个接口这样每种数据库都能够返回一个自己的实例

    举例 class AccessFactory implements Ifactory

    最后实现时

    Ifactory factory = new AccessFactory ();

    Idepartment id = factory.创建数据库();

    这样如果有新的数据库接入就重复上边的步骤就能够使用新的数据库了  这就是抽象工厂的设计模式

    好处是易于交换产品系列

    由于具体工厂类只有在 Ifactory factory = new AccessFactory ();这个时候初始化过一次 这就使得改变一个引用的具体工厂变得容易 只需要改变初始化就可以

    第二个好处就是它让具体的创建实例过程与客户端分离

    客户端是用过它们的抽象接口操纵实例产品的具体类名也被具体工厂的实现分离不会出现在客户代码中

    可以用反射+抽象工厂来解决数据库的变更问题这个是最好的

    以上就是抽象工厂模式的总结

    建造者模式

    将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示

    实战例子:画小人儿有头身体和脚 然后画一个胖小人和一个瘦小人

    首先定义一个产品类 类中有添加部件的方法和显示部件的方法 Product

    然后定义一个抽象建造者 abstract class Builder 里边有组装部件和返回结果的方法

    然后实例化这个抽象的建造者  class ConcreteBuilderextends Builder

    然后创建一个指挥者 class Director  里边有一个组装的过程 如 先放头部 然后放身体 最后放鞋子 这个方法的形参是Builder

    实现的方法是

    Director director =  new Director();

    Builder b1 = new ConcreteBuilder();

    director.组装过程(b1);

    这样就只有一个指挥者来执行不同的建造者的建造过程

    需要的话 就实例化一个自己的Builder,Builder可以有若干个 这就是建造者模式

    好处是将一个复杂对象的构建与它的表示分离使得同样的构建过程可以创建不同的表示

    简单来说  就是画一个小人 必须有画头 身体 和脚这么几个部分  我不关心怎么画出来  我只关心高矮胖瘦 不管是高是矮是胖是瘦 这个人必然会有头身体和脚这么几个部分

    那么胖人 我就建立一个胖的builder

    瘦子我就建立一个瘦builder  至于builder中怎么画出的人 我不管 只管画出的人的形状高矮胖瘦

    建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配模式时适用的模式

    以上就是建造者模式的总结

    工厂方法模式

    定义一个用于创建对象的接口让子类决定实例化哪一个类

    工厂方法使一个类的实例化延迟到其子类

    实战例子:大学生是活雷锋  社区志愿者也是活雷锋

    首先定义一个interface Ifactory 里边包含一个创建雷锋的方法

    然后定义一个大学生工厂Class 大学生工厂 implements Ifactory 实现里边接口的方法

    然后定义一个志愿者工厂 class 志愿者工厂implements Ifactory 实现里边接口的方法

    使用时

    Ifactory factory =  new 大学生工厂();

    雷锋 student = factory.创建雷锋();

    好处是如果有一个新的群体是活雷锋的话 那么新建一个群体然后implements Ifactory

    在建立factory的时候建立新的群体工厂就好了

    这个方法解决了简单工厂模式中switch case过多的问题

    以上就是工厂方法模式的总结

    原型模式

    用原型实例指定创建对象的种类并且通过拷贝这些原型创建新的对象

    原型模式其实就是从一个对象再创建另外一个可定制的对象而且不需要知道任何创建的细节

    class Prototype implements Cloneable {

    publicPrototype clone(){

    Prototypeprototype = null;

    try{

    prototype= (Prototype)super.clone();

    }catch(CloneNotSupportedExceptione){

    e.printStackTrace();

    }

    returnprototype;

    }

    }

    class ConcretePrototype extends Prototype{

    publicvoid show(){

    System.out.println("原型模式实现类");

    }

    }

    public class Client {

    publicstatic void main(String[] args){

    ConcretePrototypecp = new ConcretePrototype();

    for(inti=0; i< 10; i++){

    ConcretePrototypeclonecp = (ConcretePrototype)cp.clone();

    clonecp.show();

    }

    }

    }

    使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的,它直接在内存中复制数据,因此不会调用到类的构造方法。

    深拷贝与浅拷贝:

    Object类的clone方法只会拷贝对象中的基本的数据类型,对于数组、容器对象、引用对象等都不会拷贝,这就是浅拷贝。

    如果要实现深拷贝,必须将原型模式中的数组、容器对象、引用对象等另行拷贝。

    public class Prototype implements Cloneable{

    privateArrayList list = new ArrayList();

    publicPrototype clone(){

    Prototypeprototype = null;

    try{

    prototype= (Prototype)super.clone();

    prototype.list= (ArrayList) this.list.clone();

    }catch(CloneNotSupportedExceptione){

    e.printStackTrace();

    }

    returnprototype;

    }

    }

    由于ArrayList不是基本类型,所以成员变量list,不会被拷贝,需要我们自己实现深拷贝,幸运的是java提供的大部分的容器类都实现了Cloneable接口。所以实现深拷贝并不是特别困难。

    PS:深拷贝与浅拷贝问题中,会发生深拷贝的有java中的8中基本类型以及他们的封装类型,另外还有String类型。其余的都是浅拷贝。

    以上就是原型模式的总结目前还没有使用到  感觉不是很深刻

    单例模式

    保证一个类仅有一个实例并提供一个访问它的全局访问点

    Class singleton

    Private static singleton instance;

    Private singleton(){

    //构造方法private 这就堵死了外界利用new创建此类实例的可能性

    }

    Public static singleton GetInstance(){

    If(instance== null ){

    Instance= new singleton();

    }

    Return instance;

    }

    这里需要注意的是如果是多线程的话有可能导致创建多个实例这个时候需要添加一个lock

    最好是双重lock

    If(instance == null ){

    Lock(lock.lock){

    If(instance == null ){

    Instance = new singleton();

    }

    }

    }

    比较多的使用在数据库的DAO上

    以上就是单例模式的总结

    总结:

    所有的创建类模式本质上都是对对象的创建过程进行封装。

    更多相关内容
  • 5种创建型设计模式

    2013-04-28 13:52:42
    GOF的23中设计模式中,五种创建型模式的介绍。
  • 抽象工厂模式、构建器模式、工厂方法模式、原型模式、单例模式

     

    目录

    创建型模式

    抽象工厂模式

    建造者模式

    工厂方法模式

    原型模式

    单例模式


    创建型模式

            创建型模式使设计变得更灵活,提供了不同的方式,从代码中移除了对需要实例化的具体类的引用。换句话说,这些模式增强了对象和类之间的独立性。

    设计模式名称

    简要说明

    抽象工厂模式
    (Abstract Factory)

    提供一个接口,可以创建一系列相关或相互依赖对象,而无需指定它们具体的类。

    建造者模式
    (Builder)

    将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

    工厂方法模式
    (Factory Method)

    定义一个用于创建对象的接口,让子类决定将哪一个类实例化。Factory Method使一个类的实例化延迟到其子类。

    原型模式
    (Prototype)

    用原型实例指定创建对象的种类,并且通过拷贝这个原型来创建新的对象。

    单例模式
    (Singleton)

    保证一个类仅有一个实例,并提供一个访问它的全局访问点。

    抽象工厂模式

    1、概述:

            抽象工厂(AbstractFactory)模式:为访问类提供一个创建一组相关或相互依赖对象的接口,且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

            抽象工厂模式是工厂方法模式的升级版本,工厂方法模式只生产一个等级的产品,而抽象工厂模式可生产多个等级的产品。

    2、主要角色:

            ①、抽象工厂(Abstract Factory):提供了创建产品的接口,它包含多个创建产品的方法 newProduct(),可以创建多个不同等级的产品。

            ②、具体工厂(Concrete Factory):主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建。

            ③、抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。

            ④、具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间是多对一的关系。

    3、应用场景:

            ①、一个系统要独立于它的产品的创建、组合和表示时;

            ②、一个系统要由多个产品系列中的一个来配置时;

            ③、需要强调一系列相关的产品对象的设计以便进行联合使用时;

            ④、提供一个产品类库,而只想显示它们的接口而不是实现时。

    4、优点:

            ①、分离了具体的类。客户通过抽象接口操纵实例,产品的类名也在具体工厂的实现中被分离,它们不出现在客户代码中。

            ②、易于交换产品系列。一个具体工厂类只在初始化时出现一次,这使得改变一个应用的具体工厂变得很容易,只需改变具体的工厂即可使用不同的产品配置。

            ③、有利于产品的一致性。当一个系列的产品对象被设计成一起工作时,一个应用一次只能使用同一个系列中的对象,这一点很重要,而抽象工厂很容易实现这一点。

    5、缺点:

            ①、难以支持新种类的产品。因为抽象工厂接口确定了可以被创建的产品集合,所以难以扩展抽象工厂以生产新种类的产品。

    建造者模式

    1、概述:

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

            建造者模式的核心在于如何一步步构建一个包含多个组成部件的完整对象,使用相同的构建过程构建不同的产品,在软件开发中,如果我们需要创建复杂对象并希望系统具备很好的灵活性和可扩展性可以考虑使用建造者模式。

    2、主要角色:

            ①、Builder(抽象建造者):为创建一个产品对象的各个部件指定抽象接口。

            ②、ConcreteBuilder(具体建造者):实现Builder的接口以构造和装配该产品的各个部件,定义并明确它所创建的表示,并提供一个检索产品的接口。

            ③、Director(指挥者):构造一个使用Builder接口的对象,。

            ④、Product(产品角色):表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程,包含定义组成部件的类,包括将这些部件装配成最终产品的接口。

    3、应用场景

            ①、需要生成的产品对象有复杂的内部结构,这些产品对象通常包含多个成员属性。

            ②、需要生成的产品对象的属性相互依赖,需要指定其生成顺序。

            ③、对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类,将创建过程封装在指挥者类中,而不在构建器类和客户类中。

            ④、隔离复杂对象的创建和使用,并使得相同的创建过程可以创建不同的产品。

    4、优点

            ①、在建造者模式中,客户端不必知道产品内部组成的细节,将产品本身与产品的创建过程解耦,使得相同的创建过程可以创建不同的产品对象。

            ②、每一个具体构建器都相对独立,而与其他的具体构建器无关,因此可以很方便地替换具体构建器或增加新的具体构建器,用户使用不同的具体构建器即可得到不同的产品对象。由于指挥者类针对抽象构建器编程,增加新的具体构建器无须修改原有类库的代码,系统扩展方便,符合“开闭原则”

            ③、可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中,使得创建过程更加清晰,也更方便使用程序来控制创建过程。

    5、缺点

            ①、建造者模式所创建的产品一般具有较多的共同点,其组成部分相似,如果产品之间的差异性很大,例如很多组成部分都不相同,不适合使用建造者模式,因此其使用范围受到一定的限制。

            ②、如果产品的内部变化复杂,可能会导致需要定义很多具体构建器类来实现这种变化,导致系统变得很庞大,增加系统的理解难度和运行成本。

    工厂方法模式

    1、概述:

            工厂方法模式(Factory Method Pattern):定义一个用于创建对象的接口,让子类决定将哪一个类实例化,工厂方法模式让一个类的实例化延迟到其子类。此模式的核心精神是封装类中变化的部分,提取其中个性化善变的部分为独立类,通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。

            我们不再提供一个统一的工厂类来创建所有的产品对象,而是针对不同的产品提供不同的工厂,系统提供一个与产品等级结构对应的工厂等级结构

    2、主要角色:

            ①、抽象工厂(Creator)角色:是工厂方法模式的核心,与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

            ②、具体工厂(Concrete Creator)角色:这是实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建产品对象。

            ③、抽象产品(Product)角色:工厂方法模式所创建的对象的超类型,也就是产品对象的共同父类或共同拥有的接口。

            ④、具体产品(Concrete Product)角色:这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建,它们之间往往一一对应。

    3、应用场景

             ①、客户端不知道它所需要的对象的类。在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可,具体的产品对象由具体工厂类创建,可将具体工厂类的类名存储在配置文件或数据库中。

            ②、抽象工厂类通过其子类来指定创建哪个对象。在工厂方法模式中,对于抽象工厂类只需要提供一个创建产品的接口,而由其子类来确定具体要创建的对象,利用面向对象的多态性和里氏代换原则,在程序运行时,子类对象将覆盖父类对象,从而使得系统更容易扩展。

    4、优点

            ①、在工厂方法模式中,工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节,用户只需要关心所需产品对应的工厂,无须关心创建细节,甚至无须知道具体产品类的类名。

            ②、基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够让工厂可以自主确定创建何种产品对象,而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式,就正是因为所有的具体工厂类都具有同一抽象父类。

            ③、使用工厂方法模式的另一个优点是在系统中加入新产品时,无须修改抽象工厂和抽象产品提供的接口,无须修改客户端,也无须修改其他的具体工厂和具体产品,而只要添加一个具体工厂和具体产品就可以了,这样,系统的可扩展性也就变得非常好,完全符合“开闭原则”。

    5、缺点

            ①、在添加新产品时,需要编写新的具体产品类,而且还要提供与之对应的具体工厂类,系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,有更多的类需要编译和运行,会给系统带来一些额外的开销。

            ②、由于考虑到系统的可扩展性,需要引入抽象层,在客户端代码中均使用抽象层进行定义,增加了系统的抽象性和理解难度,且在实现时可能需要用到DOM、反射等技术,增加了系统的实现难度。

    原型模式

    1、概述:

            原型模式(Prototype Pattern):使用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。原型模式是一种对象创建型模式。

            原型模式的工作原理很简单:将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝自己来实现创建过程。由于在软件系统中我们经常会遇到需要创建多个相同或者相似对象的情况,因此原型模式在真实开发中的使用频率还是非常高的。原型模式是一种“另类”的创建型模式,创建克隆对象的工厂就是原型类自身,工厂方法由克隆方法来实现。

    2、主要角色:

            ①、Prototype(抽象原型类):它是声明克隆方法的接口,是所有具体原型类的公共父类,可以是抽象类也可以是接口,甚至还可以是具体实现类。

            ②、ConcretePrototype(具体原型类):它实现在抽象原型类中声明的克隆方法,在克隆方法中返回自己的一个克隆对象。

            ③、Client(客户类):让一个原型对象克隆自身从而创建一个新的对象,在客户类中只需要直接实例化或通过工厂方法等方式创建一个原型对象,再通过调用该对象的克隆方法即可得到多个相同的对象。

    3、应用场景

            ①、创建新对象成本较大(如初始化需要占用较长的时间,占用太多的CPU资源或网络资源),新的对象可以通过原型模式对已有对象进行复制来获得,如果是相似对象,则可以对其成员变量稍作修改。

            ②、如果系统要保存对象的状态,而对象的状态变化很小,或者对象本身占用内存较少时,可以使用原型模式配合备忘录模式来实现。

            ③、需要避免使用分层次的工厂类来创建分层次的对象,并且类的实例对象只有一个或很少的几个组合状态,通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更加方便。

    4、优点

            ①、当创建新的对象实例较为复杂时,使用原型模式可以简化对象的创建过程,通过复制一个已有实例可以提高新实例的创建效率。

            ②、扩展性较好,由于在原型模式中提供了抽象原型类,在客户端可以针对抽象原型类进行编程,而将具体原型类写在配置文件中,增加或减少产品类对原有系统都没有任何影响。

            ③、原型模式提供了简化的创建结构,工厂方法模式常常需要有一个与产品类等级结构相同的工厂等级结构,而原型模式就不需要这样,原型模式中产品的复制是通过封装在原型类中的克隆方法实现的,无须专门的工厂类来创建产品。

            ④、可以使用深克隆的方式保存对象的状态,使用原型模式将对象复制一份并将其状态保存起来,以便在需要的时候使用(如恢复到某一历史状态),可辅助实现撤销操作。

    5、缺点

            ①、需要为每一个类配备一个克隆方法,而且该克隆方法位于一个类的内部,当对已有的类进行改造时,需要修改源代码,违背了“开闭原则”。

            ②、在实现深克隆时需要编写较为复杂的代码,而且当对象之间存在多重的嵌套引用时,为了实现深克隆,每一层对象对应的类都必须支持深克隆,实现起来可能会比较麻烦。

    单例模式

    1、概述:

            单例模式(Singleton Pattern):一个类有且仅有一个实例,并且自行实例化向整个系统提供。

            单例模式有三个要点:一是某个类只能有一个实例;二是它必须自行创建这个实例;三是它必须自行向整个系统提供这个实例。

            具体实现角度来说就是以下三点:一是单例模式的类只提供私有的构造函数,二是类定义中含有一个该类的静态私有对象,三是该类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象。

    2、主要角色:

            Singleton(单例):在单例类的内部实现只生成一个实例,同时它提供一个静态的getInstance()工厂方法,让客户可以访问它的唯一实例;为了防止在外部对其实例化,将其构造函数设计为私有;在单例类内部定义了一个Singleton类型的静态对象,作为外部共享的唯一实例。

    3、应用场景

            ①、系统只需要一个实例对象,如系统要求提供一个唯一的序列号生成器或资源管理器,或者需要考虑资源消耗太大而只允许创建一个对象。

            ②、客户调用类的单个实例只允许使用一个公共访问点,除了该公共访问点,不能通过其他途径访问该实例。

    4、优点

            ①、单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例,所以它可以严格控制客户怎样以及何时访问它。

            ②、由于在系统内存中只存在一个对象,因此可以节约系统资源,对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。

            ③、允许可变数目的实例。基于单例模式我们可以进行扩展,使用与单例控制相似的方法来获得指定个数的对象实例,既节省系统资源,又解决了单例单例对象共享过多有损性能的问题。

    5、缺点

            ①、由于单例模式中没有抽象层,因此单例类的扩展有很大的困难。

            ②、单例类的职责过重,在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色,提供了工厂方法,同时又充当了产品角色,包含一些业务方法,将产品的创建和产品的本身的功能融合到一起。

            ③、现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术,因此,如果实例化的共享对象长时间不被利用,系统会认为它是垃圾,会自动销毁并回收资源,下次利用时又将重新实例化,这将导致共享的单例对象状态的丢失。

    设计模式之设计原则

    设计模式之结构型模式

    单例模式

    展开全文
  • 设计模式》中的描述: 创建型模式抽象了实例化过程。它们帮助一个系统独立于如何创建、组合和表示它的那些对象。 一个类----创建型模式使用继承改变被实例化的类, 一个对象-创建型模式将实例化委托给另一个对象。...

    1 创建型模式

    本人理解:以C++为例,创建对象时,用关键字new来创建(实例化)对象。用一个函数或类将new的过程封装起来,就是创建型模式。

    《设计模式》中的描述:
    创建型模式抽象了实例化过程。它们帮助一个系统独立于如何创建、组合和表示它的那些对象。
    一个类----创建型模式使用继承改变被实例化的类,
    一个对象-创建型模式将实例化委托给另一个对象。
    (看后,一头雾水)

    工厂模式(Factory Pattern)
    抽象工厂模式(Abstract Factory Pattern)
    单例模式(Singleton Pattern)
    建造者模式(Builder Pattern)
    原型模式(Prototype Pattern)

    2 结构型模式

    本人理解:创建型模式关注一个类或对象的实例化;结构型模式关注多个类或对象组合成更复杂的对象,是为了更灵活的构造对象。

    《设计模式》中的描述:结构性模式涉及到如何组合类和对象以获得更大的结构。
    结构型类----模式采用继承机制来组合接口和实现。
    结构型对象-模式不是对接口和实现进行组合,而是描述了如何对一些对象进行组合,从而实现新功能的一些方法。
    (看后,一头雾水)

    适配器模式(Adapter Pattern)
    桥接模式(Bridge Pattern)
    过滤器模式(Filter、Criteria Pattern)
    组合模式(Composite Pattern)
    装饰器模式(Decorator Pattern)
    外观模式(Facade Pattern)
    享元模式(Flyweight Pattern)
    代理模式(Proxy Pattern)

    3 行为型模式

    本人理解:上述两种模式都是出于一定目的(复用代码、修改时更灵活、容易维护等等)创建对象,对象之间一通信,一个程序就跑起来啦,把对象之间通信这部分,再总结总结,起个名字,就叫“行为型模式”。

    《设计模式》中的描述:行为模式涉及到算法和对象间职责的分配。
    行为模式不仅描述对象和类的模式,还描述它们之间的通信模式。
    行为模式使用继承机制在类间分派行为。(还是一头雾水)

    责任链模式(Chain of Responsibility Pattern)
    命令模式(Command Pattern)
    解释器模式(Interpreter Pattern)
    迭代器模式(Iterator Pattern)
    中介者模式(Mediator Pattern)
    备忘录模式(Memento Pattern)
    观察者模式(Observer Pattern)
    状态模式(State Pattern)
    空对象模式(Null Object Pattern)
    策略模式(Strategy Pattern)
    模板模式(Template Pattern)
    访问者模式(Visitor Pattern)

    各个模式之间的关系图

    参见《设计模式》第8页
    在这里插入图片描述

    设计模式的六大原则

    1、开闭原则(Open Close Principle)

    本人理解:增加新功能时,重新定义一个接口(开),不要修改原来的接口(闭)(为了向下兼容,如果修改了,可能对已经使用这个接口的代码造成影响)。

    开闭原则的意思是:对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。简言之,是为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。

    2、里氏代换原则(Liskov Substitution Principle)
    本人理解:子类包括基类的全部功能。

    里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。LSP 是继承复用的基石,只有当派生类可以替换掉基类,且软件单位的功能不受到影响时,基类才能真正被复用,而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化,而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。

    3、依赖倒转原则(Dependence Inversion Principle)

    这个原则是开闭原则的基础,具体内容:针对接口编程,依赖于抽象而不依赖于具体。

    4、接口隔离原则(Interface Segregation Principle)

    这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。它还有另外一个意思是:降低类之间的耦合度。由此可见,其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想,它强调降低依赖,降低耦合。

    5、迪米特法则,又称最少知道原则(Demeter Principle)

    最少知道原则是指:一个实体应当尽量少地与其他实体之间发生相互作用,使得系统功能模块相对独立。

    6、合成复用原则(Composite Reuse Principle)

    合成复用原则是指:尽量使用合成/聚合的方式,而不是使用继承

    展开全文
  •  创建型(为类实例化提供指南) 原型模式 原型模式(Prototype Pattern)是用于创建重复的对象,并且与重新new对象相比较,性能更高。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直...

    说明:文末可下载案例源码                                

                                                 创建型(为类实例化提供指南)

    原型模式原型模式(Prototype Pattern)是用于创建重复的对象,并且与重新new对象相比较,性能更高。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时。[详情...]
    工厂方法工厂方法(FactoryMethod)不在工厂类中进行逻辑判断,程序可以为不同产品类提供不同的工厂,不同的工厂类产不同的产品。当使用工厂方法设计模式时,对象调用者需要与具体的工厂类耦合。[详情...]
    单例模式单例模式(Singleton Pattern)涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。[详情...]
    构造器模式构造器模式(Builder Pattern)使用多个简单的对象一步一步构建成一个复杂的对象。一个 Builder 类会一步一步构造最终的对象。该 Builder 类无需通过其他对象完成构造,独立于其他对象的。[详情...]
    简单工厂模式简单工厂模式(SimpleFactory Pattern)中,我们在创建对象时不会对客户端暴露创建逻辑,是由一个工厂对象决定创建出哪一种产品类的实例。它属于创建型模式,但不属于23种GOF设计模式之一。[详情...]
    抽象工厂模式抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。[详情...]

    说明:文末可下载案例源码 

                                 结构型(为类如何设计以形成更优秀的结构提供指南)

    代理模式在代理模式(Proxy Pattern)中,一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中,我们创建具有现有对象的对象,以便向外界提供功能接口。[详情...]
    桥接模式桥接(Bridge)是用于把抽象化与实现化解耦,使得二者可以独立变化。使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。[详情...]
    外观模式外观模式(Facade Pattern)隐藏系统的复杂性,并向客户端提供一个客户端可以访问系统的接口。它向现有的系统添加一个接口,来隐藏系统的复杂性。[详情...]
    装饰模式装饰器模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构。这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。[详情...]
    享元模式享元模式(Flyweight Pattern)主要用于减少创建对象的数量,以减少内存占用和提高性能。享元模式尝试重用现有的同类对象,如果未找到匹配的对象,则创建新对象。[详情...]
    组合模式组合模式(Composite Pattern),又叫部分整体模式,是用于把一复合对象(对象中引用其他对象)当作一个单一简单的对象。组合模式依据树形结构来组合对象。[详情...]
    适配器模式适配器模式(Adapter Pattern)是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式,它结合了两个独立模块的功能。这种模式涉及到一个单一的类,该类负责加入独立的或不兼容的接口功能。[详情...]

    说明:文末可下载案例源码 

                           行为型(为类与对象交互以及之间职责分配方式提供指南)

    命令模式命令模式(Command Pattern)是一种数据驱动的设计模式,它属于行为型模式。请求以命令的形式包裹在对象中,并传给调用对象。调用对象寻找可以处理该命令的合适的对象,并把该命令传给相应的对象,该对象执行命令。[详情...]
    策略模式在策略模式(Strategy Pattern)中,一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。在策略模式中,我们创建表示各种策略的对象和一个行为随着策略对象改变而改变。[详情...]
    状态模式在状态模式(State Pattern)中,类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。在状态模式中,我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。[详情...]
    模板模式在模板模式(Template Pattern)中,一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现,但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。[详情...]
    中介者模式中介者模式(Mediator Pattern)是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类,该类通常处理不同类之间的通信,并支持松耦合,使代码易于维护。中介者模式属于行为型模式。[详情...]
    解释器模式解释器模式(Interpreter Pattern)提供了评估语言的语法或表达式的方式,它属于行为型模式。这种模式实现了一个表达式接口,该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。[详情...]
    职责链模式责任链模式(Chain of Responsibility Pattern)为请求创建了一个接收者对象的链。这种模式给予请求的类型,对请求的发送者和接收者进行解耦。在这种模式中,通常每个接收者都包含对另一个接收者的引用。[详情...]
    访问者模式在访问者模式(Visitor Pattern)中,我们使用了一个访问者类,它改变了元素类的执行算法。通过这种方式,元素的执行算法可以随着访问者的不同而改变。[详情...]
    迭代器模式迭代器模式(Iterator Pattern)是用于顺序访问集合对象的元素,不需要知道集合对象的底层表示。[详情...]
    备忘录模式备忘录模式(Memento Pattern)保存一个对象的某个状态。在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。[详情...]
    观察者模式当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知它的依赖对象。观察者模式属于行为型模式。[详情...]

    <<<24种设计模式实现案例源码下载>>>

     

     

     

     

     

    展开全文
  • 创建模式 单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式
  • 实验项目二: 创建型设计模式实验 (1)实验目的与原理 ①结合实例,熟练绘制创建型设计模式结构图。 ②结合实例,熟练使用Java面向对象编程语言实现创建型设计模式。 ③通过编程实践,理解每一种创建型设计模式的概念...
  • 设计模式 设计模式是一套被反复使用、经过分类编目的代码设计经验的总结。使用设计模式是为了复用成功的设计和体系结构、复用相似 问题的相同解决方案,保证代码可靠性,使代码编制真正工程化,能够适应需求的变化...
  • java设计模式之创建型设计模式

    千次阅读 2021-10-16 12:19:00
    创建型设计模式: 抽象工厂(Abstract Factory): 用途:提供一个接口以创建一系列相关或相互依赖的对象,而无需指定具体的类。 场景: 一个系统要独立于它的产品的创建。 一个系统要由多个产品系列中的一个来...
  • 设计模式 ① — 创建型模式

    千次阅读 2018-06-07 11:24:26
    创建型模式: 负责对象的创建。工厂方法模式(Factory Method);解决某个对象的创建工作。抽象工厂模式(Abstract Factory): 解决一系列相互依赖对象的创建工作。创建者模式(Builder):解决“一些复杂对象”的...
  • Java经典设计模式之五大创建型模式(附实例和详解)一、概况总体来说设计模式分为三大类:(1)创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。(2)结构型模式,共七种:适配器...
  • 本文实例讲述了PHP设计模式:建造者模式Builder。分享给大家供大家参考,具体如下: 1. 概述  在软件开发的过程中,当遇到一个“复杂的对象”的创建工作,该对象由一定各个部分的子对象用一定的算法构成,由于需求...
  • 文章目录设计模式GoF设计模式简要说明创建型模式简单工厂模式工厂方法模式应用实例模式优缺点适用场景抽象工厂模式模式优缺点结构型模式行为型模式 设计模式 设计模式是在特定环境下为解决某一通用软件设计问题...
  • 设计模式创建型

    千次阅读 2022-04-14 16:02:36
    创建型模式是处理对象创建的设计模式,试图根据实际情况使用合适的方式创建对象。 二:五个模式以及代码实现 2.1 单例模式 基本概念: 单例模式的方法创建的类在当前进程中只有一个实例 internal class Single { ...
  • Java设计模式创建型模式

    千次阅读 2016-05-12 16:11:07
    单例模式 应用场合: 在一个JVM中,该对象只需有一个实例存在 特点: 对于创建频繁的大型对象可以降低系统开销 减轻GC压力(Garbage collection) 安全(核心交易引擎) 实现方式: 加载类时直接创建类的实例...
  • Java设计模式-创建型设计模式-建造者模式
  • Java设计模式-创建型设计模式-抽象工厂模式
  • 设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结,设计模式不是具体的代码,而是一种合理、易拓展、易维护的代码架构思想。设计模式被运用在各种优秀的框架中。掌握设...
  • Java设计模式-创建型设计模式-单例模式
  • 设计模式PPT

    2019-08-08 16:35:04
    创建型模式用来处理对象的创建过程,主要包含以下5种设计模式:  工厂方法模式(Factory Method Pattern)  抽象工厂模式(Abstract Factory Pattern)  建造者模式(Builder Pattern)  原型模式...
  • Java设计模式--创建型设计模式-简单工厂模式
  • 作为一种创建型设计模式,工厂方法模式就是要创建“某种东西”。对于工厂方法,要创建的“东西”是一个产品,这个产品与创建它的类之间不存在绑定。实际上,为了保持这种松耦合,客户会通过一个工厂发出请求,再由...
  • C#设计模式

    2018-10-31 09:15:57
    然后分别讲述了创建型模式、结构型模式和行为型模式,每一类设计模式包括若干种具体模式,共有23种。在介绍每种模式时,给出了一个或多个应用该模式的示例,以便于读者理解。此外,每一章还提供了UML图,用以说明...
  • 【面向对象】——设计模式创建型模式

    千次阅读 热门讨论 2014-12-23 14:52:15
    创建型模式都会讲关于该系统使用哪些具体的类的信息封装起来。允许客户用结构和功能差别很大的“产品”对象配置一个系统。配置可以是静态的,即在编译时指定,也可以是动态的,就是运行时再指定。 创建型模式包括:...
  • 题型库是一个应用在考试信息系统中的计算机软件类型库,包含了表示处理各种题型数据的格式转换、显示和保存等功能的软件类。...文章使用UML的序列图来说明使用创建型设计模式来设计题型库的思路和方法。
  • Java 创建型模式

    千次阅读 2021-10-28 09:59:36
    这种类型的设计模式属于创建型模式,它提供了一种出创建对象的最佳方式。 这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象.
  • 设计模式--创建型模式-单例模式

    万次阅读 2021-02-01 18:10:29
    单例模式是一种创建型设计模式, 让你能够保证一个类只有一个实例, 并提供一个访问该实例的全局节点。 问题 单例模式同时解决了两个问题, 所以违反了_单一职责原则_: 1. 保证一个类只有一个实例。 2. 为该实例...
  • 文档讲设计模式3大类,创建型模式,结构型模式,行为模式,然后对每一种模式进行详细讲解,以及举例当前模式适合的场景,最重要的是还有各种模式的简单代码实现。我个人最开始接触设计模式也是从改书开始的,以前不...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 304,888
精华内容 121,955
关键字:

创建型设计模式包含哪些