设计模式内容分享(一)：工厂模式

工厂方法模式(Factory Method Pattern)，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式，它属于类创建型模式。
在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。
工厂模式的核心思想就是把创建对象和使用对象解藕，由工厂负责对象的创建，而用户只能通过接口来使用对象，这样就可以灵活应对变化的业务需求，方便代码管理、避免代码重复。

二、工厂方法模式的适用场景

客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
客户不关心创建产品的细节，只关心产品的品牌。

三、工厂方法模式结构

抽象产品角色（Product）：定义产品的接口
具体产品角色（ConcreteProduct）?：实现接口产品的具体产品类
抽象工厂角色（Creator）?：声明工厂方法（FactoryMethod），返回一个产品
真实的工厂（ConcreteCreator）：实现FactoryMethod工厂方法，由客户调用，返回一个产品的实例

工厂方法模式包含四种类，分别是抽象产品类、具体产品类、抽象工厂类、具体工厂类，下面分别对各类以及它们之间的关系作进一步说明。

角色	关系	作用
抽象产品 Product?	具体产品的父类	描述产品的公共接口
具体产品 ConcreteProduct	抽象产品的子类；工厂创建的目标类	描述生产的具体产品
抽象工厂 Factory	具体工厂的父类	描述具体工厂的公共接口
具体工厂 ConcreteFactory	抽象工厂的子类，外界调用	描述具体工厂；实现Factory接口，创建具体产品实例

根据上述概念，下面将抽象工厂模式的使用步骤概括如下：

step1：创建抽象工厂类，定义具体工厂的公共接口；
step2：创建抽象产品类，定义具体产品的公共接口；
step3：创建具体产品类（继承抽象产品类），定义生产的具体产品；
step4：创建具体工厂类（继承抽象工厂类），定义创建相应具体产品实例的方法；
step5：外界调用具体工厂类的方法，创建不同具体产品类的实例。

还是以淘宝店铺下的宝贝分类展示功能举例，假如该服装店除男款衬衫和女款衬衫外，还要新增一个衬衫类型如中性衬衫，按照简单工厂模式我们依然可以继承 Shirt 抽象父类，override 衬衫类型，然后在 Fcatory 中添加新分支，然而这样虽然扩展了衬衫类型，却对 Fcatory 类进行了修改，不符合“开放扩展、关闭修改”的开闭原则。为了应对这种需求变化，我们可以使用工厂方法模式，提取出一个工厂父类接口 Fcatory，并创建各衬衫类型的工厂子类WomenShirtFactory、MenShirtFactory、NeutralShirtFactory，并分别使用对应的工厂子类来判断要创建哪一衬衫类型的对象。

四、工厂方法模式实现方式

创建同一接口，抽象产品角色。声明对所有产品都有意义的行为方法。
为每种产品创建产品的具体产品角色，实现抽象产品角色接口。
定义抽象工厂角色，接口中定义一个工厂方法。该方法的返回类型必须遵循通用的产品接口。
为每种产品定义一个真实的工厂，并实现抽象工厂角色中的工厂方法，将具体产品角色中的相关对象的创建移动到工厂方法中。

如果应用中的产品类型太多，那么为每个产品创建子类并无太大必要，这时也可以在子类中复用基类中的控制参数。

五、工厂方法模式的实现

工厂方法模式的实现其实是在简单工厂代码的基础上加以改造

抽象工厂角色实现

/**
 * 抽象工厂
 */
publicinterface IFactory {
	//定义一个方法用于创建汽车工厂
    ICar CreateCar();
}

抽象产品角色实现

/**
 * 抽象产品类代码
 */
publicinterface ICar {
    void GetCar();
}

具体工厂角色实现

/**
 * 具体工厂类：用于创建两厢车类
 */
publicclass HatchbackFactory implements IFactory{
    @Override
    public ICar CreateCar() {
        returnnew HatchbackCar();
    }
}
/**
 * 具体工厂类：用于创建越野车类
 */
publicclass JeepFactory implements IFactory{
    @Override
    public ICar CreateCar() {
        returnnew JeepCar();
    }
}

/**
 * 具体工厂类：用于创建跑车类
 */
publicclass SportFactory implements IFactory{
    @Override
    public ICar CreateCar() {
        returnnew SportCar();
    }
}

具体产品角色实现?? 与简单工厂代码一致

/**
 * 具体汽车 : 越野车
 */
publicclass JeepCar implements ICar  {

    @Override
    public void GetCar() {
        System.out.println("这是越野车");
    }
}

/**
 * 具体汽车 : 跑车
 */
publicclass SportCar implements ICar  {

    @Override
    public void GetCar() {
        System.out.println("这是跑车");
    }
}

/**
 * 具体汽车 : 两箱车
 */
publicclass HatchbackCar implements ICar  {

    @Override
    public void GetCar() {
        System.out.println("这是两箱车");
    }
}

客户端代码实现

public static void main(String[] args) {
    IFactory factory = new JeepFactory();
    ICar car = factory.CreateCar();
    car.GetCar();
}

六、工厂方法模式的优缺点

优点
- 工厂和具体产品之间的解耦
- 遵循单一职责原则，将产品创建代码放在程序的单一位置，易维护。
- 符合单一职责原则。每个具体工厂类只负责创建对应的具体产品，而简单工厂中的工厂类存在复杂的switch逻辑判断。
- 遵循开闭原则，无需更改现有客户端代码，就可以在程序中引入新的产品类型。
- 符合开闭原则。新增一种产品时，只需要增加相应的具体产品类和工厂子类即可，可方便的生产或切换产品，而无须像简单工厂模式那样修改工厂类的判断逻辑，具有更高的扩展性?。
- 相比于简单工厂模式，使用的不是静态方法，可形成基于继承的等级结构。
缺点
- 在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度。
- 一个具体工厂只能创建一种具体产品。添加新产品时，除增加新产品类外，还要提供与之对应的具体工厂类，类的个数成对增加，在一定程度上增加了系统复杂度；同时有更多的类需要编译和运行，给系统带来额外开销。
- 由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。
- 虽然保证了工厂方法内的对修改关闭，但对于使用工厂方法的类，如果要更换另外一种产品，仍然需要修改实例化的具体工厂类。
- 难以对父类接口进行修改，因为一旦修改接口，就必须要对众多的帮忙子类进行修改。

七、适用场景

一个类不确定它所必须创建的对象的类。在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可。
你期望获得较高的扩展性。
一个类希望由它的子类来指定它所创建的对象。在工厂方法模式中，对于抽象工厂类只需提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏替换原则，在程序运行时，子类对象将覆盖父类对象，从而使系统更容易扩展。
当类将创建对象的职责委托给多个工厂子类的中的某一个，且用户知道将要使用哪一个工厂子类。

?

简单工厂模式

顾名思义，简单工厂模式是最简单的一种工厂模式，它定义了一个负责生产对象的工厂类，使用者可以根据不同参数来创建并返回不同子类，这些子类都共用一个接口（即父类）。

一、结构

简单工厂模式包含三种类，分别是抽象产品类、具体产品类、工厂类，下面分别对各类及它们之间的关系作进一步说明。

角色	关系	作用
抽象产品 Product?	具体产品的父类	描述产品的公共接口
具体产品 ConcreteProduct	抽象产品的子类；工厂创建的目标类	描述生产的具体产品
工厂 Factory	外界调用	根据传入的不同参数来创建不同具体产品类的实例

二、使用

有了上述的基本概念，我们将简单工厂模式的使用步骤概括为：

step1：创建抽象产品类，并为具体产品定义好一个接口；
step2：创建具体产品类，其通过接口来继承抽象产品类，同时也要定义计划生产的每一个具体产品；
step3：创建工厂类，其创建的静态方法可以对传入的不同参数做出响应；
step4：外界使用者就能调用工厂类的静态方法了，通过传入不同参数来创建不同具体产品类的实例。

下面以淘宝服装店铺的商品展示销售进行阐释，比如一个衬衫专卖店需要在淘宝平台上展示旗下商品，我们可以把所有衬衫都分别单独定义一个类，这样就可以随意添加或修改某一个新的衬衫类型，并使用 Fcatory 类来判断要创建哪一个衬衫类型的对象，即：先声明一个父类对象的变量，再根据用户输入的参数判断新建什么具体的衬衫类型对象。

三、代码实现

//step1:创建抽象产品类，定义具体产品的公共接口
public abstract class Shirt{
    public abstract void Show();
}

//step2:创建具体产品类（继承抽象产品类），定义生产的具体产品
//具体产品类A，女款衬衫
public class WomenShirt extends Shirt{
    @Override
    public void Show(){
        System.out.println("展示女款衬衫");
    }
}
//具体产品类B，男款
public class MenShirt extends Shirt{
    @Overside
    public void Show(){
        System.out.println("展示男款衬衫")；
        }
}

//step3:创建工厂类，通过静态方法处理不同传入参数，从而创建不同具体产品类的实例
public class Factory{
    public static Shirt Exhibit(String ShirtName){
        switch(ShirtName){
            case "女款衬衫":
                return new WomenShirt();
            case "男款衬衫":
                return new MenShirt();
            default:
                return null;
        }
    }
}

//step4:外界调用工厂类的静态方法，传入不同参数创建不同具体产品类的实例
public class SimpleFactoryPattern{
    public static void main(String[] args){
        Factory exhibitFactory = new Factory();
        //用户搜索女款衬衫
        try{
            //调用工厂类的静态方法，传入参数并创建实例
            exhibitFactory.Exhibit("女款衬衫").Show();
        }catch(NullPointerException e){
            System.out.println("没有找到商品");
        }
        //用户搜索男款裤子
        try{
            exhibitFactory.Exhibit("男款裤子").Show();
        }catch(NullPointerException e){
            System.out.println("没有找到商品");
        }
        //用户搜索男款衬衫
        try{
            exhibitFactory.Exhibit("男款衬衫").Show();
        }catch(NullPointerException e){
            System.out.println("没有找到商品");
        }
    }
}

结果输出

展示女款衬衫没有找到商品展示男款衬衫

UML图

四、优点

将对象的使用和创建过程分离开，实现解藕。客户端不需要关注对象是谁创建的、怎么创建的，只要通过工厂中的静态方法就可以直接获取其需要的对象。
将初始化实例的工作放到工厂里执行，代码易维护，更符合面向对象的原则，做到面向接口编程，而不是面向实现编程。

五、缺点

工厂类中需要选择创建具体某个对象，所以一旦添加新产品则必须要对工厂中的选择逻辑进行修改，导致工厂逻辑过于复杂，违背开闭原则。
工厂类集合了所有实例（具体产品）的创建逻辑，一旦这个工厂不能正常工作，整个系统都会受到影响。
静态方法不能被继承和重写，会造成工厂角色无法形成基于继承的等级结构。

六、适用场景

具体产品类较少时，使用简单工厂模式可以实现生产者与消费者的分离，而且也不会在工厂类中设定太复杂的判断逻辑。
使用者只知道传入工厂类的参数，不关心如何创建对象的逻辑时。

抽象工厂模式

抽象工厂模式，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。抽象工厂模式与工厂方法模式最大的区别：抽象工厂中每个具体工厂可以创建多类具体产品；而工厂方法每个具体工厂只能创建一类具体产品。

一、结构

工厂方法模式包含五种类，分别是抽象产品族类、抽象产品类、具体产品类、抽象工厂类、具体工厂类，下面分别对各类以及它们之间的关系作进一步说明：

角色	关系	作用
抽象产品族 AbstractProduct	抽象产品的父类	描述抽象产品的公告接口
抽象产品 Product?	具体产品的父类	描述具体产品的公共接口
具体产品 ConcreteProduct	抽象产品的子类；工厂创建的目标类	描述生产的具体产品
抽象工厂 Factory	具体工厂的父类	描述具体工厂的公共接口
具体工厂 ConcreteFactory	抽象工厂的子类，外界调用	描述具体工厂；实现Factory接口，创建具体产品实例

二、使用

根据上述概念，下面将工厂方法模式的使用步骤概括如下：

step1：创建抽象工厂类，定义具体工厂的公共接口；
step2：创建抽象产品族类，定义抽象产品的公共接口；
step3：创建抽象产品类（继承抽象产品族类），定义具体产品的公共接口；
step4：创建具体产品类（继承抽象产品类），定义生产的具体产品；
step5：创建具体工厂类（继承抽象工厂类），定义创建相应具体产品实例的方法；
step6：外界调用具体工厂类的方法，创建不同具体产品类的实例。

这里继续以网店销售服装举例，假设上述衬衫淘宝专卖店的运营总部还有一家裤子淘特专卖店，随着用户需求变化，淘宝用户也要购买裤子，同时淘特用户要购买衬衫，那么我们可以使用抽象工厂模式升级这两个店铺，令淘宝店铺展示销售衬衫+裤子，淘特店铺展示销售裤子+衬衫。

三、代码实现

//step1:创建抽象工厂类，定义具体工厂的公共接口
public abstract class Factory{
    public abstract Clothing ExhibitShirt();
    public abstract Clothing ExhibitTrousers();
}

//step2:创建抽象产品族类，定义抽象产品的公共接口
public abstract class Clothing{
    public abstract void Show();
}

//step3:创建抽象产品类，定义具体产品的公共接口
//女装抽象类
public abstract class Shirt extends Clothing{
    @Override
    public abstract void Show();
}
//男装抽象类
public abstract class Trousers extends Clothing{
    @Override
    public abstract void Show();
}

//step4:创建具体产品类（继承抽象产品类），定义生产的具体产品
//衬衫产品类A，淘宝衬衫
public class TBShirt extends Shirt{
    @Override
    public void Show(){
        System.out.println("展示淘宝店铺衬衫");
    
}
//衬衫产品类B，淘特衬衫
public class TTShirt extends Shirt{
    @Overside
    public void Show(){
        System.out.println("展示淘特店铺衬衫")；
    }
}
//裤子产品类A，淘宝裤子
public class TBTrousers extends Trousers{
    @Override
    public void Show(){
        System.out.println("展示淘宝店铺裤子");
    }
}
//裤子产品类B，淘特裤子
public class TTTrousers extends Trousers{
    @Overside
    public void Show(){
        System.out.println("展示陶特店铺裤子")；
    }
}

//step5:创建具体工厂类，定义创建具体产品实例的方法
//淘宝工厂类A，展示衬衫+裤子  
public class TBFactory extends Factory{
    @Overside
    public Clothing ExhibitShirt(){
        return new TBShirt()；
    }
    @Overside
    public Clothing ExhibitTrousers(){
        return new TBTrousers()；
    }
}
//淘特工厂类B，展示裤子+衬衫
public class TTFactory extends Factory{
    @Overside
    public Clothing ExhibitShirt(){
        return new TTShirt()；
    }
    @Overside
    public Clothing ExhibitTrousers(){
        return new TTTrousers()；
    }
}

//step6:外界实例化具体工厂类，调用工厂类中创建不同目标产品的方法，创建不同具体产品类的实例
public class AbstractFactoryPattern{
    public static void main(String[] args){
        TBFactory exhibitTBFactory = new TBFactory();
        TTFactory exhibitTTFactory = new TTFactory();
        //淘宝用户搜索衬衫
        exhibitTBFactory.ExhibitShirt().Show();
        //淘宝用户搜索衬衫
        exhibitTBFactory.ExhibitTrousers().Show();
        //淘特用户搜索衬衫
        exhibitTTFactory.ExhibitShirt().Show();
        //淘特用户搜索衬衫
        exhibitTTFactory.ExhibitTrousers().Show();     
    }
}

结果输出

展示淘宝店铺衬衫展示淘宝店铺裤子展示淘特店铺衬衫展示淘特店铺裤子

UML图

四、优点

降低耦合度。抽象工厂模式将具体产品的创建延迟到具体工厂类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而降低系统耦合度，有利于后期的维护和扩展。
符合开闭原则。新增一种产品类时，只需增加相应的具体产品类和工厂子类即可，简单工厂模式需要修改工厂类的判断逻辑。
符合单一职责原则。每个具体工厂类只负责创建对应的产品，简单工厂模式中的工厂类需要进行复杂的 switch 逻辑判断。
不使用静态工厂方法，可以形成基于继承的等级结构。
便于添加更换产品族。因为具体产品都是由具体工厂创建的，所以在更换产品族的时候只要简单修改具体工厂即可。
具体产品的创建过程和客户端隔离。客户端通过操作抽象产品接口实现操作具体产品实例，具体产品的类名不会出现在客户端中。

五、缺点

难以支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可被创建的产品集合，如果需要添加新产品，此时就必须去添加抽象产品接口，还要在抽象工厂接口中添加新方法，并在所有具体工厂中实现该新方法。这样就会改变抽象工厂类以及所有具体工厂子类的改变，违背开闭原则。
类图有点复杂，可读性没有工厂方法模式高。

六、适用场景

系统不要求依赖产品类实例如何被创建、组合和表达，这点也是所有工厂模式应用的前提。
系统要求提供一个产品类的库，所有产品以同样的接口出现，客户端不需要依赖具体实现。
系统中有多个产品族，但每次只使用其中某一族产品。（切换产品族只需修改具体工厂对象即可）

总结

简单工厂模式：让一个工厂类负责创建所有对象；但没有考虑后期扩展和维护，修改违背开闭原则，静态方法不能被继承。

工厂类负责创建的对象比较少，不会造成工厂方法中的业务逻辑太过复杂。
客户端只知道传入工厂类的参数，对于如何创建对象并不关心。

工厂方法模式：主要思想是继承，修改符合开闭原则；但每个工厂只能创建一种类型的产品。

客户端不知道它所需要的对象的类。
抽象工厂类通过其子类来指定创建哪个对象。

抽象工厂模式：主要思想是组合，本质是产品族，实际包含了很多工厂方法，修改符合开闭原则；但只适用于增加同类工厂这种横向扩展需求，不适合新增功能方法这种纵向扩展。

其实这三种工厂模式在形式和特点上都非常相似，甚至存在一定的内在联系，而且最终目的都是解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为它们之间也是可以灵活转变的。比如你原本使用的是工厂方法模式，加入一个新方法后就可能会让具体产品类构成不同等级结构中的产品族，代码结构就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个或多个具体产品类时，使原有产品族只剩下一个产品后，代码结构也就转变成了工厂方法模式。

工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。

文章来源:https://blog.csdn.net/qq_45038038/article/details/135197099
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！