工厂设计模式、简单工厂设计模式、抽象工厂设计模式

最新推荐文章于 2022-04-03 21:46:26 发布

丘山一郎

最新推荐文章于 2022-04-03 21:46:26 发布

阅读量203

点赞数

分类专栏： JAVA设计模式

本文链接：https://blog.csdn.net/qq_43170213/article/details/119153434

版权

JAVA设计模式专栏收录该内容

14 篇文章 3 订阅

订阅专栏

一、简单工厂设计模式、工厂设计模式，抽象工厂设计模式总体分析

简单工厂模式
简单工厂模式不是23种里的一种，简而言之，就是有一个专门生产某个产品的类。
比如下图中的鼠标工厂，专业生产鼠标，给参数0，生产戴尔鼠标，给参数1，生产惠普鼠标。
工厂设计模式
工厂模式也就是鼠标工厂是个父类，有生产鼠标这个接口。
戴尔鼠标工厂，惠普鼠标工厂继承它，可以分别生产戴尔鼠标，惠普鼠标。
生产哪种鼠标不再由参数决定，而是创建鼠标工厂时，由戴尔鼠标工厂创建。
后续直接调用鼠标工厂.生产鼠标()即可
抽象工厂设计模式

抽象工厂模式也就是不仅生产鼠标，同时生产键盘。也就是PC厂商是个父类，有生产鼠标，生产键盘两个接口。戴尔工厂，惠普工厂继承它，可以分别生产戴尔鼠标+戴尔键盘，和惠普鼠标+惠普键盘。创建工厂时，由戴尔工厂创建。后续工厂.生产鼠标()则生产戴尔鼠标，工厂.生产键盘()则生产戴尔键盘。

在这里插入图片描述

在抽象工厂模式中，假设我们需要增加一个工厂
假设我们增加耳麦这个产品，则首先我们需要增加耳麦这个父类，再加上戴尔耳麦，惠普耳麦这两个子类。
之后在PC厂商这个父类中，增加生产耳麦的接口。最后在戴尔工厂，惠普工厂这两个类中，分别实现生产戴尔耳麦，惠普耳麦的功能。
以上。

参考知乎地址：https://www.zhihu.com/question/20367734

二、简单工厂设计模式

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


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时，必须在工厂类的生产方法中增加对应的判断分支，所以简单工厂模式违背了开放封闭原则。

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

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

工厂设计模式，简单工厂设计模式、抽象工厂设计模式链接：https://www.jianshu.com/p/d27d698802fd

三、工厂设计模式

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

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


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 Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

假设现在需要针对每种产品生产对应的赠品，难道我们要新增一个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

五、简单工厂模式、工厂模式与抽象工厂设计模式的区别

简单工厂模式和工厂方法模式的区别

1、简单工厂模式中包含判断什么对象的逻辑，而工厂方法模式则需要调用者判断要实例化什么具体类型的工厂进而创建出想要的对象。当增加新类时，简单工厂模式需要修改工厂类，而工厂方法模式不需要，因此工厂方法模式遵守了开闭原则，而简单工厂模式没遵守。

2、简单工厂模式因为采用了静态方法，所以不利于继承，而工厂方法模式恰恰相反，需要利用到继承来从抽象工厂中派生出各种各样的具体工厂。

3、抽象工厂模式的优点和缺点

抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。

产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

简单工厂模式和工厂方法模式的区别：https://www.cnblogs.com/winsons/p/12490359.html

丘山一郎

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录