简单工厂模式、工厂方法模式与抽象工厂模式的区别(转)

虽然看完了《大话设计模式》,但是工厂模式的三种类型之间的差异,理解还不是非常透彻,那么本文就围绕三者间的差异性来阐述各自的优缺点。

简单工厂模式 (Simple Factory)

首先定义一个产品类的共同接口

public interface Product{

//价格
int price();

//产品名
String getName();

}

分别有三个产品ProductA、ProductB、ProductC ,均实现Product接口

ProductA

public class ProductA implements Product {
    @Override
    public int price() {
        return 100;
    }

    @Override
    public String getName() {
        return "ProductA";
    }
}

ProductB

public class ProductB implements Product {
    @Override
    public int price() {
        return 200;
    }

    @Override
    public String getName() {
        return "ProductB";
    }
}

ProductC

public class ProductC implements Product {
    @Override
    public int price() {
        return 300;
    }

    @Override
    public String getName() {
        return "ProductC";
    }
}

定义一个生产工厂类,根据输入类型生产对应的产品

public class Factory {

    /**
     * 根据生产类型生产对应的产品
     * @param type
     * @return
     */
    public static Product createProduct(String type){

        Product product =null;

        switch (type){

            case "A":

                product = new ProductA();
                break;
            case "B":
                product = new ProductB();

                break;
            case "C":
                product = new ProductC();

                break;

        }
        return product;

    }

}

根据输入的生产类型生产对应的产品

Product productA = Factory.createProduct("A");
System.out.println("productA name="+productA.getName()+",getPrice:"+productA.getPrice());

Product productB = Factory.createProduct("B");
System.out.println("productB name="+productB.getName()+",getPrice:"+productB.getPrice());

Product productC = Factory.createProduct("C");
System.out.println("productC name="+productC.getName()+",getPrice:"+productC.getPrice());

输出结果:

productA name=ProductA,getPrice:100
productB name=ProductB,getPrice:200
productC name=ProductC,getPrice:300

以上便是简单工厂模式的一个典型事例,当用户需要新增产品ProductD时,必须在工厂类的生产方法中增加对应的判断分支,所以简单工厂模式违背了开放封闭原则。

简单工厂模式,利用静态方法根据输入参数生成对应的产品,隐藏了产品实例化的细节。

总结: 简单工厂模式最大的优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖。但是当需求变动的时候,需要对原有的类进行修改,违背了开放封闭原则。

工厂方法模式 (Factory Method)

通过工厂方法模式,可以解决简单工厂模式的问题。

首先声明一个工厂接口,所有工厂必须实现这个接口

public interface IFactory {

    Product createProduct();
}

生产ProductA的工厂FactoryA

public class FactoryA implements IFactory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

生产ProductB的工厂FactoryB

public class FactoryB implements IFactory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

同样地,生产ProductC的工厂FactoryC跟以上模式一样。

现在来根据新的工厂方法模式来生产

IFactory factoryA = new FactoryA();

Product productA = factoryA.createProduct();
System.out.println("productA name="+productA.getName()+",getPrice:"+productA.getPrice());

IFactory factoryB = new FactoryB();

Product productB = factoryB.createProduct();
System.out.println("productB name="+productB.getName()+",getPrice:"+productB.getPrice());

IFactory factoryC = new FactoryB();

Product productC = factoryC.createProduct();

System.out.println("productC name="+productC.getName()+",getPrice:"+productC.getPrice());

输出结果:

productA name=ProductA,getPrice:100
productB name=ProductB,getPrice:200
productC name=ProductC,getPrice:300

当需要增加一个新产品ProductD,只需要新建对应的FactoryD来实现生产功能即可,对原有的代码没有任何影响,非常符合开放封闭原则,但是由于每增加一个产品,都需要新增对应的生产工厂,导致增加额外的开发工作量。

总结:由于使用了多态,工厂方法克服了简单工厂违背的开放封闭原则的缺点,又保持了封装对象创建过程的优点。

抽象工厂模式 (Abstract Factory)

假设现在需要针对每种产品生产对应的赠品,难道我们要新增一个Gift的生产工厂吗?其实没有必要,因为在这个场景下,每种产品必须附带了赠品,所以我们可以利用原有的工厂来生产赠品。

先定一个共同的Gift接口

public interface Gift {

    String getGiftName();

}

增加GiftA、GiftB、GiftC

public class GiftA implements Gift {
    @Override
    public String getGiftName() {
        return "GiftA";
    }
}

修改Factory接口,增加生产Gift的方法

public interface IFactory {

    Product createProduct();
    Gift createGift();
}

修改工厂方法模式下的FactoryA、FactoryB、FactoryC

public class FactoryA implements IFactory {
    @Override
    public Gift createGift() {
        return new GiftA();
    }

    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

生产产品和赠品

IFactory factoryA = new FactoryA();
Product productA = factoryA.createProduct();
Gift giftA = factoryA.createGift();

总结:抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,而无需制定他们具体的类。抽象工厂接口,应该包含所有的产品创建的抽象方法,我们可以定义实现不止一个接口,一个工厂也可以生产不止一种产品类,和工厂方法模式一样,抽象工厂模式同样实现了开发封闭原则
原文链接:https://www.jianshu.com/p/d27d698802fd

原文地址:https://www.cnblogs.com/heliusKing/p/11577837.html

时间: 2024-11-05 22:36:41

简单工厂模式、工厂方法模式与抽象工厂模式的区别(转)的相关文章

工厂模式总结(简单工厂,工厂方法,抽象工厂)

工厂模式属于创建型模式,大致可以分为三类,简单工厂模式.工厂方法模式.抽象工厂模式. 通过两个例子讲解这三种工厂模式 示例一 简单工厂模式 首先介绍简单工厂模式,它的主要特点是需要在工厂类中做判断,从而创造相应的产品.当增加新的产品时,就需要修改工厂类.有点抽象,举个例子就明白了.有一家生产处理器核的厂家,它只有一个工厂,能够生产两种型号的处理器核.客户需要什么样的处理器核,一定要显示地告诉生产工厂.下面给出一种实现方案. 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说“开奥迪车!”.你一定说:这人有病!直接说开车不就行了?!       而当把这个暴发户的行为放到我们程序设计中来时,会发现这是一个普遍存在的现象.幸运的是,这种有病