Java工厂模式

简介

Java工厂模式大体分为简单工厂、工厂方法、抽象工厂等三种模式。工厂方法模式也可称为工厂模式，与抽象模式都是属于23种设计模式中的之一。简单工厂进阶变成了工厂方法，然后再进阶成了抽象工厂。难度逐步增加，也越来越抽象。

一、简单工厂模式

一个栗子：
我喜欢吃面食，抽象一个面食基类，(接口也可以)，这是产品的抽象类。

public abstract class pasta {
    /**
     * 描述每种面食啥样的
     */
    public abstract void desc();
}

先来一份韭菜饺子（具体的产品类）：

public class Leeks extends pasta {
    @Override
    public void desc() {
        System.out.println("味道有点大！");
    }
}

营养的虾仁饺子（具体的产品类）：

public class Shrimp extends pasta {
    @Override
    public void desc() {
        System.out.println("味道好极了！");
    }
}

菜单如下：

public class SimpleFactory {
    public static final int TYPE_L = 1;//韭菜
    public static final int TYPE_S = 2;//虾仁

    public static Dumplings create(int type) {
        switch (type) {
            case TYPE_Leeks:
                return new Leeks();
            case TYPE_Shrimp:
                return new Shrimp();
        }
    }
}

来到面馆，点了一份虾仁的:

pasta simple = SimpleFactory.create(SimpleFactory.TYPE_S);
 simple.desc();

输出：

味道好极了！

优点：将创建使用工作分开，不必关心类对象如何创建，实现了解耦；
缺点：违背“开放 - 关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，这样就会造成工厂逻辑过于复杂。

二、工厂方法模式

又称工厂模式、多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。一种常用的对象创建型设计模式,此模式的核心精神是封装 类中不变的部分。

举个简单易懂的例子：
产品：还是上边的饺子
工厂：Factory.java、FactoryL.java 、FactoryS.java
Factory.java

abstract class Factory {
    //生产产品
    abstract Product makeDumplings();
}

FactoryL.java

public class FactoryL extends Factory{
    @Override
    Product makeDumplings() {
        return new Leeks();
    }
}

FactoryS.java

public class FactoryS extends Factory{
    @Override
    Product makeDumplings() {
        return new Shrimp();
    }
}

测试：Test.java

public class Test {
    public static void main(String[] args) {
        //创建具体的工厂
        FactoryL factoryL = new FactoryL();
        //生产相对应的产品
        factoryA.makeDumplings().desc();
        FactoryS factoryS = new FactoryS();
        factoryS.makeDumplings().desc();
    }
}

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

缺点：
1.增加了系统的复杂度：类的个数将成对增加
2.增加了系统的抽象性和理解难度
3.一个具体工厂只能创建一种具体产品

三、抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。
Factory.java（抽象工厂）

abstract class Factory {
    //生产饺子
    abstract Factory getDumplings();
    //生产面条
    abstract Factory getNoodles();
}

FactoryD.java（抽象饺子工厂）

abstract class FactoryD extends Factory{
     @Override
    abstract void intro();
}

FactoryN.java（抽象面条工厂）

abstract class FactoryN extends Factory{
     @Override
    abstract void intro();
}

Dumplings.java（具体的面条工厂）

public  class Dumplings extends FactoryD{
    @Override
    void intro() {
        System.out.println("牛肉饺子");
    }
}

Noodles.java（具体的面条工厂）

public  class Noodles extends FactoryN{
    @Override
    void intro() {
        System.out.println("三鲜面");
    }
}

饭店：

public class Restaurant extends Factory{
    @Override
    Product getDumplings() {
        //生产饺子
        return new Dumplings();
    }
    @Override
    Product getNoodles() {
        //生产面条
        return new Noodles();
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        
        Restaurant restaurant = new Restaurant();
        restaurant.getDumplings().intro();
        restaurant.getNoodles().intro();
    }
}

优点：
1.降低耦合
2.符合开-闭原则
3.符合单一职责原则
4.不使用静态工厂方法，可以形成基于继承的等级结构。

缺点：难以扩展新种类产品