【设计模式】三种工厂模式

【设计模式】工厂模式

相对来说，写的比较乱，但是看一下实例，其实理解很快
成都创新互联公司是专业的九江网站建设公司，九江接单;提供成都网站建设、网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行九江网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

抽象工厂模式（这里主要介绍抽象工厂模式）

核心的工厂类不再负责所有对象的创建，而是将具体的创建工作交给子类去做。这个类则摇身一变变成了一个抽象工厂角色，仅仅负责给出具体工厂子类必须实现的接口。
举个例子：
我有个鸡厂，我准备养鸡，可以养母鸡和公鸡，但是母鸡或者公鸡有黄鸡和黑鸡（这就是举个例子，不要太在意是否是正常的），
有一个抽象工厂，生产鸡的工厂：

/**
 * @Description 总工厂
 */
public interface Factory{

    public Chicken getChicken(String name) throws InstantiationException, IllegalAccessException;
}

它有两个实现类，分别是生产母鸡的工厂和生产公鸡的工厂：

/**
 * @Description 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
 */
public class ChickenFactoryGirl implements Factory{
    @Override
    public Chicken getChicken(String name) throws InstantiationException, IllegalAccessException {
        if ("YellowGirlChicken".equalsIgnoreCase(name)) {
            return YellowGirlChicken.class.newInstance();
        } else if ("BlackGirlChicken".equalsIgnoreCase(name)) {
            return BlackGirlChicken.class.newInstance();
        }else{
            return null;
        }
    }
}
/**
 * @Description 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
 */
public class ChickenFactoryMan implements Factory{
    @Override
    public Chicken getChicken(String name) throws InstantiationException, IllegalAccessException {
        if ("YellowManChicken".equalsIgnoreCase(name)) {
            return YellowManChicken.class.newInstance();
        } else if ("BlackManChicken".equalsIgnoreCase(name)) {
            return BlackManChicken.class.newInstance();
        }else{
            return null;
        }
    }
}

抽象产品角色，一只鸡：

/**
 * @Description 产品的抽象接口
 */
public interface Chicken {

    /**
     * 获得相应的鸡
     */
    public void get();
}

具体产品角色：

public class BlackGirlChicken implements Chicken{

    /**
     * 这叫做黑鸡
     */
    @Override
    public void get() {
        System.out.println("这是一只黑母鸡");
    }
}
public class BlackManChicken implements Chicken{
    @Override
    public void get() {
        System.out.println("这是一只黑公鸡");
    }
}
public class YellowManChicken implements Chicken{
    @Override
    public void get() {
        System.out.println("这是一只黄公鸡");
    }
}
public class YellowGirlChicken implements Chicken{

    /**
     * 这叫做黄鸡
     */
    @Override
    public void get() {
        System.out.println("这是一只黄母鸡");
    }
}

模拟客户端调用，实例化出一个具体的工厂角色，根据传入的参数返回不同的产品角色：

public class User {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        ChickenFactoryMan chickenFactoryMan = new ChickenFactoryMan();
        ChickenFactoryGirl chickenFactoryGirl = new ChickenFactoryGirl();
        Chicken yellowGirlChicken = chickenFactoryGirl.getChicken("YellowGirlChicken");
        yellowGirlChicken.get();
        Chicken blackGirlChicken = chickenFactoryGirl.getChicken("BlackGirlChicken");
        blackGirlChicken.get();
        Chicken yellowManChicken = chickenFactoryMan.getChicken("YellowManChicken");
        yellowManChicken.get();
        Chicken blackManChicken = chickenFactoryMan.getChicken("BlackManChicken");
        blackManChicken.get();

    }
}

总结：

对于抽象工厂类，其实是可以通过不同的品种种类来进行工厂创建，这样就不会有工厂方式模式中的增加一个就创建一个工厂
那这个就是要在我们的产品族中增加一类产品，同时再增加一个工厂就可以解决这个问题；还有一个非常大的有点，高内聚，低耦合，在一个较大的项目组，产品是由一批人定义开发的，但是提供其他成员访问的时候，只要提供工厂方法和产品的接口，也就是说只需要提供Interface 和抽象工厂，当然也可以提供具体工厂实现，根据实际情况来吧，就可以产生自己需要的对象和方法。可扩展性很高。
在一个工厂里聚合多个同类产品！
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

产品族难扩展，产品等级易扩展。
总的来说，不同的工厂模式有不同的好处吧，也可以都尝试一下，源码里面其实都会有一定的实现！

工厂方法模式

介绍

简单来说就是通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。

作用

和简单工厂模式不同，就是为了解决问题产生的
这里将类的具体产品的创建（实例化）交给了工厂类的子类（具体工厂）来进行实现，这里会由子类来进行选择生产

工厂方法模式把具体产品的创建推迟到工厂类的子类（具体工厂）中，此时工厂类不再负责所有产品的创建，而只是给出具体工厂必须实现的接口，这样工厂方法模式在添加新产品的时候就不修改工厂类逻辑而是添加新的工厂子类

实例

还是鸡厂，作为一个卖鸡的专业商户，随着买鸡业务的增多，我自己生产的鸡品类越来越多，这时候我需要专门来进行养鸡的工厂来养鸡，这样我不会在乎这些工厂怎么养鸡的，我只会从这些工厂里面拿鸡，然后A类工厂拿到了订单进行生产，后面又增加B类鸡业务，然后置办了另一个工厂B来进行生产B类鸡，这里A鸡厂就不需要进行改变，也不会发生业务混淆的问题
工厂的公共接口，总鸡厂

/**
 * @Description 总工厂
 */
public interface Factory{

    public Chicken getChicken() throws InstantiationException, IllegalAccessException;
}

创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；具体生产鸡的工厂

/**
 * @Description 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
 */
public class ChickenFactoryA implements Factory{


    @Override
    public Chicken getChicken() throws InstantiationException, IllegalAccessException {
        return BlackChicken.class.newInstance();
    }
}
/**
 * @Description 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
 */
public class ChickenFactoryB implements Factory{
    @Override
    public Chicken getChicken() throws InstantiationException, IllegalAccessException {
        return YellowChicken.class.newInstance();
    }

}

创建一个养鸡的接口产品类

/**
 * @Description 产品的抽象接口
 */
public interface Chicken {

    /**
     * 获得相应的鸡
     */
    public void get();
}

接下来创建具体的产品类

/**
 * @Description 黄鸡对抽象产品接口的实现
 */
public class BlackChicken implements Chicken{

    /**
     * 这叫做黑鸡
     */
    @Override
    public void get() {
        System.out.println("这是一只黑鸡");
    }
}

/**
 * @Description 黄鸡对抽象产品接口的实现
 */
public class YellowChicken implements Chicken{

    /**
     * 这叫做黄鸡
     */
    @Override
    public void get() {
        System.out.println("这是一只黄鸡");
    }
}

优点

更符合开-闭原则，新增一种产品时，只需要增加相应的具体产品类和相应的工厂子类即可
符合单一职责原则，每个具体工厂类只负责创建对应的产品

缺点

添加产品，虽然生产产品不会很复杂，但随着产品种类的增加，系统类的个数会不断增加，会不断增加系统的开销
虽然保证了工厂方法内的对修改关闭，但对于使用工厂方法的类，如果要更换另外一种产品，仍然需要修改实例化的具体工厂类；
一个工厂只能创建一个产品

总结

还是比较适合简单一点的生产环境，比简单生产模式更加安全合理，但是业务的增加会导致系统开销的增加，这样是不合理的，所以对于简单的业务环境会比较适合，会造成类爆炸

简单工厂模式

简单介绍一下简单工厂模式：就是我作为一个商家，随着业务不断拓宽，生产的产品不断增多，这时候我需要一个专门的来工厂进行生产需要的产品，然后商家只需要从工厂来拿货，而不需要自己负责所有。

Factory：工厂类，负责实现内部逻辑，创建的产品类可以被外界直接调用，创建所需要的产品对象
IProduct：抽象产品类，所有产品对象的父类，负责所有实例的共有的公共接口
Product：具体产品类

这种情况下可以使用

工厂类负责创建的对象相对来说比较少，业务逻辑不会太复杂
客户端只知道传入工厂类的参数，对于如何创建对象不会关心；客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。
JDK类库中就广泛使用了简单工厂模式，如工具类java.text.DateFormat，它用于格式化一个本地日期或者时间。

实例

作为一个卖鸡的专业商户，随着买鸡业务的增多，我自己生产的鸡品类越来越多，这时候我需要一个专门来进行养鸡的工厂来养鸡，这样我不会在乎这个工厂怎么养鸡的，我只会从这个工厂里面拿鸡

创建一个养鸡的接口产品类

/**
 * @Description 产品的抽象接口
 */
public interface Chicken {

    /**
     * 获得相应的鸡
     */
    public void get();
}

接下来创建具体的产品类

/**
 * @Description 黄鸡对抽象产品接口的实现
 */
public class BlackChicken implements Chicken{

    /**
     * 这叫做黑鸡
     */
    @Override
    public void get() {
        System.out.println("这是一只黑鸡");
    }
}

/**
 * @Description 黄鸡对抽象产品接口的实现
 */
public class YellowChicken implements Chicken{

    /**
     * 这叫做黄鸡
     */
    @Override
    public void get() {
        System.out.println("这是一只黄鸡");
    }
}

创建一个工厂类，它提供了一个静态方法getChicken用来养鸡。你只需要传入你想生产的鸡的种类，它就会实例化相应的鸡对象：

/**
 * @Description 鸡的加工厂
 */
public class ChickenFactory {

    public static Chicken getChicken(String type) throws InstantiationException, IllegalAccessException {
        if("BlackChicken".equalsIgnoreCase(type)){
            return BlackChicken.class.newInstance();
        }else if("YellowChicken".equalsIgnoreCase(type)){
            return YellowChicken.class.newInstance();
        }else{
            System.out.println("找不到对应的实例化类");
            return null;
        }
    }
}

测试一下（鸡哥就是不一样，要啥鸡有啥鸡）

/**
 * @Description
 */
public class User {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        Chicken blackChicken = ChickenFactory.getChicken("BlackChicken");
        Chicken yellowChicken = ChickenFactory.getChicken("YellowChicken");
        if(yellowChicken != null){
            yellowChicken.get();
        }

    }
}

优点

有点我看了好多博客，说实话认真看的没多少

就是我不需要记住具体的实现产品类，我只需要记住参数，这样可能会舒服一些
我增加或者更换新的产品类时，我不需要对以前的进行修改，只需要加一个新的就行

缺点

由于工厂类集中了所有实例的创建逻辑，这就直接导致一旦这个工厂出了问题，所有的客户端都会受到牵连，就是工厂出问题，我们就都会出问题，这样不安全
当我们的产品种类太多的时候，我们可能会混淆产品，这里就需要进行各种判断，所以这里违背了“单一原则”
（单一原则：一个类所承担的职责不能够太多，这里就产生了单一原则，一个类只能负责一个功能领域的相应职责，对于一个类来说，只能由一个引起它变化的原因）
简单工厂模式违背了“开放封闭原则”，就是违背了“系统对扩展开放，对修改关闭”的原则，因为当我新增加一个产品的时候必须修改工厂类，相应的工厂类就需要重新编译一遍。就是系统扩展困难，一旦添加新产品就不得不修改工厂逻辑
（开放封闭原则：软件一般来说时可扩展但不可修改的，也就是有了新的业务只能对现有的类上进行扩展，而不能进行修改。类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改）

总结

对于简单的工厂模式来说，可以用，但是不能用太多，只适合在需求不多的时候使用，比如自己写一个小型测试类

本文名称：【设计模式】三种工厂模式
本文URL：http://kswsj.cn/article/dscgijc.html

关于创新互联