精华内容
下载资源
问答
  • 创建型模式主要用于创建对象
    千次阅读
    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上

    以上就是单例模式的总结

    总结:

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

    更多相关内容
  • 创建型模式主要用于创建对象。 • 结构型模式主要用于处理类或对象的组合。 • 行为型模式主要用于描述对类或对象怎样交互和怎样分配职责。 根据范围,即模式主要是用于处理类之间关系还是处理对象之间的...

    复习设计模式有两周了,有必要重新把设计模式的整体结构梳理一下,在此摘录刘伟老师的教材中部分知识点,做个笔记。

    一、设计模式的分类

    根据其 目的 (模式是用来做什么的)可分为 创建型 (Creational) 结构型 (Structural) 行为型 (Behavioral) 三种:
    创建型模式主要用于 创建对象
    结构型模式主要用于 处理类或对象的组合
    行为型模式主要用于 描述对类或对象怎样交互和怎样分配职责
    根据 范围 ,即模式主要是用于处理类之间关系还是处理 对象之间的关系,可分为 类模式 对象模式 两种:
    类模式 处理类和子类之间的关系 ,这些关系通过继承建立,在编译时刻就被确定下来,是属于 静态 的。
    对象模式 处理对象间的关系 ,这些关系在运行时刻变化,更具 动态 性。

    二、GoF设计模式

    创建型模式
    • 抽象工厂模式(Abstract Factory)
    • 建造者模式(Builder)
    • 工厂方法模式(Factory Method)
    • 原型模式(Prototype)
    • 单例模式(Singleton)
    结构型模式
    • 适配器模式(Adapter)
    • 桥接模式(Bridge)
    • 组合模式(Composite)
    • 装饰模式(Decorator)
    • 外观模式(Facade)
    • 享元模式(Flyweight)
    • 代理模式(Proxy)
    行为型模式
    • 职责链模式(Chain of Responsibility)
    • 命令模式(Command)
    • 解释器模式(Interpreter)
    • 迭代器模式(Iterator)
    • 中介者模式(Mediator)
    • 备忘录模式(Memento)
    • 观察者模式(Observer)
    • 状态模式(State)
    • 策略模式(Strategy)
    • 模板方法模式(Template Method)
    • 访问者模式(Visitor)

    三、创建型模式

    创建型模式 (Creational Pattern) 对类的实例化过程进 行了抽象,能够 将软件模块中对象的创建和对象的使用 分离 。为了使软件的结构更加清晰,外界对于这些对象 只需要知道它们共同的接口,而不清楚其具体的实现细 节,使整个系统的设计更加符合单一职责原则。
    创建型模式在 创建什么 (What) 由谁创建 (Who) 时创建 (When) 等方面都为软件设计者提供了尽可能大 的灵活性。创建型模式 隐藏了类的实例的创建细节,通 过隐藏对象如何被创建和组合在一起达到使整个系统独 立的目的

    四、结构型模式

    描述 如何将类或者对 象结合在一起形成更大的结构 ,就像搭积木,可以通过 简单积木的组合形成复杂的、功能更为强大的结构。
    结构型模式可以分为 类结构型模式 对象结构型模式
    类结构型模式关心类的组合 ,由多个类可以组合成一个更大的系统,在类结构型模式中一般只存在继承关系和实现关系。
    对象结构型模式关心类与对象的组合,通过关联关系使得在一个类中定义另一个类的实例对象,然后通过该对象调用其方法。 根据“合成复用原则”,在系统中尽量使用关联关系来替代继承关系,因此大部分结构型模式都是 对象结构型模式

    五、行为型模式

    行为型模式 (Behavioral Pattern) 是对 在不 同的对象之间划分责任和算法的抽象化
    行为型模式不仅仅关注类和对象的结构,而 重点关注它们之间的相互作用 通过行为型模式,可以更加清晰地 划分类与
    对象的职责 ,并 研究系统在运行时实例对象 之间的交互 。在系统运行时,对象并不是孤 立的,它们可以通过相互通信与协作完成某 些复杂功能,一个对象在运行时也将影响到 其他对象的运行。
    行为型模式分为 类行为型模式 对象行为型模式 两种:
    类行为型模式 :类的行为型模式 使用继承关系在几个类之间分配行为 ,类行为型模式主要通过多态等方式来分配父类与子类的职责。
    对象行为型模式 :对象的行为型模式则 使用对象的聚合关联关系来分配行为 ,对象行为型模式主要是通过对象关联等方式来分配两个或多个类的职责。根据“合成复用原则”,系统中要尽量使用关联关系来取代继承关系,因此大部分行为型设计模式都属于对象行为型设计模式
    展开全文
  • Java 创建型模式

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

    Java 创建型模式

    持续更新…

    创建者模式的主要关注点是‘怎样创建对象?’,它的主要特点是‘将对象的创建和使用分离’。
    这样可以降低系统的耦合度,使用者不需要关注对象的创建细节。
    创建型模式分为:
    • 单例模式
    • 工厂方法模式
    • 抽象工厂模式
    • 原型模式
    • 建造者模式

    单例模式

    单例模式是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种出创建对象的最佳方式。
    这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类对象。

    单例模式的结构

    单例模式主要有以下角色:

    • 单例类,只能创建一个实例的类
    • 访问类,使用单例的类

    点击此可以查看更多有关单例模式的细节

    工厂模式

    工厂模式是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。主要用于解决接口问题。

    UML类图实例:

    BookStore +sellBook(String type) : NoteBook «abstract» NoteBook #writeContent(String content) : void EnglishBook -String type -String content +getContent() : String +getDescription() : String MathBook -String type -String content +getContent() : String +getDescription() : String

    代码实现如下:

    package com.wu;
    
    public abstract class NoteBook {
        public abstract  void writeContent(String content);
    }	
    
    package com.wu;
    
    public class EnglishBook extends NoteBook{
        private static final String TYPE = "英语本";
        private String content;
    
        public void writeContent(String content){
            this.content = content;
        }
        public String getContent(){
            return "内容为:" + content;
        }
        public String getDescription(){
            return "这是一个英语本";
        }
    }
    
    package com.wu;
    
    public class MathBook extends NoteBook{
        private static final String TYPE = "数学本";
        private String content;
    
        public void writeContent(String content){
            this.content = content;
        }
        public String getContent(){
            return "内容为:" + content;
        }
        public String getDescription(){
            return "这是一个数学本";
        }
    }
    
    package com.wu;
    
    public class BookStore {
        public NoteBook sellBook(String type) throws RuntimeException{
            NoteBook book = null;
            if(type.equals("英语本")){
                book =  new EnglishBook();
            }else if(type.equals("数学本")){
                book = new MathBook();
            }else{
                throw new  RuntimeException();
            }
            return book;
        }
    }
    
    
    package com.wu;
    
    public class Client {
        public static void main(String[] args) {
            // 创建书店对象
            BookStore booKStore = new BookStore();
            // 销售数学本
            NoteBook book = booKStore.sellBook("数学本");
            System.out.println(((MathBook) book).getDescription());
            // 销售英语本
            book = booKStore.sellBook("英语本");
            System.out.println(((MathBook) book).getDescription());
        }
    }
    

    可以分析以上的代码,由于通过BookStore来创建(new)Book对象,所以导致了BookStore对Book对象的耦合,假如我们需要更换对象的时候,就会修改相应的代码,这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象,我们就只需要和工厂来进行信息交换就可以了,就可以彻底和对象解耦,因此,工厂模式的最大优势就是:解耦合

    三种工厂模式

    • 简单工厂模式(不属于经典设计模式)
    • 工厂方法模式
    • 抽象工厂模式

    简单工厂模式

    简单工厂角色

    • 抽象产品:定义了产品规范
    • 具体产品:实现或者继承抽象产品的子类
    • 具体工厂:提供了创建产品的方法,调用者通过该方法来获取产品

    优缺点

    • 优点:
      封装了创建对象的过程,可以通过参数直接获取对象。把对象的创建和业务逻辑层分开,这样以后就可以避免了修改客户代码,如果要实现新的产品就可以直接修改工厂类,而不需要原代码中修改,这样就降低了客户代码修改的可能性,更加容易扩展。
    • 缺点:
      增加新的产品还是需要修改工厂类的代码,违背了“开闭原则”

    UML类图:

    BookStore +sellBook(String type) : NoteBook SimpleBookFactory +createBook(String type) : NoteBook «abstract» NoteBook #writeContent(String content) : void EnglishBook -String type -String content +getContent() : String +getDescription() : String MathBook -String type -String content +getContent() : String +getDescription() : String

    修改的代码:

    package com.wu;
    
    public class SimpleBookFactory {
        public NoteBook createBook(String type){
            NoteBook noteBook = null;
            if(type.equals("英语本")){
                noteBook =  new EnglishNoteBook();
            }else if(type.equals("数学本")){
                noteBook = new MathNoteBook();
            }else{
                throw new  RuntimeException();
            }
            return noteBook;
        }
    }
    
    package com.wu;
    
    public class BookStore {
        public NoteBook sellBook(String type) throws RuntimeException{
            SimpleBookFactory factory = new SimpleBookFactory();
            NoteBook noteBook = factory.createBook(type);
            return noteBook;
        }
    }
    
    

    静态工厂:

    package com.wu;
    
    public class SimpleBookFactory {
        public static NoteBook createBook(String type){
            NoteBook noteBook = null;
            if(type.equals("英语本")){
                noteBook =  new EnglishNoteBook();
            }else if(type.equals("数学本")){
                noteBook = new MathNoteBook();
            }else{
                throw new  RuntimeException();
            }
            return noteBook;
        }
    }
    

    工厂方法模式

    针对上面中的未遵循开闭原则,我们可以通过工厂方法模式来完美地解决。

    概念
    定义一个用于创建对象的接口,让子类决定实例化哪个产品类对象。工厂方法

    工厂方法模式角色

    • 抽象工厂:提供了创建产品的接口,调用者通过它访问具体的工厂的工厂方法来创建产品。
    • 具体工厂:主要是实现抽象工厂中的抽象方法,完成具体产品的创建。
    • 抽象产品:定义了产品规范,描述了产品的主要特性和功能。
    • 具体产品:实现了抽象产品角色所定义的接口,有具体工厂来创建,它同具体工厂之间一一对应。

    优缺点

    • 优点:
      用户只需要知道具体工厂的名称就可以得到所要的产品,无须知道产品的具体创建过程
      在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂进行任何修改,满足开闭原则
    • 缺点:
      每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类,这增加了系统的复杂度

    UML类图:

    BookStore +sellBook() : NoteBook «interface» BookFactory +createBook() : NoteBook «abstract» NoteBook #writeContent(String content) : void EnglishBookFactory +createBook() : NoteBook MathBookFactory +createBook() : NoteBook EnglishBook -String type -String content +getContent() : String +getDescription() : String MathBook -String type -String content +getContent() : String +getDescription() : String

    代码实现:

    package com.wu;
    
    public class BookStore {
        private BookFactory factory;
    
        public void setFactory(BookFactory factory) {
            this.factory = factory;
        }
    
        public NoteBook sellBook() throws RuntimeException{
            NoteBook book = factory.createBook();
            return book;
        }
    }
    
    package com.wu;
    
    public abstract class NoteBook {
        public abstract  void writeContent(String content);
    }
    
    
    package com.wu;
    
    public interface BookFactory {
        public NoteBook createBook();
    }
    
    
    package com.wu;
    
    public class MathBookFactory implements BookFactory{
    
        @Override
        public NoteBook createBook() {
            return new MathNoteBook();
        }
    }
    
    
    package com.wu;
    
    public class EnglishBookFactory implements BookFactory{
    
        @Override
        public NoteBook createBook() {
            return new EnglishNoteBook();
        }
    }
    
    
    package com.wu;
    
    public class MathNoteBook extends NoteBook {
        private static final String TYPE = "数学本";
        private String content;
    
        public void writeContent(String content){
            this.content = content;
        }
        public String getContent(){
            return "内容为:" + content;
        }
        public String getDescription(){
            return "这是一个数学本";
        }
    }
    
    
    package com.wu;
    
    public class EnglishNoteBook extends NoteBook {
        private static final String TYPE = "英语本";
        private String content;
    
        public void writeContent(String content){
            this.content = content;
        }
        public String getContent(){
            return "内容为:" + content;
        }
        public String getDescription(){
            return "这是一个英语本";
        }
    }
    
    
    package com.wu;
    
    public class Client {
        public static void main(String[] args) {
            // 创建书店对象
            BookStore bookStore = new BookStore();
            // 销售数学本
            MathBookFactory mathBookFactory = new MathBookFactory();
            bookStore.setFactory(mathBookFactory);
            NoteBook noteBook = bookStore.sellBook();
            System.out.println(((MathNoteBook) noteBook).getDescription());
            // 销售英语本
            EnglishBookFactory englishBookFactory = new EnglishBookFactory();
            bookStore.setFactory(englishBookFactory);
            noteBook = bookStore.sellBook();
            System.out.println(((EnglishNoteBook) noteBook).getDescription());
        }
    }
    
    

    抽象工厂模式

    抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
    在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

    概念
    是一种为访问类提供一个创建一组相关或相互依赖对象的接口,且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
    抽象工厂模式时工厂方法模式的升级版本,工厂方法模式只生产一个等级的产品,而抽象工厂模式可生产多个等级的产品。

    抽象工厂模式主要角色

    • 抽象工厂:提供了创建产品的接口,它包含多个创建产品的方法,可以创建多个不同等级的产品
    • 具体工厂:主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建
    • 抽象产品:定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品
    • 具体产品:实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间是多对一的关系

    优缺点

    • 优点:
      当一个产品族中的多个对象设计成一起工作时,它能保证客户端始终使用一个产品族中的对象
    • 缺点:
      当产品族中需要增加一个新产品时,所有工厂类都需要进行修改

    使用场景

    • 当需要创建的对象是一系列相互依赖的产品族时
    • 系统中有多个产品族,但每次只使用其中的某一族产品
    • 系统中提供了产品的类库j,且所有产品的接口相同,客户端不依赖产品实例的创建细节和内部结构

    UML类图:

    MathBookFactory +createNoteBook() : NoteBook +createTextBook() : TextBook «interface» BookFactory +createNoteBook() : NoteBook +createTextBook() : TextBook EnglishBookFactory +createNoteBook() : NoteBook +createTextBook() : TextBook EnglishTextBook +description() : void TextBook +description() : void MathTextBook +description() : void MathNoteBook +description() : void NoteBook +description() : void EnglishNoteBook +description() : void

    代码如下:

    package com.wu;
    
    public interface BookFactory {
        // 生产本子的功能
        NoteBook createNoteBook();
        // 生产教科书的功能
        TextBook createTextBook();
    }
    
    
    package com.wu;
    
    public class Client {
        public static void main(String[] args) {
            MathBookFactory mathBookFactory = new MathBookFactory();
            // 创建数学教科书
            TextBook mathTextBook = mathBookFactory.createTextBook();
            mathTextBook.description();
            // 创建数学本子
            NoteBook mathNoteBook = mathBookFactory.createNoteBook();
            mathNoteBook.description();
    
            EnglishBookFactory englishBookFactory = new EnglishBookFactory();
            // 创建英语本子
            NoteBook englishNoteBook = englishBookFactory.createNoteBook();
            englishNoteBook.description();
            // 创建英语教科书
            TextBook englishTextBook = englishBookFactory.createTextBook();
            englishTextBook.description();
        }
    }
    
    
    package com.wu;
    
    public class EnglishBookFactory implements BookFactory{
    
        @Override
        public NoteBook createNoteBook() {
            return new EnglishNoteBook();
        }
    
        @Override
        public TextBook createTextBook() {
            return new EnglishTextBook();
        }
    }
    
    
    package com.wu;
    
    public class EnglishNoteBook extends NoteBook {
        @Override
        public void description(){
            System.out.println("这是一个英语本… ");
        }
    }
    
    
    package com.wu;
    
    public class EnglishTextBook extends TextBook{
    
        @Override
        public void description() {
            System.out.println("这是一本英语教科书… ");
        }
    }
    
    
    package com.wu;
    
    public class MathBookFactory implements BookFactory{
    
        @Override
        public NoteBook createNoteBook() {
            return new MathNoteBook();
        }
    
        @Override
        public TextBook createTextBook() {
            return new MathTextBook();
        }
    }
    
    
    package com.wu;
    
    public class MathNoteBook extends NoteBook {
        @Override
        public void  description(){
            System.out.println("这是一个数学本… ");
        }
    }
    
    
    package com.wu;
    
    public class MathTextBook extends TextBook{
        @Override
        public void description() {
            System.out.println("这是一本数学教科书… ");
        }
    }
    
    
    package com.wu;
    
    public abstract class NoteBook {
        public abstract void description();
    }
    
    
    package com.wu;
    
    public abstract class TextBook {
        public abstract void description();
    }
    
    
    展开全文
  • 【面向对象】——设计模式之创建型模式

    千次阅读 热门讨论 2014-12-23 14:52:15
    创建型模式创建型模式抽象了实例化的过程。它们帮助一个系统独立于如何创建、组合和表示它的那些对象创建型模式都会讲关于该系统使用哪些具体的类的信息封装起来。允许客户用结构和功能差别很大的“产品”对象...


    创建型模式:创建型模式抽象了实例化的过程。它们帮助一个系统独立于如何创建、组合和表示它的那些对象。创建型模式都会讲关于该系统使用哪些具体的类的信息封装起来。允许客户用结构和功能差别很大的“产品”对象配置一个系统。配置可以是静态的,即在编译时指定,也可以是动态的,就是运行时再指定。

    创建型模式包括:工厂方法,抽象工厂,建造者,原型,单例。

    工厂方法:

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


    工厂方法模式,完全符合了开放-封闭原则。较简单工厂而言,工厂方法模式实现时,客户端需要决定实例化哪一个工厂来实现运算类,选择判断的问题还是存在的,也就是说,工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。当想要加功能时,本来改工厂类,现在只需改客户端。更加符合了开放-封闭原则。


    抽象工厂:

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


    这个例子是解决不能换数据库问题的。当换数据库时,用代码直接切换数据库工厂即可,而不需更改大量代码。很好的实现了开放-封闭原来,和依赖倒转原则。

    抽象工厂模式便于交换产品系列,由于具体工厂类,在一个应用中只需要在初始化的时候出现一次,这就使得改变一个应用的具体工厂变得非常容易,它只需要改变具体工厂即可使用不同的产品配置。另,它让具体的创建实例过程与客户端分离,客户端是通过他们的抽象接口操纵实例,产品的具体类名也被具体工厂的实现分离,不会出现在客户代码中。


    单例模式:

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


    通常我们可以让一个全局变量使得一个对象被访问,但它不能防止你实例化多个对象。一个最好的办法就是,让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建,并且它可以提供一个访问该实例的方法。


    原型模式:

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


    原型模式其实就是从一个对象再创建另外一个可定制的对象,而且不需知道任何创建的细节。其实,原型模式就相当于克隆,建一个实现模型的接口,便可克隆对象了。并且建立相应数目的原型并克隆它们通常比每次用合适的状态手工实例化该类方便很多。


    建造者:

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


    建造者模式,主要用于创建一些复杂的对象,这些对象内部构建间的建造顺序通常是稳定的,但对象内部的构建通常面临着复杂的变化。符合了合成/聚合复用原则。

    如果你需要将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示的时候,我们就需要创建者模式,将一个产品的内部表象与产品的生成过程分割开来,从而可以使一个建造过程生成具有不同的内部表象的产品对象。如果用了建造者模式,那么用户就只需要指定需要的建造的类型就可以得到他们,而具体建造的过程和细节就不需要了。


    总:通常设计是从工厂方法开始,当设计者发现需要更大的灵活性时,设计便会向其他创建型模式演化,当设计者在设计标准间进行权衡的时候,了解多个创建型模式可以给设计者更多的选择余地。

    展开全文
  • 设计模式之创建型模式

    万次阅读 2022-06-16 21:39:59
    本篇是23中设计模式中的创建型设计模式汇总,主要讲解了工厂模式、单例模式、构建者模式、原型模式,各个模式从概念,示例,框架中的应用等方面对每一种框架进行解读,是一篇不错的设计模式入门文章。希望大家收藏...
  • 创建模式 单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式
  • 这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。例如,一个对象需要在一个高...
  • 工厂模式创建对象的最佳方式)

    千次阅读 2021-07-14 10:01:02
    这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。 工厂模式具体包括了简单工厂、...
  • 创建型设计模式——抽象工厂模式

    千次阅读 2022-02-11 10:19:11
    抽象工厂模式: 定义了一个interface用于创建相关或有依赖关系的对象簇,而无需指明具体的类。 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。 从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者...
  • 设计模式 - 创建型设计模式 - 原型模式(Java)

    万次阅读 多人点赞 2019-02-19 19:51:19
    请点击http://www.captainbed.net 这是要说的创建型模式的最后一个设计模式了。 原型模式很简单:有一个原型实例,基于这个原型实例产生新的实例,也就是“克隆”了。 Object 类中有一个 clone() 方法,它用于生成...
  • 创建型模式,共五种

    千次阅读 多人点赞 2016-11-18 19:23:17
     ——可复用面向对象软件的基础 设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 ...
  • 工厂模式将目的将创建对象的具体过程屏蔽隔离起来,从而达到更高的灵活性,工厂...抽象工厂模式用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时,通过抽象工厂模式,保证客户端始终只使用同一个产品族
  • 创建型模式——工厂方法模式

    千次阅读 2020-07-10 08:22:13
    创建型模式——工厂方法模式 (一)概述 工厂方法模式定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method是一个类的实例化延迟到其子类。 在工厂方法模式中,核心的工厂类不再负责所有的产品的...
  • 设计模式-创建型模式总结

    千次阅读 2017-07-24 20:24:25
    创建型模式,顾名思义,就是用来创建对象的模式。它抽象了实例化过程,帮助一个系统独立于如何创建、组合和表示它的对象。
  • 设计模式 ① — 创建型模式

    千次阅读 2018-06-07 11:24:26
    创建型模式: 负责对象的创建。工厂方法模式(Factory Method);解决某个对象的创建工作。抽象工厂模式(Abstract Factory): 解决一系列相互依赖对象的创建工作。创建者模式(Builder):解决“一些复杂对象”的...
  • UML、对象创建型模式

    万次阅读 2019-12-03 21:02:20
    是类与类之间最常用的一种关系, 它是一种结构化关系,用于表示一类对象与另一类对象之间有联系。 单线实箭头,可自关联 关联关系中要表明对象间的关联关系,如是一对多还是一对一 依赖关系(Dependency) 一种使用...
  • 创建型模式——单例模式

    千次阅读 2020-07-09 10:19:51
    单例模式是最简单的设计模式之一,属于创建型模式,它提供了一种特殊的创建对象的方式,确保全局中只有单个对象被创建。这个设计模式主要目的是想在整个系统中只能出现类的一个实例,即一个类只有一个对象。 单例...
  • C++创建型模式-工厂模式

    千次阅读 多人点赞 2021-08-12 08:56:59
    简单工厂模式(Simple Factory Pattern)专门定义一个类来负责创建其他类的实例,被创建的实例通常具有共同的父类。 1.2 简单工厂模式的角色 二、C++实现工厂模式 参考文献: 【1】 ......
  • 1.单例模式 单例模式(Singleton Pattern):确保某一个类只有一个实例,而且自己实例化并向整个系统提供这个实例。  通用类图如下:    通用代码如下:public class Singleton { private static final ...
  • 创建型模式总结

    千次阅读 热门讨论 2019-03-21 17:41:12
    创建型模式有以下几个模式: 简单工厂:用来生产同一等级结构中的任意产品。(不支持拓展增加产品) 工厂方法 :用来生产同一等级结构中的固定产品。(支持拓展增加产品) 抽象工厂 :用来生产不同产品族的全部...
  • 好吧,在Java 5之前的版本,使用双重检查锁定创建单例Singleton,记得使用volatile变量。从Java 5开始,使用Enum创建线程安全的Singleton很容易。 Java枚举和单例模式 Java中的枚举单例模式是使用枚举在Jav...
  • 设计模式之“创建型模式

    千次阅读 热门讨论 2014-12-08 12:02:53
    创建型模式主要分为五大模式,分别为:抽象工厂模式、建造者模式、工厂方法模式、原型模式、单例模式。 抽象工厂模式  提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 一、优点...
  • 设计模式--六种创建型模式

    千次阅读 热门讨论 2017-04-13 16:58:25
    前言  每几种模式之间都有一定的联系,从中发现它们的相同点和不同点,研究发生改变的节点,这就是本篇博客所要说明的创建型设计模式之间的联系。它们包括:简单工厂模式、...一个类创建型模式使用继承改变被实例
  • 创建型模式中关于工厂的模式

    千次阅读 热门讨论 2014-03-21 11:09:41
    创建型模式中,有3中关于工厂的模式,分别是:简单工厂模式,工厂方法模式,抽象工厂模式。这3中模式既有各自的优点,同时,这3中模式又可以逐步演化:如,简单工厂可以演化成工厂方法,工厂方法可以演化成抽象...
  • 创建型设计模式之Builder模式

    千次阅读 2017-04-30 11:28:05
     Builder模式是一步一步创建一个复杂对象创建型模式,它允许用户在不知道内部构建细节的情况下,可以更精细地控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的部件解耦,使得构建过程和部件的表示...
  • java设计模式创建型设计模式

    千次阅读 2021-10-16 12:19:00
    创建型设计模式: 抽象工厂(Abstract Factory): 用途:提供一个接口以创建一系列相关或相互依赖的对象,而无需指定具体的类。 场景: 一个系统要独立于它的产品的创建。...用途:定义一个用于创建对象的接
  • 前言    每几种模式之间都有一定的联系,从中发现它们的相同点和不同点,研究发生改变的节点,这就是本篇博客所要说明的创建型设计模式之间的联系。...一个类创建型模式使用继承改变被实例化的类...
  • 总结三种类型的设计模式的区别和联系

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 272,784
精华内容 109,113
热门标签
关键字:

创建型模式主要用于创建对象