Java设计模式之工厂模式

工厂设计模式介绍

工厂模式属于创建型设计模式，可以分为三类，分别是：简单工厂模式（Simple Factory）、工厂方法模式（Factory Method）、抽象工厂模式（Abstract Factory）。
其中简单工厂其实不是一个标准的的设计模式。GOF 23 种设计模式中只有「工厂方法模式」与「抽象工厂模式」。简单工厂模式可以看为工厂方法模式的一种特例，为了统一整理学习，就都归为工厂模式。
三种设计模式根据抽象的程度来排列顺序：简单工厂模式<工厂方法模式<抽象工厂模式

什么是创建型设计模式

创建型模式是处理对象创建的设计模式，试图根据实际情况使用合适的方式创建对象。基本的对象创建方式可能会导致设计上的问题，或增加设计的复杂度。创建型模式通过以某种方式控制对象的创建来解决问题。
创建型模式由两个主导思想构成。一是将系统使用的具体类封装起来，二是隐藏这些具体类的实例创建和结合的方式。
创建型模式又分为对象创建型模式和类创建型模式。对象创建型模式处理对象的创建，类创建型模式处理类的创建。详细地说，对象创建型模式把对象创建的一部分推迟到另一个对象中，而类创建型模式将它对象的创建推迟到子类中。

简单工厂模式

简单工厂模式是工厂模式最简单的体现，一般就是创建一个接口，这个接口代表一类产品，接口中一般封装的是产品的创建规范，然后有具体的产品去实现这个接口，相当于定义一些方法让它的实现类去实现。然后创建一个产品工厂，该工厂就是用来创建真正的具体的产品,创建完成后返回具体产品实例。
以生产小米手机为例，你作为决策者，需要生产小米手机，首先要成立小米公司，这家公司的经营业务是制造小米手机，想要生产小米手机需要有相应的技术，因此这家公司研发了小米1和小米2手机的技术，有了技术需要生产就需要一个工厂来生产。
那么首先我们需要
1.定义这家公司的经营业务

public interface ProduceMiPhone {
    void makeMiPhone();//制造小米手机
}

2.定义小米1和小米2的生产技术

public class MiOneMake implements ProduceMiPhone{
public MiOneMake () {
        this.makeMiPhone();
    }
    @Override
    public void makeMiPhone() {
        System.out.println("制造了一个小米1手机");
    }
}

public class MiTwoMake implements ProduceMiPhone{
public MiTwoMake() {
        this.makeMiPhone();
    }
    @Override
    public void makeMiPhone() {
        System.out.println("制造了一个小米2手机");
    }
}

3.公司成立了，主营业务有了，产品技术也有了，现在就需要一家工厂了。

public class MiPhoneFactory {
    public ProduceMiPhone getPhone(String phoneType){
        if(phoneType.equals("小米1")){//如果收到生产指令是小米1
            return new MiOneMake();//生产小米1
        }else if(phoneType.equals("小米2")){//如果收到生产指令是小米2
            return new MiTwoMake();//生产小米2
        }
        return null;
    }
}

2.技术，工厂都有了，现在产品就可以上市售卖了，根据市场，你作为决策者来决定生产哪一款手机

public class Demo {
    public static void main(String[] args) {
        MiPhoneFactory miPhoneFactory=new MiPhoneFactory();
        ProduceMiPhone produceMiPhone1= miPhoneFactory.getPhone("小米1");//设置生产指令
        ProduceMiPhone produceMiPhone2= miPhoneFactory.getPhone("小米2");//设置生产指令
    }
}

**关系:**一个工厂可以生产多个产品，一个决策者对应一个工厂
**总结:**简单工厂模式，你封装好方法的入口(工厂)以及相应的具体实现(技术)，只需要按需要设置参数来调用即可(给工厂下达生产指令)。缺点:每次都要下发指令给工厂，工厂要根据下发的指令来切换生产产品的技术。

工厂方法模式

工厂方法模式是来解决简单工厂模式问题的，采用一种多工厂的思路，为每一个产品都单独写个工厂。
例如:小米1和小米2上市后大火，你挣了一大笔钱，但是一个工厂生产两款手机，技术来回切换及其浪费时间，索性你大手一挥，再建一个工厂来生产小米2。
1.你的经营业务没有改变依旧是小米手机(代码同上)
2.技术也没有变还是小米1和小米2(代码同上)
3.因为你有两家工厂了，因此组成了一个小米园区，专门来管理你的工厂

public interface AbstractFactory {//这个类就是园区
    ProduceMiPhone makephone();//这是这个园区的业务生产手机
}

4.你的两家工厂拆分后，每家工厂只生产一种手机
小米1

public class MiOnePhoneFactory implements AbstractFactory{
    @Override
    public ProduceMiPhone makephone() {
        return new MiOneMake();
    }
}

小米2

public class MiTwoPhoneFactory implements AbstractFactory{
    @Override
    public ProduceMiPhone makephone() {
        return new MiTwoMake();
    }
}

5.这个时候,你作为决策者想要哪款手机就去哪个工厂，而不用先告诉工厂要生产哪款手机。

public class Demo {
    public static void main(String[] args) {
        AbstractFactory factory1=new MiOnePhoneFactory();
        AbstractFactory factory2=new MiTwoPhoneFactory();
        factory1.makephone();
        factory2.makephone();
    }
}

关系： 一个工厂只生产一款产品，一个决策者对应多个工厂
总结： 工厂不需要再来回切换生产技术。缺点是如果以后小米手机卖的不好不需要生产这么多了，每天运行一半的产线就可以满足市场需求了，那剩下的一半产线停工就比较浪费了。如果以后有了新产品是不是又要新建一个工厂，这样就比较烧钱了。

抽象工厂模式

抽象工厂模式就是首先把生产产品的工厂进行抽象，形成抽象工厂类，同时增加接口，有几种类型的产品就增加多少接口，这次以生产手机和电脑为例：
1.经营业务进行了改变，从只有手机，变成了电脑和手机

public interface ProduceMiPhone {
    void makeMiPhone();//制造小米手机
}

public interface ProduceMiPC {
    void makeMiPC();//制造小米电脑
}

2.生产技术也有了改变，从只有手机技术，变成了也有了电脑技术
制造小米1 手机技术

public class MiOnePhoneMake implements ProduceMiPhone{
    public MiOnePhoneMake() {
        this.makeMiPhone();
    }

    @Override
    public void makeMiPhone() {
        System.out.println("制造了一个小米1手机");
    }
}

制造小米2手机技术

public class MiTwoPhoneMake implements ProduceMiPhone{
    public MiTwoPhoneMake() {
        this.makeMiPhone();
    }
    @Override
    public void makeMiPhone() {
        System.out.println("制造了一个小米2手机");
    }
}

制造小米1电脑技术

public class MiOnePCMake implements ProduceMiPC{
    public MiOnePCMake() {
        this.makeMiPC();
    }
    @Override
    public void makeMiPC() {
        System.out.println("制造了小米1电脑");
    }
}

制造小米2电脑技术

public class MiTwoPCMake implements ProduceMiPC{
    public MiTwoPCMake() {
        this.makeMiPC();
    }
    @Override
    public void makeMiPC() {
        System.out.println("制造了小米2电脑");
    }
}

3.你园区的生产技业务能力也发生了改变

public interface AbstractFactory {
    ProduceMiPhone makephone();//生产手机
    ProduceMiPC makePC();//生产电脑
}

4.你的工厂也发生了改变，从只能生产手机变成了既生产手机也生产电脑
工厂1

public class ProduceOneFactory implements AbstractFactory{
    //生产小米1手机
    @Override
    public ProduceMiPhone makephone() {
        return new MiOnePhoneMake();
    }
    //生产小米1电脑
    @Override
    public ProduceMiPC makePC() {
        return new MiOnePCMake();
    }
}

工厂2

public class ProduceTwoFactory implements AbstractFactory{
    //生产小米2手机
    @Override
    public ProduceMiPhone makephone() {
        return new MiTwoPhoneMake();
    }
    //生产小米2电脑
    @Override
    public ProduceMiPC makePC() {
        return new MiTwoPCMake();
    }
}

5.你作为决策者来获取产品的方式也发生了改变

public class Demo {
    public static void main(String[] args) {
        AbstractFactory factory1=new ProduceOneFactory();
        AbstractFactory factory2=new ProduceTwoFactory();
        factory1.makephone();
        factory1.makePC();
        factory2.makephone();
        factory2.makePC();
    }
}

关系： 一个工厂生产多款产品，一个决策者对应多个工厂
总结： 一个工厂不需要再来回切换生产技术，即可生产多种产品。

总结

简单工厂模式:就是一个判断，需要根据指令来判断返回的内容，如果要增加一种产品，就会牵一发动全身的修改工厂代码。
工厂方法模式:总工厂(工厂类)对应子工厂(接口)，对接口进行了抽象，如果增加一种产品，需要新建一个工厂(接口)。
抽象工厂模式::对产品进行了抽象，我们可以通过工厂类控制到工厂的流水线，控制能力更强了。