三种工厂模式详述

工厂模式概述

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

何时使用：

• 工厂模式将创建和使用分离，使用者不需要知道具体的创建过程，只需要使用即可
• 降低代码重复。如果对象的创建过程比较复杂，并且很多地方都用到了，那么很可能出现很多重复的代码，通过统一将创建对象的代码放到工厂里面统一管理，可以减少代码的重复率，同时也方便维护。相比于构造函数来说，复杂的初始化，会使得构造函数非常的复杂。
• 工厂模式的目的是为了实现解耦，将对象的创建和使用分开，即应用程序将对象的创建和初始化职责交给工厂对象。若一个对象想要调用对象X时，如果直接通过new关键字来创建一个X实例，然后调用X实例，这样做的不好处是，当需求变更，要将X实例换成Z实例时，则需要修改所有new了该实例的方法

工厂模式主要解决的问题是：将对象的创建过程与对象的使用分离出来,将对象的创建交给一个工厂,最终对于要使用的对象,不需要自己去new，一且都交给工厂,对于工厂模式有三种类型,简单工厂模式,工厂方法模式,抽象工厂模式,接下来我们就详细介绍每一种工厂。

简单工厂模式

• 在简单工厂模式中，只提供了一个工厂类，该工厂类处于对产品类进行实例化的中心位置，它知道每一个产品对象的创建细节，并决定何时实例化哪一个产品类。简单来说就是一个工厂,用于创建所有类的实例,这样简单工厂最大的不足就是当有新的实例要加入到当前的系统时,必须修改工厂类,同时加入必要的业务逻辑,这一点违背了 "开闭原则（软件对象（类、模块、方法等）应该对于扩展是开放的，对修改是关闭的。"
  在简单工厂模式中,所有的实例都是由工厂创建,工厂类职责重大,业务逻辑复杂,同时代码不易维护,产品和工厂类之间的耦合度高,严重影响了程序的灵活性和扩展性.

  我们使用收集支付讲解该模式：
  PaymentService类：手机支付标准规范类(AbstractProduct)

public interface PaymentService {
    /*
       支付方法
     */
    public void pay();
}

WeChat类 ：微信支付

public class WeChat implements PaymentService {
    public WeChat(){
        this.pay();
    }
    @Override
    public void pay() {
        System.out.println("微信支付...");
    }
}

ZFB类 ：支付宝支付

public class ZFB implements PaymentService {
    public ZFB(){
        this.pay();
    }

    @Override
    public void pay() {
        System.out.println("支付宝支付...");
    }
}

PaymentFactory 类 : 支付工厂

public class PaymentFactory {
    public static PaymentService getPaymentService(String payType){
        PaymentService paymentService = null;
        switch(payType){
            case "ZFB":
                paymentService = new ZFB();
                break;
            case "WeChat":
                paymentService = new WeChat();
                break;
        }
        return  paymentService;
    }
}

测试类:

public class Test {
    public static void main(String[] args) {
        PaymentService paymentService =  PaymentFactory.getPaymentService("ZFB");
        paymentService.pay();
        PaymentService paymentService2 =  PaymentFactory.getPaymentService("WeChat");
        paymentService2.pay();
    }
}
/*
支付宝支付...
支付宝支付...
微信支付...
微信支付...
*/

工厂方法模式

工厂方法模式(Factory Method Pattern)又称为工厂模式。在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

• 工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责哪一个产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
• 当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体产品对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好地符合了“开闭原则”。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。

我们还是用支付的例子来说明这个模式:
抽象工厂类代码:

public interface PhoneFactory {
   public Phone productPhone();
}

具体的工厂1代码:

public class XiaoMiFactory implements PhoneFactory {
    @Override
    public Phone productPhone() {
        System.out.println("小米工厂出产小米手机");
        return new XiaoMiPhone();
    }
}

具体的工厂2代码:

public class HuaWeiFectory implements PhoneFactory {
    @Override
    public Phone productPhone() {
        System.out.println("华为工厂出产华为手机");
        return new HuaWeiPhone();
    }
}

具体产品接口:

public interface Phone {
    public void Phones();
}

产品接口实现类1:

public class HuaWeiPhone implements Phone {
    @Override
    public void Phones() {
        System.out.println("生产华为手机...");
    }
}

产品接口实现类2:

public class HuaWeiFectory implements PhoneFactory {
    @Override
    public Phone productPhone() {
        System.out.println("华为工厂出产华为手机");
        return new HuaWeiPhone();
    }
}

测试类:

public class Test {
    public static void main(String[] args) {
        PhoneFactory XiaoMiFactory = new XiaoMiFactory();
        PhoneFactory HuaWeiFactory =  new HuaWeiFectory();
        XiaoMiFactory.productPhone();
        HuaWeiFactory.productPhone();
    }
}
/*
 小米工厂出产小米手机
 华为工厂出产华为手机
 */

抽象工厂模式

上面两种模式不管工厂怎么拆分抽象，都只是针对一类产品 Pay/Phone（AbstractProduct），如果要生成另一种产品PC，应该怎么表示呢？

最简单的方式是把2中介绍的工厂方法模式完全复制一份，不过这次生产的是PC。但同时也就意味着我们要完全复制和修改Phone生产管理的所有代码，显然这是一个笨办法，并不利于扩展和维护。

抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建

我们通过例子来说明该模式:
定义PC产品的接口(AbstractPC)

public interface PC {
    void make();
}

MiPC类：定义小米电脑产品(MIPC)

public class MiPC implements PC {
    public MiPC() {
        this.make();
    }
    @Override
    public void make() {
        System.out.println(" 生产小米 PC!");
    }
}

HuaWeiPC类：定义华为电脑产品(HuaWeiPC)

public class HuaWeiPC implements PC {
    public HuaWeiPC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("生产华为 PC!");
    }
}

AbstractFactory类：增加PC产品制造接口

public interface AbstractFactory {
        Phone productPhone();
        PC makePC();
    }

XiaoMiFactory类：增加小米PC的制造（XiaoMiFactory）

public class XiaoMiFactory implements AbstractFactory {
    @Override
    public Phone productPhone() {
        System.out.println("小米工厂出产小米手机");
        return new XiaoMiPhone();
    }

    @Override
    public PC makePC() {
        System.out.println("小米工厂出产小米PC");
        return new MiPC();
    }
}

HueWeiFactory类：增加华为PC的制造（HuaWeiFectory）

public class HuaWeiFectory implements AbstractFactory {
    @Override
    public Phone productPhone() {
        System.out.println("华为工厂出产华为手机");
        return new HuaWeiPhone();
    }

    @Override
    public PC makePC() {
        System.out.println("华为工厂出产华为PC");
        return new HuaWeiPC ();
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        PhoneFactory XiaoMiFactory = new XiaoMiFactory();
        PhoneFactory HuaWeiFactory =  new HuaWeiFectory();
        XiaoMiFactory.productPhone();
        XiaoMiFactory.makePC();
        HuaWeiFactory.productPhone();
        HuaWeiFactory.makePC();
    }
}
/*
小米工厂出产小米手机
小米工厂出产小米PC
 生产小米 PC!
华为工厂出产华为手机
生产华为 PC!
*/