精华内容
下载资源
问答
  • I . 原型模式 概念简介 II . 原型模式 使用场景 III . 原型模式缺点 IV . 原型模式 实现及 简单示例



    I . 原型模式 概念简介



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


    ① 设计模式类型 : 创建型设计模式 ;

    ② 原型实例对象 : 给出原型实例对象 , 根据该对象创建新对象 ;

    ③ 创建对象类型 : 创建对象的种类由原型的实例对象类型确定 ;

    ④ 创建方式 : 不调用构造函数 , 而是通过克隆原型的实例对象 , 使用现有对象创建另一个相同类型的对象 , 隐藏创建细节 ;



    II . 原型模式 使用场景



    原型模式使用场景 : 原型模式的目的是 降低实例对象个数 , 减少构造函数的调用次数 ;


    ① 类初始化消耗资源过多 : 如果类初始化时消耗过多的资源 , 如这个类中某个成员占用大量内存 , 为了节省开销 ;

    ② 初始化繁琐耗时 : 类对象创建时经过大量的计算 , 或与本地资源 ( 数据库 , 文件 ) 频繁交互 , 每次创建消耗大量的 CPU 与 时间资源 ;

    ③ 构造函数复杂 : 类中定义的构造函数复杂 ;

    ④ 实例对象数量庞大 : 如果在内存中循环创建了很多该实例对象 , 就可以使用原型模式复用不用的对象 , 用于创建新对象 ;



    III . 原型模式 优缺点



    1 . 原型模式优点 : 性能高 , 简单 ;


    ① 性能高 : 使用原型模式复用的方式创建实例对象 , 比使用构造函数重新创建对象性能要高 ; ( 针对类实例对象开销大的情况 )

    ② 流程简单 : 原型模式可以简化创建的过程 , 可以直接修改现有的对象实例的值 , 达到复用的目的 ; ( 针对构造函数繁琐的情况 )


    2 . 原型模式缺点 : 实现复杂 , 坑多 ;


    ① 覆盖 clone 方法 ( 必须 ) : 必须重写对象的 clone 方法 , Java 中提供了 cloneable 标识该对象可以被拷贝 , 但是必须覆盖 Object 的 clone 方法才能被拷贝 ;

    ② 深拷贝 与 浅拷贝 风险 : 克隆对象时进行的一些修改 , 容易出错 ; 需要灵活运用深拷贝与浅拷贝操作 ;



    IV . 原型模式 实现及 简单示例



    1 . 原型模式实现 :


    ① 对象创建原理 : 创建实例对象时使用原型模式 , 就是调用类的 clone 方法 , 直接克隆拷贝现有的实例对象 , 生成新的对象 ;

    ② 实现 Cloneable 接口 : 原型模式类需要实现 Cloneable 接口 , 如下面的 Student 类 ( class Student implements Cloneable ) 就实现了该接口 ;

    ③ 重写 clone() 方法 : 通常情况下直接调用父类的 clone 方法即可 , 这种方式是浅拷贝 ,

    protected Object clone() throws CloneNotSupportedException{}
    

    2 . 原型模式类代码示例 :


    ① 代码实现 : Student 类实现 Cloneable 接口 , 重写了 clone() 方法 , 直接调用父类的 clone() 方法 ;

    ② 地址打印 : 注意 toString 中调用到了父类的打印方法 , super.toString() , 该方法打印 类名@地址 信息 , 可以帮助我们通过内存地址信息 , 看到是否真正的创建了一个新的实例对象 ;

    package kim.hsl.design.prototype;
    
    /**
     * 原型模式实现流程 : 使用 clone 方法实现原型模式
     * 1 . 类继承 Cloneable 接口
     * 2 . 实现 protected Object clone() 方法
     */
    public class Student implements Cloneable {
        private String name;
        private int age;
    
        public Student() {
            System.out.println("调用 Student 默认构造函数");
        }
    
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            System.out.println("调用 Student clone 方法");
            return super.clone();
        }
        
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", " + super.toString() +
                    '}';
        }
    }
    

    3 . 使用原型模式创建实例测试代码 :


    ① 创建一个原型对象 : 首先使用构造函数 , 创建一个原型对象 newStudent , 之后的对象都是根据该原型对象 clone 创建的 ;

    ② 使用原型模式创建对象 : 循环中 , 通过调用原型对象 newStudent 的 clone() 方法 , 创建一个新的对象 ;

    ③ 性能分析 : 使用 clone 方法创建对象 , 比直接使用 new 构造函数方法开销更小 , 性能更高 , 如果要创建大量该对象示例 , 建议使用原型模式 , 使用 clone() 方法大量创建该对象 ;

    package kim.hsl.design.prototype;
    
    public class Main {
    
        public static void main(String[] args) {
            try {
                //测试使用 clone 方法实现的原型模式 , 使用原型模式创建 10 个对象
                Student newStudent = new Student();
    
                /*
                    需求声明 : 此时要创建 10 个 Student 对象
                             依次调用一个创建好的 Student 对象的 clone 方法 10 次
                             即可创建 10 个不同的对象
                    适用场景 : 这是频繁创建大量的对象 , 该场景下适合使用原型模式
                 */
                for (int i = 0; i < 10; i++) {
                    // 1 . 使用 clone 方法创建对象
                    Student student = (Student) newStudent.clone();
                    // 2 . 设置克隆出的对象参数
                    student.setName("Tom" + i);
                    student.setAge(10 + i);
    
                    System.out.println(student);
                }
            } catch (CloneNotSupportedException e) {
                //捕获 clone 方法可能产生的异常
                e.printStackTrace();
            }
        }
    }
    

    4 . 执行结果 : 通过打印出的字符串序列分析 , 注意每个对象的地址 Student@1b6d3586 , Student@4554617c … , 10 个对象的地址都不相同 , 说明每个对象都是一个新的实例对象 ;

    调用 Student 默认构造函数
    Student clone 方法
    注册学生信息 : Student{name='Tom0', age=10, kim.hsl.design.prototype.Student@1b6d3586}
    Student clone 方法
    注册学生信息 : Student{name='Tom1', age=11, kim.hsl.design.prototype.Student@4554617c}
    Student clone 方法
    注册学生信息 : Student{name='Tom2', age=12, kim.hsl.design.prototype.Student@74a14482}
    Student clone 方法
    注册学生信息 : Student{name='Tom3', age=13, kim.hsl.design.prototype.Student@1540e19d}
    Student clone 方法
    注册学生信息 : Student{name='Tom4', age=14, kim.hsl.design.prototype.Student@677327b6}
    Student clone 方法
    注册学生信息 : Student{name='Tom5', age=15, kim.hsl.design.prototype.Student@14ae5a5}
    Student clone 方法
    注册学生信息 : Student{name='Tom6', age=16, kim.hsl.design.prototype.Student@7f31245a}
    Student clone 方法
    注册学生信息 : Student{name='Tom7', age=17, kim.hsl.design.prototype.Student@6d6f6e28}
    Student clone 方法
    注册学生信息 : Student{name='Tom8', age=18, kim.hsl.design.prototype.Student@135fbaa4}
    Student clone 方法
    注册学生信息 : Student{name='Tom9', age=19, kim.hsl.design.prototype.Student@45ee12a7}
    
    展开全文
  • 原型模式的优缺点

    2021-06-11 18:24:27
    function Person() { } Person.prototype = { constructor: Person, name: "LiBai", age: 60, job: "诗人", friends: ["杜甫", "白居易"], sayName: function() { console.log(this.name) ...
    function Person() {
    
    }
    
    Person.prototype = {
        constructor: Person,
        name: "LiBai",
        age: 60,
        job: "诗人",
        friends: ["杜甫", "白居易"],
        sayName: function() {
            console.log(this.name)
        }
    };
    var person1 = new Person();
    var person2 = new Person();
    
    //可识别对象类型的问题
    console.log(person1 instanceof Person);
    console.log(person2 instanceof Person);
    //共享方法,节省内存
    console.log(person1.sayName == person2.sayName);
    

    问题:所有实例都会共享引用类型的值

    person1.friends.push("孟浩然");
    console.log(person1.friends);
    // ["杜甫", "白居易", "孟浩然"]
    console.log(person2.friends);
    // ["杜甫", "白居易", "孟浩然"]
    
    展开全文
  • 2、原型(Prototype)模式:将一个对象作为原型,通过对其进行复制而克隆出多个和原型类似的新实例。 3、工厂方法(Factory Method)模式:定义一个用于创建产品的接口,由子类决定生产什么产品。 4、抽象工厂...

    1、单例(Singleton)模式:某个类只能生成一个实例,该类提供了一个全局访问点供外部获取该实例,其拓展是有限多例模式。

    2、原型(Prototype)模式:将一个对象作为原型,通过对其进行复制而克隆出多个和原型类似的新实例。

    3、工厂方法(Factory Method)模式:定义一个用于创建产品的接口,由子类决定生产什么产品。

    4、抽象工厂(AbstractFactory)模式:提供一个创建产品族的接口,其每个子类可以生产一系列相关的产品。

    5、建造者(Builder)模式:将一个复杂对象分解成多个相对简单的部分,然后根据不同需要分别创建它们,最后构建成该复杂对象。

    6、代理(Proxy)模式:为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象,从而限制、增强或修改该对象的一些特性。

    7、适配器(Adapter)模式:将一个类的接口转换成客户希望的另一个接口,使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

    8、桥接(Bridge)模式:将抽象与实现分离,使它们可以独立变化。它是用组合关系代替继承关系来实现,从而降低了抽象和实现这两个可变维度的耦合。

    9、装饰(Decorator)模式:动态的给对象增加一些职责,即增加其额外的功能。

    10、外观(Facade)模式:为多个复杂的子系统提供一个一致的接口,使这些子系统更加容易被访问。

    11、享元(Flyweight)模式:运用共享技术来有效地支持大量细粒度对象的复用。

    12、组合(Composite)模式:将对象组合成树状层次结构,使用户单个对象和组合对象具有一致的访问性。

    13、模板方法(TemplateMethod)模式:定义一个操作中的算法骨架,而将算法的一些步骤延迟到子类中,使得子类可以不改变该算法结构的情况下定义该算法的某些特定步骤。

    14、策略(Strategy)模式:定义了一系列算法,并将每个算法封装起来,使它们可以相互替换,且算法的改变不会影响使用算法的客户。

    15、命令(Command)模式:将一个请求封装为一个对象,使发出请求的责任和执行请求的责任分隔开。

    16、职责链(Chain of Responsibility)模式:把请求从链中的一个对象传到下一个对象,直到请求被响应为止。通过这种方式去除对象之间的耦合。

    17、状态(State)模式:允许一个对象在其内部状态改变时改变其行为能力。

    18、观察者(Observer)模式:多个对象间一对多关系,当一个对象发生改变时,把这种改变通知给其他多个对象,从而影响其他对象的行为。

    19、中介者(Mediator)模式:定义一个中介对象来简化原有对象之间的交互关系,降低系统中对象间的耦合度,使原有对象之间不必相互了解。

    20、迭代器(Iterator)模式:提供一种方法来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。

    21、访问者(Visitor)模式:在不改变集合元素的前提下,为一个集合中的每个元素提供多种访问方式,即每个元素有多个访问者对象访问。

    22、备忘录(Memento)模式:在不破坏封装性的前提下,获取并保存一个对象的内部状态,以便以后恢复它。

    23、解释器(Interpreter)模式:提供如何定义语言的文法,以及对语言句子的解释方法,即解释器。

     

    一、开闭原则

    定义:一个软件实体,如类,模块和函数应该对拓展开放,对修改关闭。用抽象构建框架,用实现拓展细节。

    优点:提高软件系统的可复用性及可维护性。

    二、依赖倒置原则

    定义:高层模块不应该依赖低层模块,两者都应该依赖其抽象。抽象不应该依赖细节;细节应该依赖抽象。针对接口编程,不要针对实现编程

    优点:可以减少类之间的耦合性、提高系统稳定性、提高代码可读性和可维护性,可降低修改程序所造成的风险。

    三、单一职责原则

    定义:不要存在多于一个导致类变更的原因。一个类\接口\方法只负责一项职责。

    优点:降低类的复杂度、提高类的可读性,提高系统的可维护性、降低变更引起的风险。

    四、接口隔离原则

    定义:用多个专门的接口,而不使用单一的总接口,客户端不应该依赖它不需要的接口。一个类对一个类的依赖应该建立在最小的接口上。建立单一接口,不要建立庞大臃肿的接口。尽量细化接口,接口中的方法尽量少。

    优点:符合我们常说的高内聚低耦合的设计思想,从而使得类具有良好的可读性、可拓展性和可维护性。

    五、迪米特原则

    定义:一个对象应该对其他对象保持最少的了解。又叫最少知道原则。尽量降低类与类之间的耦合。强调只和朋友交流,不和陌生人说话。朋友--出现在成员变量、方法的输入、输出参数中的类称为成员朋友类,而出现在方法体内部的类不属于朋友类。

    优点:降低类之间的耦合。

    六、里式替换原则

    定义:如果对每一个类型为T1的对象O1,都有类型为T2的对象O2,使得以T1定义的所有程序P在所有的对象O1都替换成O2时,程序P的行为没有发生变化,那么类型T2是类型T1的子类型。

    定义拓展:一个软件实体如果适用一个父类的话,那一定适用于其子类,所有引用父类的地方必须能透明地使用其子类的对象,子类对象能够替换父类对象,而程序逻辑不变。

    引申意义:子类可以拓展父类的功能,但不能改变父类原有的功能。

    含义1:子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法。

    含义2:子类中可以增加自己特有的方法。

    含义3:当子类的方法重载父类的方法时,方法的前置条件(即方法的输入/入参)要比父类方法的输入参数更宽松。

    含义4:当子类的方法实现父类的方法时(重写\重载或实现抽象方法),方法的后置条件(即方法的输出\返回值)要比父类更严格或相等。

    优点1:约束继承泛滥,开闭原则的一种体现。

    优点2:加强程序的健壮性,同时变更时也可以做到非常好的兼容性,提高程序的维护性、拓展性。降低需求变更时引入的风险。

    七、合成(组合)/聚合复用原则

    定义:尽量使用对象组合/聚合,而不是继承关系达到软件复用的目的。

    优点:可以使系统更加灵活,降低类与类之间的耦合度,一个类的变化对其他类造成的影响相对较少。

    八、简单工厂

    定义:由一个工厂对象决定创建出哪一种产品类的实例。

    类型:创建型,但不属于GOF23种设计模式。

    使用场景:工厂类负责创建的对象比较少。客户端(应用层)只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心。

    优点:只需要传入一个正确的参数,就可以获取你所需要的对象,而无需知道其创建的细节。

    缺点:工厂类的职责相对过重,增加新的产品,需要修改工厂类的判断逻辑,违背开闭原则。

    九、工厂方法

    定义:定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个类,工厂方法让类的实例化推迟到子类中进行。

    适用场景:创建对象需要大量重复的代码。客户端(应用层)不依赖于产品类实例如何被创建、实现等细节。一个类通过其子类来指定创建哪个对象。

    优点:用户只需要关心所需的产品对应的工厂,无需关心创建细节。加入新产品符合开闭原则,提高可拓展性。

    缺点:类的个数容易过多,增加复杂度。增加了系统的抽象性和理解难度。

    十、抽象工厂

    定义:抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口。无需指定它们具体的类。

    使用场景:客户端(应用层)不依赖于产品实例如何被创建、实现等细节。强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量重复的代码。提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。

    优点:具体产品在应用层代码隔离,无需关心创建细节。将一个系列的产品族统一到一起创建。

    缺点:规定了所有可能被创建的产品集合,产品族中扩展新的产品困难,需要修改抽象工厂的接口。增加了系统的抽象性和理解难度。

     

    十一、建造者模式

    定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。用户只需指定所要建造的类型就可以得到它们,建造过程及细节不需要知道。

    适用场景:如果一个对象有非常复杂的内部结构(很多属性)。想把复杂对象的创建和使用分离。

    优点:封装性好,创建和使用分离。扩展性好、建造类之间独立、一定程度上解耦。

    缺点:产生多余的Builder对象。产品内部发生变化,建造者都要修改,成本较大。

    十二、单例设计模式

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

    适用场景:想确保任何情况下都绝对只有一个实例。

    优点:在内存里只有一个实例,减少了内存的开销。可以避免对资源的多重占用。设置全局访问点,严格控制访问。

    缺点:没有接口,扩展困难。

    重点:私有构造器。线程安全。延迟加载。序列化和反序列化安全。反射。

    十三、原型模式

    定义:指原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。不需要知道任何创建的细节,不调用构造函数

    适用场景:类初始化消耗较多资源。new产生的一个对象需要非常繁琐的过程(数据准备、访问权限等)。构造函数比较复杂。循环体中产生大量对象时。

    优点:原型模式性能比直接new一个对象性能高。简化创建过程。

    缺点:必须配备克隆方法。对克隆复杂对象或对克隆出的对象进行复杂改造时,容易引入风险。深拷贝、浅拷贝要运用得当。

    十四、外观模式

    定义:又叫门面模式,提供了一个统一的接口,用来访问子系统中的一群接口。外观模式定义了一个高层接口,让子系统更容易使用。

    使用场景:子系统越来越复杂,增加外观模式提供简单调用接口。构建多层系统结构,利用外观对象作为每层的入口,简化层间调用。

    优点:简化了调用过程,无需了解深入子系统,防止带来风险。减少系统依赖、松散耦合。更好的划分访问层次。符合迪米特法则,即最少知道原则。

    缺点:增加子系统、扩展子系统行为容易引入风险。不符合开闭原则。

    十五、装饰者模式

    定义:在不改变原有对象的基础上,将功能附加到对象上。提供了比继承更有弹性的替代方案(扩展原有对象功能)。

    优点:继承的有力补充,比继承灵活,不改变原有对象的情况下给一个对象扩展功能。通过使用不同装饰类以及这些装饰类的排列组合,可以实现不同的效果。符合开闭原则。

    缺点:会出现更多的代码,更多的类,增加程序复杂性。动态装饰时,多层装饰时会更复杂。

    十六、适配器模式

    定义:将一个类的接口转换成客户期望的另一个接口。使原本接口不兼容的类可以一起工作。

    适用场景:已经存在的类,它的方法和需求不匹配时(方法结果相同或相似)。不是软件设计阶段考虑的设计模式,是随着软件维护,由于不同产品、不同厂家造成功能类似而接口不相同情况下的解决方案。

    优点:能提高类的透明性和复用,现有的类复用但不需要改变。目标类和适配器类解耦,提高程序扩展性。符合开闭原则。

    缺点:适配器编写过程需要全面考虑,可能会增加系统的复杂性。增加系统代码可读的难度。

    十七、享元模式

    定义:提供了减少对象数量从而改善应用所需的对象结构的方式。运用共享技术有效地支持大量细粒度的对象

    适用场景:常常应用于系统底层的开发,以便解决系统的性能问题。系统有大量相似对象、需要缓冲池的场景。

    优点:减少对象的创建,降低内存中对象的数量,降低系统的内存,提高效率。减少内存之外的其他资源占用。

    缺点:关注内/外部状态、关注线程安全问题。使系统、程序的逻辑复杂化。

    十八、组合模式

    定义:将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式是客户端对单个对象和组合对象保持一致的方式处理。

    适用场景:希望客户端可以忽略组合对象与单个对象的差异时。处理一个树形结构时。

    优点:清楚地定义分层次的复杂对象,表示对象的全部或部分层次。让客户端忽略了层次的差异,方便对整个层次结构进行控制。简化客户端代码。符合开闭原则。

    缺点:限制类型时会较为复杂。使设计变得更加抽象。

    十九、桥接模式

    定义:将抽象部分与它的具体实现部分分离,使它们都可以独立地变化。通过组合的方式建立两个类之间关系,而不是继承。

    适用场景:抽象和具体实现之间增加更多的灵活性。一个类存在两个(或多个)独立变化的维度,且这两个(或多个)维度都需要独立进行拓展。不希望使用继承,或因为多层继承导致系统类的个数剧增。

    优点:分离抽象部分及其具体实现部分。提高了系统的可扩展性。符合开闭原则。符合合成复用原则。

    缺点:增加了系统的理解与设计难度。需要正确地识别出系统中两个独立变化的维度。

    二十、代理模式

    定义:为其他对象提供一种代理,以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介的作用。

    适用场景:保护目标对象。增强目标对象。

    优点:代理模式能将代理对象与真实被调用的目标对象分离。一定程度上降低了系统的耦合度,扩展性好。保护目标对象。增强目标对象。

    缺点:代理模式会造成系统设计中类的数目增加。在客户端和目标对象增加一个代理对象,会造成请求处理速度变慢。增加系统的复杂度。

    二十一、模板模式

    定义:定义了一个算法的骨架,并允许子类为一个或多个步骤提供实现。模板方法使得子类可以在不改变算法结构的情况下,重新定义算法的某些步骤。

    适用场景:一次性实现一个算法的不变的部分,并将可变的行为留给子类来实现。各子类中公共的行为被提取出来并集中到一个公共父类中,从而避免代码重复。

    优点:提高复用性,提高扩展性,符合开闭原则。

    缺点:类数目增加。增加了系统实现的复杂度。继承关系自身缺点,如果父类添加新的抽象方法,所有子类都要改一遍。

    二十二、迭代器模式

    定义:提供一种方法,顺序访问一个集合对象中的各个元素,而又不暴露该对象的内部表示。

    适用场景:访问一个集合对象的内容而无需暴露它的内部表示。为遍历不同的集合结构提供一个统一的接口。

    优点:分离了集合对象的遍历行为。

    缺点:类的个数成对增加。

    二十三、策略模式

    定义:定义了算法家族,分别封装起来,让它们之间可以相互替换,此模式让算法的变化不会影响到使用算法的用户。

    适用场景:系统有很多类,而它们的区别仅仅在于它们的行为不同。一个系统需要动态地在几种算法中选择一种。

    优点:符合开闭原则。避免使用多重条件转移语句。提高算法的保密性和安全性。

    缺点:客户端必须知道所有的策略类,并自行决定使用哪一个策略类。产生很多策略类。

    二十四、解释器模式

    定义:给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。为了解释一种语言,而为语言创建的解释器。

    适用场景:某个特定类型问题发生频率足够高。

    优点:语法由很多类表示,容易改变及扩展此"语言"。

    缺点:当语法规则数目太多时,增加了系统复杂度。

    二十五、观察者模式

    定义:定义了对象之间的一对多依赖,让多个观察者对象同时监听某一个主题对象,当主题对象发生变化时,它的所有依赖者(观察者)都会收到通知并更新。

    适用场景:关联行为场景,建立一套触发机制。

    优点:观察者和被观察者之间建立一个抽象的耦合。观察者模式支持广播通信。

    缺点:观察者之间有过多的细节依赖、提高时间消耗及程序复杂度。使用要得当,要避免循环调用。

    二十六、备忘录模式

    定义:保存一个对象的某个状态,以便在适当的时候恢复对象。“没有后悔药”。“存档”。

    适用场景:保存及恢复数据相关业务场景。后悔的时候,即想恢复到之前的状态。

    优点:为用户提供一种可恢复机制。存档信息的封装。

    缺点:资源占用。

    二十七、命令模式

    定义:将"请求"封装成对象,以便使用不同的请求。命令模式解决了应用程序中对象的职责以及它们之间的通信方式。

    适用场景:请求调用者和请求接收者需要解耦,使得调用者和接受者不直接交互。需要抽象出等待执行的行为。

    优点:降低耦合。容易扩展新命令或一组命令。

    缺点:命令的无限扩展会增加类的数量,提高系统实现复杂度。

    二十八、中介者模式

    定义:定义一个封装一组对象如何交互的对象。通过使对象明确地相互引用来促进松散耦合,并允许独立的改变它们的交互。

    适用场景:系统中对象之间存在复杂的引用关系,产生的相互依赖关系结构混乱且难以理解。交互的公共行为,如果需要改变行为则可以增加新的中介类。

    优点:将一对多转换成了一对一,降低程序复杂度。类之间解耦。

    缺点:中介者过多,导致系统复杂。

    二十九、责任链模式

    定义:为请求创建一个接受此次请求对象的链。

    适用场景:一个请求的处理需要多个对象当中的一个或几个协作处理。

    优点:请求的发送者和接受者(请求的处理)解耦。责任链可以动态组合。

    缺点:责任链太长或者处理时间过长,影响性能。责任链有可能过多。

    三十、访问者模式

    定义:封装作用于某数据结构(如List/Set/Map等)中的各元素的操作。可以在不改变各元素的类的前提下,定义作用于这些元素的操作。

    适用场景:一个数据结构如(List/Set/Map等)包含很多类型对象。数据结构与数据操作相分离。

    优点:增加新的操作很容易,即增加一个新的访问者。

    缺点:增加新的数据结构困难。具体元素变更比较麻烦。

    三十一、状态模式

    定义:允许一个对象在其内部状态改变时,改变它的行为。

    适用场景:一个对象存在多个状态(不同状态下行为不同),且状态可相互转换。

    优点:将不同的状态隔离。把各个状态的转换逻辑,分布到State的子类中,减少相互间依赖。增加新的状态很简单。

    缺点:状态多的业务场景导致类数目增加,系统变复杂。

     

    展开全文
  • 模板方法模式是最为简单也最常用的设计模式之一了,它主要利用了Java的多态的特性,通过把所有的不会变化的定义放到一个抽象类(模板类)里实现,会变化的方法定义成抽象方法,再使用其子类对会变化的地方进行自定义...

    模板方法模式是最为简单也最常用的设计模式之一了,它主要利用了Java的多态的特性,通过把所有的不会变化的定义放到一个抽象类(模板类)里实现,会变化的方法定义成抽象方法,再使用其子类对会变化的地方进行自定义实现。

    模板方法模式的定义:Define the skeleton of an algorithm in an operation,deferring some steps to subclasses.Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure. (定义一个操作中的算法的框架, 而将一些步骤延迟到子类中。 使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 )

    这次我们还是拿汽车厂制造白色、黑色汽车这个业务场景来举例讲解:普通实现到模板方法模式的演进

    普通实现

    类图:

    ads

    代码:

    1. 定义两个颜色的汽车工厂

      /**
       * 生产白色汽车的工厂
       */
      public class WhiteCarFactory {
          void createFrame(){
              System.out.println("制造汽车框架");
          }
          void installComponent(){
              System.out.println("安装零件");
          }
          void coloring() {
              System.out.println("给汽车喷上白色的车漆");
          }
          void over(){
              System.out.println("汽车制造完毕");
          }
      
          void builderCar(){
              // 1. 制造汽车框架
              createFrame();
              // 2. 安装汽车零件
              installComponent();
              // 3. 汽车喷漆,上色
              coloring();
              // 4. 汽车制造完毕
              over();
          }
      }
      /**
       * 生产黑色汽车的工厂
       */
      public class BlackCarFactory {
          void createFrame(){
              System.out.println("制造汽车框架");
          }
          void installComponent(){
              System.out.println("安装零件");
          }
          void coloring() {
              System.out.println("给汽车喷上黑色的车漆");
          }
          void over(){
              System.out.println("汽车制造完毕");
          }
      
          void builderCar(){
              // 1. 制造汽车框架
              createFrame();
              // 2. 安装汽车零件
              installComponent();
              // 3. 汽车喷漆,上色
              coloring();
              // 4. 汽车制造完毕
              over();
          }
      }
      
    2. 实际调用

      public static void main(String[] args) {
          WhiteCarFactory whiteCarFactory=new WhiteCarFactory();
          BlackCarFactory blackCarFactory=new BlackCarFactory();
          // 生产白色汽车
          whiteCarFactory.builderCar();
          // 生产黑色汽车
          blackCarFactory.builderCar();
      }
      

      输出结果:

      image-20200731170031163

      功能虽然已经实现了,但是相信大家看到这里已经看出问题了,就是这两个类里面存在了大量的重复代码。而我们在实际软件开发过程中, 如果相同的一段代码复制过两次, 就需要对设计产生怀疑,架构师要明确地说明为什么相同的逻辑要出现两次或更多次。

      很明显,我们需要把这些冗余的重复代码给优化掉,那么应该怎么设计呢?

    模板方法模式实现

    类图:

    ClassDiagram12

    业务代码

    1. 这里先定义一个汽车的制造流程 抽象(模板)类AbstractCarFactory

      /**
       * 汽车工厂
       */
      public abstract class AbstractCarFactory {
          void createFrame(){
              System.out.println("制造汽车框架");
          }
          void installComponent(){
              System.out.println("安装零件");
          }
          abstract void coloring();
          void over(){
              System.out.println("汽车制造完毕");
          }
      
          void builderCar(){
              // 1. 制造汽车框架
              createFrame();
              // 2. 安装汽车零件
              installComponent();
              // 3. 汽车喷漆,上色
              coloring();
              // 4. 汽车制造完毕
              over();
          }
      }
      
    2. 定义汽车工厂的实现类,生产白色汽车的工厂和生产黑色汽车的工厂

      /**
       * 生产白色汽车的工厂
       */
      public class WhiteCarFactory extends AbstractCarFactory{
          void coloring() {
              System.out.println("给汽车喷上白色的车漆");
          }
      }
      /**
       * 生产黑色汽车的工厂
       */
      public class BlackCarFactory  extends AbstractCarFactory{
          void coloring() {
              System.out.println("给汽车喷上黑色的车漆");
          }
      }
      
    3. 代码调用

      public static void main(String[] args) {
          AbstractCarFactory whiteCarFactory=new WhiteCarFactory();
          AbstractCarFactory blackCarFactory=new BlackCarFactory();
          // 生产白色汽车
          whiteCarFactory.builderCar();
          // 生产黑色汽车
          blackCarFactory.builderCar();
      }
      

      执行结果:

      image-20200731170031163

    以上代码是不是看着很眼熟,特别是你如果看到过我的另外一篇描写抽象工厂模式的文章,对!你没看错,抽象工厂模式里面定义抽象工厂时,确实很大一部分就是使用的这个模板方法模式,而我们在项目实际开发时有意无意的代码中也会有模板方法模式的实践,只不过大多数情况下并没有认为这是个设计模式。

    优点:

    • 模板方法模式是通过把不变的行为挪到一个统一的父类,从而达到去除子类中重复代码的目的、
    • 子类实现模板父类的某些细节,有助于模板父类的扩展
    • 通过一个父类调用子类实现的操作,通过子类扩展增加新的行为,符合“开放-封闭原则”

    缺点:

    • 按照设计习惯,抽象类负责声明最抽象、最一般的事物属性和方法,实现类负责完成具体的事务属性和方法,但是模板方式正好相反,子类执行的结果影响了父类的结果,会增加代码阅读的难度

    适用场景:

    • 多个子类有共有的方法,并且逻辑基本相同
    • 重要、复杂的算法,可以把核心算法设计为模板方法,周边的相关细节功能则由各个子类实现
    • 重构时,模板方法是一个经常使用的方法,把相同的代码抽取到父类中,然后通过构造函数约束其行为
    展开全文
  • 主要介绍了C++设计模式编程中策略模式的优缺点及实现,文中讨论了策略模式中设计抽象接口的继承和组合之间的区别,需要的朋友可以参考下
  • 设计模式之优缺点(二)

    热门讨论 2018-02-06 09:37:01
    前言上篇博客描述的是创建型模式和结构型模式中的模式的优缺点及适用场景,接下来就再学习一下行为型模式模式的优缺点和适用场景吧。正文1. 观察者模式优点:松耦合,使各自的变化不会影响另一边的变化 缺点:不...
  • 设计模式之优缺点(一)

    千次阅读 热门讨论 2018-02-05 17:26:08
    前言什么东西,什么事物都是有正反两面的,设计模式也不例外,也是既有优点,又有缺点,当然也有该用它的场合。正文1. 工厂方法模式优点:使用工厂方法模式,创建客户所需产品,用户只需关心产品对应的工厂,其他都...
  • 原型模式Java设计模式——原型模式概念使用场景Java里的克隆代码理解prototype(原型)问题总结优缺点模型优点模型缺点 概念 ​ 原型模式是创建型模式的最后一种,讲到原型模式就不得不提到克隆这个词,克隆这个词...
  • 工厂模式(Factory Pattern) 是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个...
  • 常用设计模式的一些优缺点

    千次阅读 2019-06-05 17:03:57
    1 简单工厂模式(Static Factory Method) 适用场景 工厂类负责创建的对象比较少。 客户只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心。 由于简单工厂很容易违反高内聚责任分配原则,因此一般只在很简单...
  • 原型模式(Prototype Pattern),是一种创建型设计模式,指的是以原型实例指定待创建对象的种类,并通过拷贝(克隆)原型对象来创建新的对象。
  • 原型模式是一个创建型的模式。用原型实例指定创建对象的种类,并且通过拷贝这些原型,创建新的对象。原型模式多用于创建复杂的或者构造耗时的实例,因为这种情况下,复制一个已经存在的实例可使程序运行更高效。原型...
  • 原型模式缺点: * 虽然省略了为构造函数传递初始化参数这一环节,结果所有的实例都有了默认的相同的属性值。会带来一些不方便,但主要问题还是由其共享的本质所导致的。 * 原型中所有的属性是被很多实例共享的,这...
  • 四、原型模式的优点和缺点 Prototype模式优点: 1、可以在运行时刻增加和删除产品 2、可以改变值以指定新对象 3、可以改变结构以指定新对象 4、减少子类的构造 5、用类动态配置应用 Prototype模式缺点: Prototype...
  • 原型模式介绍,包括应用场景,优缺点模式结构,类图 以及 C++代码示例
  • 2013-03-21整理出来的23个设计模式的优缺点,部分地方的理解可能不是很到位。 简单的介绍了23个设计模式的优点和缺点,以及使用场景,同时举了该设计模式的经典例子。
  • MVC三层架构 MVC是 模型(Model),视图(View)和控制(Controller)的缩写,其目的实现Web系统的职能分工。其中Model层实现系统中的业务逻辑,通常可以用JavaBean或EJB来实现; View层用于与用户的交互,通常用JSP来实现...
  • 设计模式(十六)原型模式

    千次阅读 2017-06-26 00:11:53
    公众号有同学留言设计模式,才发现好久没有写设计模式了。关于创建型设计模式只差原型模式没写了,这一篇就来填补这个空缺。
  • 设计模式及其优缺点

    千次阅读 2018-06-29 16:31:10
    设计模式 1.单例模式: 实现方式: a) 将被实现的类的构造方法设计成private的。 b) 添加此类引用的静态成员变量,并为其实例化。 c) 在被实现的类中提供公共的CreateInstance函数,返回实例化的此类,就是b...
  • 各个设计模式的优缺点

    千次阅读 2015-11-02 14:04:47
    设计原则 1、找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。 2、针对接口编程(实际上是针对超类编程),而不是针对实现编程。 策略模式(Strategy Pattern) 优点: 缺点:1....
  • builder设计模式的使用以及优缺点

    千次阅读 2018-08-30 18:02:19
    所以为了解决这个矛盾,可以使用builder(构建器)设计模式了,下面给出一个具体点的列子: package net.itaem.test; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java...
  • 原型模式

    千次阅读 2018-06-12 09:47:26
    原型模式是简单程度仅次于单例模式的简单模式,它的定义可以简单理解为对象的拷贝,通过拷贝的方式创建一个已有对象的新对象,这就是原型模式设计类图:   在原型模式中主要的任务是实现一个接口,这个接口...
  • 缺点:一是如果需要生产的产品过多,此模式会导致工厂类过于庞大,承担过多的职责,变成超级类; ​ 二是当生成新产品时,必须在工厂类中添加新的分支。这违背了开闭原则 工厂方法模式 工厂方法模式就是将简单工厂的...
  • 设计模式 | 原型模式及典型应用

    千次阅读 2018-09-15 00:49:41
    前言 本文的主要内容如下: 介绍原型模式 示例 Java语言的clone 浅克隆与深克隆 ...原型模式的工作原理很简单:将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象...
  • Java设计模式之单例模式
  • 什么是原型模式
  • 设计模式原型模式

    千次阅读 2017-04-09 17:49:38
    1 原型模式概念1.1 介绍 原型模式是一个创建型的模式原型二字表明了改模式应该有一个样板实例,用户从这个样板对象中复制一个内部属性一致的对象,这个过程也就是我们称的“克隆”。被复制的实例就是我们所称的...
  • Java设计模式原型模式

    千次阅读 2016-09-03 11:39:24
    (尊重劳动成果,转载请注明出处:https://blog.csdn.net/qq_25827845/article/details/52422098冷血之心的博客) 目录 个人理解: 定义: 通用类图如下所示: ...原型模式的使用场景 ...原型模式的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 378,290
精华内容 151,316
关键字:

原型模式的缺点