工厂模式

一，工厂模式

工厂模式是用来创建对象的一种最常用的设计模式。我们不暴露创建对象的具体逻辑，而是将逻辑封装在一个函数中，那么这个函数就可以被视为一个工厂。工厂模式根据抽象程度的不同可以分为

• 简单工厂

• 工厂方法

• 抽象工厂

二，简单工厂

正如名字那样简单，简单，可能在一些业务场景里，比如，现在有黄，黑，白三种人，要产生这三种人的对象，就需要一个工厂，如果这个工厂是一个简单工厂的话，里边可能就是包含了产生这三种对象的工厂方法

/**
 * @Description:    简单工厂
 * @Author:         Kevin
 * @CreateDate:     2019/6/6 22:02
 * @UpdateUser:     Kevin
 * @UpdateDate:     2019/6/6 22:02
 * @UpdateRemark:   修改内容
 * @Version: 1.0
 */
public class SimpleFactory {

    public static BlackHuman getBlackHuman(){
        return new BlackHuman();
    }

    public static WhiteHuman getWhiteHuman(){
        return new WhiteHuman();
    }

    public static YellowHuman getYellowHuman(){
        return new YellowHuman();
    }
}

如果对于只需要简单实例化一种对象或比较少类，可以使用简单工厂

但是缺点也很明显，比如水果，有很多种水果，苹果，香蕉数不清的多，如果要实例化这么多品种的水果，那这个简单工厂岂不是要新增很多工厂方法？也会修改原来的代码，所以这才有了下边的比简单工厂稍微复杂一点的工厂

三，工厂方法

抽象出一个工厂接口，定义生产方法

public interface HumanFactory {

    Human getHuman();

}

分别定义各种类型的工厂类

```java
public class BlackHumanFactory implements HumanFactory {

    @Override
    public Human getHuman() {
        return new BlackHuman();
    }
}

public class WhiteHumanFactory implements HumanFactory {

    @Override
    public Human getHuman() {
        return new WhiteHuman();
    }
}

public class YellowHumanFactory implements HumanFactory {

    @Override
    public Human getHuman() {
        return new YellowHuman();
    }
}

如果届时需要新增产品，可以无需改动原先写好的代码，只需要新增工厂实现类就可以，实现了对修改封闭，对扩展开放

四，抽象工厂

上边的例子都是基于一个工厂，如果多个呢，这就需要抽象工厂来解决

现在人类需要车作为交通工具，车有两种，A车和B车

现在需要两个工厂

先定义一个父工厂

/**
 * @Description:    抽象工厂
 * @Author:         Kevin
 * @CreateDate:     2019/6/6 22:03
 * @UpdateUser:     Kevin
 * @UpdateDate:     2019/6/6 22:03
 * @UpdateRemark:   修改内容
 * @Version: 1.0
 */
public abstract class AbstractFactory {

    public abstract <T extends Human>T createHuman(Class<T> c);

    public abstract <T extends Car>T createCar(Class<T> c);
}

定义子工厂

public class AbstractHumanFactory extends AbstractFactory {

    @Override
    public <T extends Human> T createHuman(Class<T> c) {
        Human human = null;
        try {
            human = (Human) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T)human;
    }

    @Override
    public <T extends Car> T createCar(Class<T> c) {
        return null;
    }
}

public class AbstractCarFactory extends AbstractFactory {

    @Override
    public <T extends Human> T createHuman(Class<T> c) {
        return null;
    }

    @Override
    public <T extends Car> T createCar(Class<T> c) {
        Car car = null;
        try {
            car = (Car) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T)car;
    }
}

感觉理解的不是很到位，尤其是抽象工厂，希望大家多多指教