码迷,mamicode.com
首页 > 其他好文 > 详细

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

时间:2019-09-24 13:45:46      阅读:92      评论:0      收藏:0      [点我收藏+]

标签:factor   逻辑判断   包含   过程   代码   模式   interface   增加   java   

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

简单工厂模式 (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

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

标签:factor   逻辑判断   包含   过程   代码   模式   interface   增加   java   

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

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!