设计模式--工厂模式（三种）

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

工厂模式有三种：简单工厂模式、工厂方法模式、抽象工厂模式，都是属于创建型设计模式。

在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。
简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。所以它不属于23设计模式之一。

属于GoF的23种设计模式的功能：

工厂方法（Factory Method）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
抽象工厂（AbstractFactory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。

简单工厂模式

简单工厂模式对对象创建管理的方式最简单。

以生产手机为例。写了一个Phone接口，ApplePhone和MiPhone类实现Phone接口，来生产特定的手机，PhoneFactory类用来判断传过来的手机名称来生产。整个手机的生产都被这个工厂类封装了，用户不用关注这些细节。

Phone类： 抽象接口，生产手机标准

package com.lu01;

public interface Phone {
    public void make();
}

ApplePhone类： 制造苹果手机

package com.lu01;

public class ApplePhone implements Phone {
    public ApplePhone(){
        this.make();
    }
    @Override
    public void make(){
        System.out.println("制造苹果手机");
    }
}

MiPhone类： 制造小米手机

package com.lu01;

public class MiPhone implements Phone  {
    public MiPhone(){
        this.make();
    }
    @Override
    public void make() {
        System.out.println("制造小米手机");
    }
}

PhoneFactory类： 手机代工厂

package com.lu01;

public class PhoneFactory {
    public static Phone makePhone(String PhoneType){

        if (PhoneType.equals("MiPhone")){
            return new MiPhone();
        }else if (PhoneType.equals("ApplePhone")){
            return new ApplePhone();
        }

        return null;
    }
}

Test类： 测试

package com.lu01;

public class Test {
    public static void main(String[] args) {

        Phone miPhone = PhoneFactory.makePhone("MiPhone");

        Phone applephone = PhoneFactory.makePhone("ApplePhone");

    }
}

工厂方法模式(Factory Method)

如果我们想要在生产另外一种手机，那就需要修改PhoneFactory源代码，在它的类中添加一个else if判断，然后在写一个实现Phone接口的类，违反了开闭原则，所以不是很合理。

通过工厂方法模式可以解决。之所以会出现上边修改PhoneFactory源代码的原因，是因为只有一个工厂：PhoneFactory类，只能在这个类中生产手机。

那如果，写一个接口：抽象工厂（AbstractFactory），想要生产哪一种手机，写一个相应的实现抽象工厂的工厂，然后在这个工厂生产手机，就可以了。也就是说，想要再生产一个品牌手机的话，只需要建立一座生产这个品牌的工厂，然后从这座工厂拿就可以了。

Phone接口、MiPhone类和ApplePhone类的定义不变。复制上的时候变一下包名。
下边是新添加的抽象工厂和实现类。

AbstractFactory 类： 生产不同品牌手机的工厂的抽象类

package com.lu02;

public interface AbstractFactory {
    public Phone makePhone();
}

AppleFactory 类： 生产苹果手机的工厂

package com.lu02;

public class AppleFactory  implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new ApplePhone();
    }
}

MiFactory类： 生产小米手机的工厂

package com.lu02;

public class MiFactory implements AbstractFactory {

    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

Test2类： 测试

package com.lu02;

public class Test2 {
    public static void main(String[] args) {
        AbstractFactory miFactory = new MiFactory();
        miFactory.makePhone();

        AbstractFactory appleFactory = new AppleFactory();
        appleFactory.makePhone();
    }
}

抽象工厂模式(Abstract Factory)

上边两种模式不管工厂怎么拆分，都只是针对一类产品 Phone，如果想生产另外一种产品PC，怎么做？
简单的办法是把工厂方法模式复制一份，不过这次生产的是PC。很明显，这么做很麻烦，而且不利于扩展和维护。

抽象工厂模式是通过在AbstractFactory中增加生产产品的接口，并在子工厂中实现它。也可以只实现、什么都不做。

Phone接口、MiPhone类和ApplePhone类的定义不变。复制上的时候变一下包名。
变的是：在AbstractFactory中添加生产PC接口，修改实现类。添加PC接口和实现类

PC类： 生产PC产品的接口

package com.lu03;

public interface PC {
    public void make();
}

MacPC 类： 制造苹果电脑

package com.lu03;

public class MacPC implements PC{
    public MacPC(){
        this.make();
    }
    @Override
    public void make() {
        System.out.println("制造苹果电脑");
    }
}

MiPC 类： 制造小米电脑

package com.lu03;

public class MiPC implements PC {

    public MiPC(){
        this.make();
    }

    @Override
    public void make() {
        System.out.println("制造小米电脑");
    }
}

下边是修改工厂和相关的类：

AbstractFactory 类： 增加制造PC的接口

package com.lu03;

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

AppleFactory 类： 增加苹果电脑制造的实现

package com.lu03;

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new ApplePhone();
    }

    @Override
    public PC makePC() {
        return new MacPC();
    }
}

MiFactory 类： 增加增加小米电脑制造的实现

package com.lu03;

public class MiFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }

    @Override
    public PC makePC() {
        return new MiPC();
    }
}

Test3类： 测试

package com.lu03;

public class Test3 {
    public static void main(String[] args) {
        AbstractFactory miFactory = new MiFactory();
        miFactory.makePhone();
        miFactory.makePC();

        AbstractFactory appleFactory = new AppleFactory();
        appleFactory.makePhone();
        appleFactory.makePC();
    }
}

总结

简单工厂模式： 工厂类是关键，里面有逻辑判断，可以根据用户给的信息来创建对应的对象。适合创建对象比较少的情况，用户只需传具体的参数，忽略生产的细节。
工厂方法模式： 是简单工厂模式的抽象，抽象了一个Factory类(接口)，这个接口定义规范，具体生产是由实现它的子类来完成，实现了可扩展。适合单一产品生产的情况。
抽象工厂模式： 在抽象的Factory类中，创建产品族的接口，可以生产一系列的产品。适合有多种产品生产的情况。

完整版代码，idea编译器
链接：https://pan.baidu.com/s/1h4NOZIjwhxwM8aaMQQhWow
提取码：v4qa