具体聊一聊简单工厂模式、工厂方法模式和抽象工厂模式

1.工厂模式简介

In class-based programming, the factory method pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created. ( 在基于类的编程中，工厂方法模式是一种创建模式，它使用工厂方法来处理创建对象的问题，而不必指定将要创建的对象的确切类。) ——引用自维基百科

? 通过上面的描述我们可以通过一个基类来创建多个子类，然后实现相应的方法，最后调用基类中的方法（工厂方法）来返回某个子类实例，并加以运用。这种方式增强了类的复用性和可扩展性。

2.工厂模式的类型

工厂模式主要有以下几种类型:

? ①简单工厂模式：通过传入相关的类型来确切的返回相应的类,这种方式比较单 一,可扩展性相对较差;

②工厂方法模式：通过实现类实现相应的方法来决定相应的返回结果,这种方式的可扩展性比较强；

③抽象工厂方法模式：这个模式是以上模式的扩展，相比工厂方法而言，它所能生产的不只是一种产品，还可以是一组产品。
工厂模式的优点：
  • 解耦 ：把对象的创建和使用的过程分开
  • 降低代码重复: 如果创建某个对象的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。
  • 降低维护成本 ：由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建某个对象的地方去逐个修正，只需要在工厂里修改即可，降低维护成本。

3.相关实例

①简单工厂：

? 这里我们举个简单的栗子，拿我们平时最常见的笔类来说，以此作为接口，含有书写的方法，分别有圆珠笔、铅笔、马克笔实现了笔类的接口。我们分别实现它的方法，描述一段话，然后我们根据简单工厂的方法得出每个书写的具体内容，也就是我们书写用的是什么类型的笔。

/**
 * 笔类接口
 */
interface Pen {
    void write();
}

/**
 * 圆珠笔
 */
class BallpointPen implements Pen {
    public void write() {
        System.out.println("书写:我是圆珠笔!");
    }
}

/**
 * 铅笔
 */
class Pencil implements Pen {
    public void write() {
        System.out.println("书写:我是铅笔!");
    }
}

/**
 * 马克笔
 */
class MarkerPen implements Pen {
    public void write() {
        System.out.println("书写:我是马克笔!");
    }
}

/**
 * 简单工厂
 */
class SimpleFactory {
    public Pen getPen(String type) {
        switch (type) {
            case "ballpointPen":
                return new BallpointPen();
            case "pencil":
                return new Pencil();
            case "markerPen":
                return new MarkerPen();
            default:
                return null;
        }
    }

}

public class PenWithType {

    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        Pen ballpointPen = simpleFactory.getPen("ballpointPen");
        ballpointPen.write();
        Pen pencil = simpleFactory.getPen("pencil");
        pencil.write();
        Pen markerPen = simpleFactory.getPen("markerPen");
        markerPen.write();
    }

}

输出结果：

书写:我是圆珠笔!
书写:我是铅笔!
书写:我是马克笔!
②工厂方法模式

? 这个模式是使用最广泛的模式，通过子类来确定所需要创建的类型，每一个子类你都可以看做是一个小型工厂，可以生产一种产品，然后调用相应的方法。（如笔类工厂的相关类别：圆珠笔工厂、铅笔工厂、马克笔工厂等）还是拿我们上面的栗子进行变换，但是这次你会发现相比简单工厂而言，此种方法具有更多的可扩展性和复用性，同时也增强了代码的可读性。

/**
 * 笔类工厂
 */
interface PenFactory {

    PenFactory getPen();

    void write();
}

/**
 * 圆珠笔工厂
 */
class BallpointPenFacTory implements PenFactory {
    public PenFactory getPen() {
        return new BallpointPenFacTory();
    }

    public void write() {
        System.out.println("书写:我是圆珠笔!");
    }
}

/**
 * 铅笔工厂
 */
class PencilFacTory implements PenFactory {
    public PenFactory getPen() {
        return new PencilFacTory();
    }

    public void write() {
        System.out.println("书写:我是铅笔!");
    }
}

/**
 * 马克笔工厂
 */
class MarkerPenFacTory implements PenFactory {
    public PenFactory getPen() {
        return new MarkerPenFacTory();
    }

    public void write() {
        System.out.println("书写:我是马克笔!");
    }
}

public class PenWithType {

    public static void main(String[] args) {
        BallpointPenFacTory ballpointPenFacTory = new BallpointPenFacTory();
        PenFactory penFactory = ballpointPenFacTory.getPen();
        penFactory.write();
    }

}

输出结果：

书写:我是圆珠笔!
③抽象工厂方法模式
    这个是上面两种方式的扩展,这里我们不止可以创建一种笔，而是一组，可以说是将某个产品再细化下去。通俗的拿上面的例子来讲，铅笔需要笔杆和笔芯组装而成，我们再细化相应的实现，铁质的笔杆加上铅笔芯拼装起来最后得到铅笔。这个过程涉及到笔杆的实现类，笔芯的实现类，和铅笔工厂的实现类。

/*******************创建相关的接口*******************/

/**
 * 笔杆接口
 */
interface Penholder {
    void getMaterial();
}

/**
 * 笔芯接口
 */
interface Refill {
    void load();
}

/*******************创建相关的实现类*******************/

class plastic implements Penholder {
    @Override
    public void getMaterial() {
        System.out.println("我是塑料材质的笔杆");
    }
}

class iron implements Penholder {
    @Override
    public void getMaterial() {
        System.out.println("我是铁材质的笔杆");
    }
}

class PencilLeads implements Refill {
    @Override
    public void load() {
        System.out.println("装载铅笔芯");
    }
}

class InkCartridge implements Refill {
    @Override
    public void load() {
        System.out.println("装载油墨笔芯");
    }
}

/*******************创建工厂接口*******************/

interface Factory {

    Penholder producePenholder();

    Refill produceRefill();
}

/*******************创建工厂实现类*******************/

/**
 * 铅笔
 */
class PencilFactory implements Factory {

    @Override
    public Penholder producePenholder() {
        return new iron();
    }

    @Override
    public Refill produceRefill() {
        return new PencilLeads();
    }
}

/**
 * 圆珠笔
 */
class BallpointPenFactory implements Factory {

    @Override
    public Penholder producePenholder() {
        return new plastic();
    }

    @Override
    public Refill produceRefill() {
        return new InkCartridge();
    }
}

public class PenWithType {

    public static void main(String[] args) {
        // 这里我们创建一支铅笔
        Factory pencilFactory = new PencilFactory();
        Penholder penholder = pencilFactory.producePenholder();
        Refill refill = pencilFactory.produceRefill();
        penholder.getMaterial();
        refill.load();
    }
}

输出结果:

我是铁材质的笔杆
装载铅笔芯

原文地址：https://www.cnblogs.com/charlypage/p/11774366.html

时间： 2024-10-12 21:20:15

具体聊一聊简单工厂模式、工厂方法模式和抽象工厂模式的相关文章

工厂模式总结（简单工厂，工厂方法，抽象工厂）

工厂模式属于创建型模式,大致可以分为三类,简单工厂模式.工厂方法模式.抽象工厂模式. 通过两个例子讲解这三种工厂模式 示例一 简单工厂模式 首先介绍简单工厂模式,它的主要特点是需要在工厂类中做判断,从而创造相应的产品.当增加新的产品时,就需要修改工厂类.有点抽象,举个例子就明白了.有一家生产处理器核的厂家,它只有一个工厂,能够生产两种型号的处理器核.客户需要什么样的处理器核,一定要显示地告诉生产工厂.下面给出一种实现方案. 1 enum CTYPE {COREA, COREB}; 2 class

iOS设计模式——工厂方法（简单工厂模式，工厂方法模式， 抽象工厂模式）

1. 简单工厂模式 如何理解简单工厂,工厂方法, 抽象工厂三种设计模式? 简单工厂的生活场景,卖早点的小摊贩,他给你提供包子,馒头,地沟油烙的煎饼等,小贩是一个工厂,它生产包子,馒头,地沟油烙的煎饼.该场景对应的UML图如下所示: 图1:简单工厂模式UML图 简单工厂模式的参与者: 工厂(Factory)角色:接受客户端的请求,通过请求负责创建相应的产品对象. 抽象产品(Abstract Product)角色: 是工厂模式所创建对象的父类或是共同拥有的接口.可是抽象类或接口. 具体产品(Conc

【JS设计模式】温习简单工厂模式、工厂方法模式、抽象工厂模式概念

注:空心箭头表示的是种继承关系,工厂类和产品类之间是一种依赖关系.是用箭头加虚线表示的,以下的模型图是用的实线是不正确(时间不够用,在这里我偷懒了.这个习惯不好,呵呵) 简单工厂模式(Simple Factory Pattern): 使用一个类(通常为单体)来创建实例;简单工厂模式也叫静态工厂方法模式(Static FactoryMethod Pattern). 接口的定义通常是以I开头标识符,在JS中未定义接口或抽象类的语法: var MacBikeFactory = { createBike

iOS常用设计模式——工厂方法（简单工厂模式，工厂方法模式， 抽象工厂模式）

1. 简单工厂模式 如何理解简单工厂,工厂方法, 抽象工厂三种设计模式? 简单工厂方法包含:父类拥有共同基础接口,具体子类实现子类特殊功能,工厂类根据参数区分创建不同子类实例.该场景对应的UML图如下所示: 代码结构如下 Animal 类 @interface Animal :NSObject @proterty(nonatomic,strong) NSString *name; -(void)laugh; @end Dog类 @interface Dog:Animal @end Cat类 @i

简单工厂模式、工厂方法模式和抽象工厂模式-设计模式学习

1.简单工厂模式 简单工厂模式是属于创建型模式,又叫做静态工厂方法(StaticFactory Method)模式,但不属于23种GOF设计模式之一.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例.简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现. 工厂(Creator)角色 简单工厂模式的核心,它负责实现创建所有实例的内部逻辑.工厂类的创建产品类的方法可以被外界直接调用,创建所需的产品对象. 抽象产品(Product)角色 简单工厂模式所创建的所有

工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式

我们一般制造对象时,采用操作符new来进行创建.但是慢慢我们了解到实例化这个活动不应该总是公开地进行,同时初始化还经常造成"耦合"的问题. 如果我们不希望出现上述问题,那么我们就有必要认识一下"工厂模式",它将有助于我们从复杂的依赖中解脱出来. 1)为什么说"new"不好? 当看到"new",就会想到"具体". 我们不应该总是针对实现编程,但是当我们每次使用new时,正是在针对实现编程而不是接口,这很不符合

Java设计模式—工厂方法模式&抽象工厂模式

工厂方法模式与抽象工厂模式都是设计模式中重要而且常见的模式.       工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 通用类图如下: 在工厂方法模式中,抽象产品类Product负责定义产品的共性,实现对事物最抽象的定义:Creator为抽象创建 类,也就是抽象工厂,具体如何创建产品类是由具体的实现工厂ConcreteCreator完成的. 工厂方法模式的扩展方式有很多种,下边是工厂方法模式一个比较实用的源代码: 抽象产品类: pub

工厂方法模式And抽象工厂模式

一.工厂方法模式 简单工厂模式的缺陷就是类的创建太过于依赖工厂,一旦需要进行程序扩展,就必须修改工厂类的代码 这违背了背包原则. 而工厂方法模式针对这一问题进行了改进. public interface Sender { public void send(); } public interface producer { public Sender produce(); } public class MailFactory implements producer{ public Sender pr

设计模式：工厂方法模式（Factory Method）和抽象工厂模式(Abstact Factory)

?在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的.但是在一些情况下, new操作符直接生成对象会带来一些问题.举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象. 在这些情况,新对象的建立就是一个 "过程",不仅是一个操作,像一部大机器中的一个齿轮传动. 分类 ?工厂模式主要是为创建对象提供过渡接口,以便将创建对象的

工厂方法模式与抽象工厂模式

本文转自:http://laughingchs.iteye.com/blog/1169986 一.引子       话说十年前,有一个暴发户,他家有三辆汽车——Benz奔驰.Bmw宝马.Audi奥迪,还雇了司机为他开车.不过,暴发户坐车时总是怪怪的:上Benz车后跟司机说“开奔驰车!”,坐上Bmw后他说“开宝马车!”,坐上Audi说“开奥迪车!”.你一定说:这人有病!直接说开车不就行了?!       而当把这个暴发户的行为放到我们程序设计中来时,会发现这是一个普遍存在的现象.幸运的是,这种有病