精华内容
下载资源
问答
  • 设计模式工厂模式(简单工厂模式工厂方法模式,抽象工厂模式工厂模式介绍简单工厂模式工厂方法模式抽象工厂模式 工厂模式 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式...

    设计模式之工厂模式(简单工厂模式,工厂方法模式,抽象工厂模式)

    工厂模式

    工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

    在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。

    介绍

    意图:定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。

    主要解决:主要解决接口选择的问题。

    何时使用:我们明确地计划不同条件下创建不同实例时。

    如何解决:让其子类实现工厂接口,返回的也是一个抽象的产品。

    关键代码:创建过程在其子类执行。

    应用实例: 1、您需要一台电脑,可以直接从工厂里面提货,而不用去管台电脑是怎么做出来的,以及这台电脑里面的具体实现。

    优点: 1、一个调用者想创建一个对象,只要知道其名称就可以了。 2、扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现,调用者只关心产品的接口。

    缺点:每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。这并不是什么好事。

    注意事项:作为一种创建类模式,在任何需要生成复杂对象的地方,都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式,而简单对象,特别是只需要通过 new 就可以完成创建的对象,无需使用工厂模式。如果使用工厂模式,就需要引入一个工厂类,会增加系统的复杂度。

    简单工厂模式

    在这里插入图片描述
    1、首先我们创建一个抽象产品类接口Computer.java,它是工厂类所创建的所有产品对象的父类,所创建的具体产品对象都是其子类对象;

    package factory;
    /**
     * 抽象接口
     * @author wf
     */
    public interface Computer {
        void creatComputer();
    }
    

    2、然后我们创建具体产品类DellComputer.java,HaseeComputer.java,LenovoComputer.java,它们是简单工厂模式的创建目标,也是抽象产品接口的子类;

    package factory;
    
    /**
     * Dell电脑
     * @author wf
     */
    public class DellComputer implements Computer {
        @Override
        public void creatComputer() {
            System.out.println("Create a dell computer...");
        }
    }
    
    package factory;
    
    /**
     * Hasee电脑
     * @author wf
     */
    public class HaseeComputer implements Computer {
        @Override
        public void creatComputer() {
            System.out.println("CreateFactory a hasee computer...");
        }
    }
    
    package factory;
    
    /**
     * Lenovo电脑
     * @author wf
     */
    public class LenovoComputer implements Computer {
        @Override
        public void creatComputer() {
            System.out.println("CreateFactory a lenovo computer...");
        }
    }
    

    3、准备工作做好后,我们开始创建工厂角色CreateFactory .java,工厂角色即工厂类,它是简单工厂模式的核心,负责实现创建所有产品实例的内部逻辑;工厂类可以被外界直接调用,创建所需的产品对象;

    package factory;
    
    /**
     * 根据传进来的参数的产品类型来 生产/创建 真实的产品实体对象
     * @author wf
     */
    public class CreateFactory {
        public static Computer createComputer(String type) {
            if(type.equals("dellcomputer"))
            	return new DellComputer();
            else if (type.equals("haseecomputer"))
                return new HaseeComputer();
            else if(type.equals("lenovocomputer"))
                return new LenovoComputer();
            else System.out.println("no "+type +" computer");
            return null;
        }
    }
    
    

    4、客户端调用工厂类静态方法创建产品:Client.java

    package factory;
    
    public class Client {
        public static void main(String[] args)
        {
            Computer computer = CreateFactory.createComputer("haseecomputer");
            computer.creatComputer();
        }
    }
    

    输出为:CreateFactory a hasee computer…

    简单工厂类负责了所有产品的创建逻辑,当我们需要新引进一个新产品时,就不得不修改工厂类的产品创建逻辑,在产品类型较多时有可能会造成工厂类的产品创建逻辑过于负责,违背了java设计原则的开-闭原则,不利于系统的维护性和扩展性;

    为了解决上面的问题,下面我们介绍工厂模式的第二种,工厂方法模式。

    工厂方法模式

    工厂方法模式,又称工厂模式、多态工厂模式和虚拟构造器模式,通过定义工厂父类负责定义创建对象的公共接口,而子类则负责生成具体的对象。工厂方法模式将类的实例化(具体产品的创建)延迟到工厂类的子类(具体工厂)中完成,即由子类来决定应该实例化(创建)哪一个类。解决了简单工厂模式中一旦需要生产新产品就需要修改工厂类的方法逻辑的问题。
    在这里插入图片描述

    1、首先我们要创造抽象工厂类AbstractFactory.java,定义具体工厂的公共接口

    package factory;
    
    /**
     * 抽象工厂类,定义具体工厂的公共接口
     * @author wf
     */
    public interface AbstractFactory {
        public Computer computerFactory();
    }
    

    2、创建抽象产品类Computer.java ,定义具体产品的公共接口

    package factory;
    
    /**
     * 抽象产品类,定义具体产品的公共接口
     * @author wf
     */
    public interface Computer {
        void creatComputer();
    }
    

    3、创建具体产品类(继承抽象产品类)DellComputer.java,HaseeComputer.java,LenovoComputer.java, 定义生产的具体产品,以下不一一列出

    package factory;
    
    /**
     * Dell电脑
     * @author wf
     */
    public class DellComputer implements Computer {
        @Override
        public void creatComputer() {
            System.out.println("Create a dell computer...");
        }
    }
    

    4、创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;

    package factory;
    
    public class DellComputerFactory implements AbstractFactory {
        @Override
        public Computer computerFactory() {
            return new DellComputer();
        }
    }
    
    

    5、外界通过调用具体工厂类的方法,从而创建不同具体产品类的实例

    package factory;
    
    public class Client {
        public static void main(String[] args)
        {
            DellComputerFactory dellComputerFactory = new DellComputerFactory();
            dellComputerFactory.computerFactory().creatComputer();
        }
    }
    

    输出:Create a dell computer…

    优点:
    更符合开-闭原则
    新增一种产品时,只需要增加相应的具体产品类和相应的工厂子类即可
    符合单一职责原则
    每个具体工厂类只负责创建对应的产品
    工厂方法模式可以说是简单工厂模式的进一步抽象和拓展,在保留了简单工厂的封装优点的同时,让扩展变得简单,让继承变得可行,增加了多态性的体现。

    抽象工厂模式

    我们在生产电脑的时候,不同电脑的配置都不同,CPU、主板等配件也不同,这时我们就要用到抽象工厂模式,与工厂方法模式相比,抽象工厂模式中的具体工厂不只是创建一种产品,它负责创建一族产品。
    在这里插入图片描述

    参与者

    (1) AbstractFactory(抽象工厂):它声明了一组用于创建一族产品的方法,每一个方法对应一种产品。如上图UML类图中的Factory。

    (2) ConcreteFactory(具体工厂):它实现了在抽象工厂中声明的创建产品的方法,生成一组具体产品,这些产品构成了一个产品族,每一个产品都位于某个产品等级结构中。如上图UML类图中的DellComputerFactory和HaseeComputerFactory。

    (3) AbstractProduct(抽象产品):它为每种产品声明接口,如上图UML类图中的CPU和MainBoard。

    (4) ConcreteProduct(具体产品):它定义具体工厂生产的具体产品对象,实现抽象产品接口中声明的业务方法。如上图UML类图中的InterCPU,InterMainBorad,AMDCpu,AMDBoard。

    为了方便理解,我们在上述的基础上进行修改

    1、两种产品类接口: Cpu.java,MainBoard.java

    package factory;
    
    /**
     * 主板
     */
    public interface Cpu{
    }
    
    package factory;
    
    /**
     * 主板
     */
    public interface MainBoard {
    }
    

    2、具体产品类AMDCpu.java,AMDMainBoard,InterCpu.java,InterMainBoard.java

    package factory;
    
    /**
     * InterCPU
     */
    public class InterCpu implements Cpu {
        public InterCpu()
        {
            System.out.println("Create a InterCpu");
        }
    }
    
    package factory;
    
    /**
     * Inter主板
     */
    public class InterMainBoard implements MainBoard {
        public InterMainBoard()
        {
            System.out.println("Create a nterMainBoard...");
        }
    }
    
    package factory;
    
    /**
     * AMDCPU
     */
    public class AMDCpu implements Cpu {
        public AMDCpu()
        {
            System.out.println("Create a  AMDCpu");
        }
    }
    
    package factory;
    
    /**
     * AMD主板
     */
    public class AMDMainBoard implements MainBoard {
        public AMDMainBoard()
        {
            System.out.println("Create a AMDMainBoard...");
        }
    }
    

    3、抽象工厂类AbstractFactory .java

    package factory;
    
    /**
     * 抽象工厂类,定义具体工厂的公共接口
     * @author wf
     */
    public interface AbstractFactory {
        public Computer computerFactory();
        public Cpu createCpu();
        public MainBoard createMainBoard();
    }
    
    

    4、具体工厂类,只负责生产所需产品

    package factory;
    
    public class DellComputerFactory implements AbstractFactory {
        @Override
        public Computer computerFactory() {
            return new DellComputer();
        }
    
        @Override
        public Cpu createCpu() {
            return new InterCpu();
        }
    
        @Override
        public MainBoard createMainBoard() {
            return new InterMainBoard();
        }
    }
    

    5、生产电脑

    package factory;
    
    public class Client {
        public static void main(String[] args)
        {
            AbstractFactory factory=null;
            factory = new DellComputerFactory();
            factory.createCpu();
            factory.createMainBoard();
            factory.computerFactory().creatComputer();
        }
    }
    

    输出:
    Create a InterCpu
    Create a InterMainBoard…
    Create a dell computer…
    、抽象工厂模式是工厂方法模式的进一步延伸。在抽象工厂模式中,增加新的产品族很方便,但是增加新的产品等级结构很麻烦。

    总体来说,工厂模式适合:凡是出现了大量的产品需要创建,并且具有共同的接口时,可以通过工厂方法模式进行创建。在以上的三种模式中,第一种如果传入的字符串有误,不能正确创建对象,第三种相对于第二种,不需要实例化工厂类,所以,大多数情况下,我们会选用第三种——静态工厂方法模式。

    展开全文
  • 工厂模式

    2015-10-31 16:54:36
    一、什么是设计模式 设计模式(Design Pattern)是一套被反复使用、多数人知晓的,经过分类编目的、...三、工厂模式意图 定义一个接口来创建对象,但是让子类来决定哪些类需要被实例化。  工厂方法把实例化的工作推

    一、什么是设计模式

    设计模式(Design Pattern)是一套被反复使用、多数人知晓的,经过分类编目的、代码设计经验的总结。

    二、什么是工厂模式

    实例化对象,用工厂方法代替new操作。

      工厂模式包括工厂方法模式和抽象工厂模式。

      抽象工厂模式是工厂方法模式的扩展。

    三、工厂模式意图

    定义一个接口来创建对象,但是让子类来决定哪些类需要被实例化。

      工厂方法把实例化的工作推迟到子类中去实现。

    四、什么情况下适合工厂模式

    1、有一组类似的对象需要创建

    2、在编码时不能预见需要创建哪种类的实例。

    3、系统需要考虑扩展性,不应依赖于产品类实例如何被创建、组合和表达的细节。

    五、工厂模式的动机

    项目中现状:

    在软件系统中,经常面临着对象的“对象”的创建工作,由于需求的变化,这个对象可能随之也会发生变化,但它却拥有比较稳定的接口。

    为此,我们需要提供一种封装机制来隔离出这个易变对象的变化,从而保持系统中其他依赖该对象的对象不会随着需求变化而变化。也就是我们要做到低耦合。

    基于项目现状将代码进行如下设计:

    1、尽量松耦合,一个对象的依赖对象的变化与本身无关。

       2、具体产品与客户端剥离,责任分割。

     

    展开全文
  • 设计模式---工厂模式

    2016-04-06 14:34:07
    设计模式---工厂模式 ...2、工厂模式意图 定义一个接口来创建对象,但是让子类来决定哪些类需要被实例化。 工厂方法把实例化的工作推迟到子类中去实现。 什么情况下适用:

    设计模式---工厂模式

    1、工厂模式

    实例化对象,用工厂方法代替new操作。
    工厂模式包括工厂方法模式和抽象工厂模式。
    抽象工厂模式是工厂方法模式的扩展。

    2、工厂模式意图

    定义一个接口来创建对象,但是让子类来决定哪些类需要被实例化。
    工厂方法把实例化的工作推迟到子类中去实现。

    什么情况下适用:
    有一组类似的对象需要创建
    在编码时不能预见需要创建哪种类的实例
    系统需要考虑扩展性,不应依赖于产品类实例如何被创建、组合和表达的细节

    3、类图



    4、常见的应用:



    5、总结

    工厂方法模式与抽象工厂模式对比
    工厂模式是一种极端情况下的抽象工厂模式,而抽象工厂模式可以看成是工厂模式的推广
    工厂模式用来创建一个产品的等级结构,而抽象工厂模式是用来创建多个产品的等级结构
    工厂模式只有一个抽象产品类,而抽象工厂模式有多个产品抽象类

    工厂模式帮我们实现

    系统可以在不修复具体工厂角色的情况下引进新的产品

    客户端不必关心对象如何创建,明确了职责

    更好的理解面向对象的原则,面向接口编程,而不要面向实现编程

    适用哪些场景



    展开全文
  • 工厂方法 定义一个用于创建对象的接口,让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。 抽象工厂 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 建造者模式 将...

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

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

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

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

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

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

    桥接模式
    将抽象部分与它的实现部分分离,使它们都可以独立地变化。(解决类属性多维度变化的问题)

    组合模式
    将对象组合成树形结构以表示"部分-整体"的层次结构。"Composite使得用户对单个对象和组合对象的使用具有一致性。"(完美处理树形递归结构)

    装饰模式
    动态地给一个对象添加一些额外的职责。就增加功能来说,Decorator模式相比生成子类更为灵活。

    外观模式
    为子系统中的一组接口提供一个一致的界面,Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

    享元模式
    运用共享技术有效地支持大量细粒度的对象。

    代理模式
    为其他对象提供一种代理以控制对这个对象的访问。

    责任链模式
    为解除请求的发送者和接收者之间的耦合,而使多个对象都有机会处理请求。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它。

    命令模式
    将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤消的操作。

    解释器模式
    给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。

    迭代器模式
    提供一种方法顺序访问一个聚合对象中的各个元素,而 有不需要暴露该对象的内部表示。

    中介者模式
    用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。

    备忘录模式
    在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。(备忘录模式是以解耦的方式实现业务对象某一时刻状态存储和复原。)

    观察者模式
    定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。(通过观察者模式,以可扩展、可插拔、解耦合的机制,实现一对多对象之间信息交互和同步。)

    状态模式
    允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它所属的类。

    策略模式
    定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。(符合开闭原则,可以通过扩展策略供客户端替换使用)

    模板方法
    定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。TemplateMethod使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。(模板方法模式是基于继承的代码复用技术,面向对象是对多态特性的具体体现,设计原则上是对里氏替换原则的具体体现。)

    访问者模式
    表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。(数据结构和数据所具有的属性是固定不变的,但数据展示操作可能随时改变,通过访问者模式,可以轻松实现变更数据展示形式。accept(visitor){visitor.visit})

    展开全文
  • 意图:定义一个创建对象(Car)的接口,让其子类(宝马、捷豹等)自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。 主要解决:主要解决接口选择的问题。 何时使用:我们明确地计划不同条件下创建...
  • 工厂模式中任何创建对象的工厂类都要实现这个接口,实现接口的方法体中都要实现接口中的方法,它声明了工厂方法,该方法返回一个Product类型的对象。 工厂模式适用场景: 1、当一个类不知道它所必须创建的对象的...
  • Java 工厂模式

    2019-10-09 01:21:08
     工厂模式意图:  1 定义一个接口来创建对象,由子类来决定实例化哪些类。  2 实例化工作交给子类去实现。    适合工厂模式的情况:  1 创建一组类似的对象。  2 不能预见哪个类实例需要实例化。  3 ...
  • 《Android源码设计模式解析与实战》第6章 创建型设计模式–抽象工厂模式 意图 协调对象的实例化,提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 我觉得就是在工厂方法模式里的工厂.....
  • 工厂模式意图 定义一个接口来创建对象,但是让子类来决定哪些类需要被实例化。 工厂方法把实例化的工作推迟到子类中去实现 哪些情况适合? 有一组类似的对象需要创建 编码时不能预见需要创建哪种类的实例 ...
  • 前言 在《设计模式》一书中工厂模式提到了: 工厂方法模式(Factory Method) ...工厂意图 定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。 别名 虚构造器(V
  • Java工厂模式

    2018-02-13 10:47:22
    工厂模式意图 定义一个接口来创建对象,但是让子类决定哪些类需要被实例化 工厂方法把实例化的工作推迟到子类中去实现 什么情况下适合工厂模式 有一组类似的对象需要创建 在编码的时候不能预见需要创建哪种类的...
  • 设计模式 - 抽象工厂模式

    千次阅读 2019-08-20 09:57:25
    文章目录设计模式 - 抽象工厂模式1、意图2、实例1、定义颜色,样式接口2、定义颜色,样式枚举3、定义颜色实例4、定义样式实例5、定义工厂接口 - 可以创建不同的工厂6、定义颜色工厂7、定义样式工厂8、定义工厂枚举 -...
  • 概念:实例化对象,用工厂方法代替new操作工程模式包括工厂方法模式和抽象工厂模式抽象工厂模式是工厂方法模式的扩展意图:定义一个接口来创建对象,但是让子类来决定哪些类需要被实例化工厂方法把实例化的工作推迟...
  • 工厂模式 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。...意图:定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。 主要解决:主要解...
  • 今天在慕课上学习了模式的秘密——工厂模式和抽象工厂模式,还需要更加深入地了解。(以下内容整理自慕课网) ... (一) 工厂模式是什么?...(二) 工厂模式意图是什么? 定义一个接口来创建对象,但是让子类来决定
  • 二,介绍意图:定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。主要解决:主要解决接口选择的问题。何时使用:我们明确地计划不同条件下创建不同实例时。如何...
  • JAVA设计模式--简单工厂模式

    万次阅读 2016-05-18 10:39:23
    一、什么是简单工厂模式 二、简单工厂模式的结构 三、简单工厂模式的优缺点 一、什么是简单工厂模式 简单工厂模式属于类的创建型模式。提供一个创建对象实例的功能,而无须关心其具体实现。被创建实例的类型可以...
  • 几种设计模式意图或优势总结

    热门讨论 2018-04-27 09:21:22
    抽象工厂:提供一个创建一系列相关或互相依赖对象的接口,而无须指明它们具体的类。 建造者:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 工厂:定义一个用于创建对象的接口,让...
  • 工厂模式意图:定义一个用于创建对象的接口,并控制返回哪个类的实例。 工厂方法模式不仅要求有一个能够创建新对象的方法,还需要让客户代码无须了解具体实例化的类。工厂方法模式通常包含了若干类,这些类实现了...
  • 简单工厂模式

    2019-09-30 21:47:12
    一、简单工厂模式意图:根据提供的数据类型。选择一个类进行实例化。 二、UML图描述: 三、代码示例: 举例说明: 工作中薪资的计算方式: 程序员=底薪+ 绩效; 销售员=底薪+提成; 助理=底薪+平均奖金; ...
  • 抽象工厂模式

    千次阅读 2019-09-25 20:07:55
    抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在抽象工厂模式中,接口是负责...
  • 工厂模式工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。...意图:定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。主要解决:主要解决接口选
  • 设计模式 - 简单工厂模式

    千次阅读 2019-08-20 09:38:51
    文章目录设计模式 - 简单工厂模式1、意图2、实例1、创建颜色接口 - 定义生产的产品是什么2、创建颜色枚举 - 定义生产哪些类型的产品3、根据颜色枚举创建产品 - 根据产品清单生产产品4、创建工厂 - 对外提供产品5、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,443
精华内容 13,777
关键字:

工厂模式的意图