【转】Java设计模式之工厂模式

注：本文转自知乎大佬：冯冬冬的IT技术栈

在古代的时候，人们身上穿的衣服其实是人们自己使用织布机织的，随着社会的发展，一直到了现代社会，我们身上穿的衣服基本上都是在工厂里面做好了，直接拿到市面上去卖就好了，对于我们身上的衣服而言，由一开始的手工制作再到今天的工厂生产，这就是工厂模式。

一、认识工厂模式

工厂模式主要分为三个：

（1）简单工厂模式：我们的衣服在工厂里面去建造，这就是简单工厂模式

（2）工厂方法模式：随着社会的发展，用户现在想要一身黑色的衣服、也想要一身红色的衣服。于是乎，我们开始定义一个总厂，下面有很多具体的工厂来生产不同颜色的衣服。

（3）抽象工厂模式时代：随着客户的要求越来越高，不同颜色衣服还要带各种颜色的帽子去搭配。于是这个工厂又开始生产衣服又要去生产帽子。

我们这里所说的工厂模式就是指的前两种：简单工厂模式和工厂方法模式

为了演示方便，（其实我是借鉴了很多别人的文章），我们先从手动织布时代开始：

二、手动织布时代

我们先用一张图来看一下手动织布时代的关系：

第一步：有一个cloth类

public class Cloth {
    // 在古代，布是需要我们手动去织的。
    public Cloth() {
        System.out.println("手动去织布。。。。");
    }
}

第二步：人们要想使用，需要手动去new出一个

public class User { 
    //手动织布时代:需要什么衣服，我们要自己new一个对象
    Cloth cloth=new Cloth();
}

手动织布时代样子很简单，但是时间久了，人越来越多，衣服也会越来越多，我们创建的对象也会越来越多，代码会显得格外臃肿。于是乎，人们开始创建了工厂，我们不必关系自己如何去生产布匹，而是交给工厂

三、简单工厂时代

我们在使用一张图来表示：

从上面我们可以看到简单工厂模式主要有四个角色：

（1）客户（User）：用来指定生产什么衣服，提要求的

（2）工厂（factory）：生产所有衣服的工厂

（3）抽象产品（abstract product）:定义所有衣服的抽象类，可以描写所有衣服的共同属性

（4）具体产品（product）：抽象衣服的具体实现

下面我们代码来实现一下：

第一步：定义抽象类

abstract class Cloth {
    public Cloth() { }
}

第二步：具体产品类

class RedCloth extends Cloth {
    public RedCloth() {
        System.out.println("生产红衣服");
    }
}
class BlackCloth extends Cloth {
    public BlackCloth() {
        System.out.println("生产黑衣服");
    }
}

第三步：工厂类

class clothFactory {
    public Cloth createCloth(String type) {
        switch (type) {
            case "red":
                return new RedCloth();
            case "black":
                return new BlackCloth();
            default:
                break;
        }
        return null;
    }
}

第四步：用户

class SimpleFactoryUser {
    public static void main(String[] args) {
        // 简单工厂时代：东西都交给工厂来生产
        clothFactory factory = new clothFactory();
        // 接下来我们需要什么直接就去让工厂来创建
        factory.createCloth("red");
        factory.createCloth("black");
    }
}

四、工厂方法模式

随着社会的发展，发现用户需要衣服的颜色也开始变得越来越多了，一般都是花里胡哨的那些，这时候有就麻烦了，因为每次新增加一种颜色的衣服时候，我们都需要在工厂里面添加一个新的case语句。这样颜色越来越多，工厂类开始变得臃肿起来。于是为了不违背开闭原则，开始对工厂类有一个划分。

下面使用一张图来表示一下：

从上面我们可以看到主要有五个角色：

（1）用户：提需求，使用衣服

（2）工厂接口：我们不再一个工厂去生产所有衣服了，而是定义一个抽象接口，这样有新的需求的时候，我们就可以把这些工厂的共同操作提取出来

（3）具体工厂：具体工厂对职责又进行了细化分，每一个工厂只负责一种产品

（4）抽象产品：产品的所有抽象类

（5）具体产品：具体的每一种衣服。

下面看代码的具体实现：

第一步：定义一个抽象产品类

abstract class Ball {
    public Ball() {}
}

第二步：具体的产品类

class RedBall extends Ball {
    public RedBall() {
        System.out.println("生产红球");
    }
}
class BlueBall extends Ball {
    public BlueBall() {
        System.out.println("生产蓝球");
    }
}

第三步：工厂接口

interface BallFactory {
    public Ball createBall();
}

第四步：具体工厂

class RedBallFactory implements BallFactory {
    public RedBall createBall() {
        return new RedBall();
    }
}
class BlueBallFactory implements BallFactory {
    public BlueBall createBall() {
        return new BlueBall();
    }
}

第五步：用户

class FactoryMethodUser {
    public static void main(String[] args) {
        // 工厂方法时代
        RedBallFactory redBallFactory = new RedBallFactory();
        RedBall redBall = redBallFactory.createBall();

        BlueBallFactory blueBallFactory = new BlueBallFactory();
        BlueBall blueBall = blueBallFactory.createBall();
    }
}

其实现在还不能满足我们的需求，因为随着时代的发展，人们的需求变得更加复杂，比如说我红色衣服要10000件，但是黑色衣服只需要10件，这样的差别实在太大了，而我们仍然需要建造一个工厂。而且，还有一些用户买衣服的时候还需要选择是不是再购买一双鞋子。所以上面的这个模式能够解决一些简单的情况，但是比较复杂的情况依然不能解决。不过办法总是比问题要多，下一遍博客主要就是解决这个问题，也就是抽象工厂模式。