工厂模式

简单工厂模式（Simple Factory Pattern）

简单工厂模式（simple factory pattern）是指由一个专门的工厂对象决定创建哪一种产品的实例。简单工厂模式不属于 GOF 的 23 种设计模式。简单工厂模式适用于工厂类负责创建对象较少的场景，且客户端只需要传入工厂的参数，对于如何创建对象不需要关心。

简单工厂模式的实现

创建课程抽象类

/**
 * 抽象角色  规定子类必须实现的接口
 */
public interface ICourse {
    public void course();
}

创建具体 java 课程类

/**
 * 具体 java 课程类  实现抽象课程的接口
 */
public class JavaCourse implements ICourse{
    @Override
    public void course() {
        System.out.println("创建了java课程");
    }
}

创建具体 python 课程类

/**
 * 具体 python 课程类，实现抽象课程类的接口
 */
public class PythonCourse implements ICourse{
    @Override
    public void course() {
        System.out.println("创建了python课程");
    }
}

创建简单工厂类，负责创建不同的课程对象

/**
 * 简单工厂类 负责创建不同的课程对象
 */
public class CourseFactory {
    public static ICourse createCourse(Class<? extends ICourse> clazz){
        try {
            if (clazz != null) {
                return clazz.newInstance();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

测试

    public static void main(String[] args) {
        // 创建 java 课程
        ICourse javaCourse = CourseFactory.createCourse(JavaCourse.class);
        javaCourse.course();

        // 创建 python 课程
        ICourse python = CourseFactory.createCourse(PythonCourse.class);
        python.course();
    }

结果

创建了java课程
创建了python课程

这是如果想加入大数据课程，只需要实现 ICourse 接口，使用工厂类很方便的就可以创建对象。

工厂方法模式（Factory Method Pattern）

工厂方法模式（factory method pattern）是指定义一个创建对象的的接口，但让实现这个接口的类来决定要实例化那个类，工厂方法模式让类的实例化推迟到子类中进行。在工厂方法模式中用户只需要关心所需产品对应的工厂，无需关心创建细节，而且加入新的产品是符合开原则。

工厂方法模式的优缺点

优点
1.用户只需要知道具体的工厂名就可以得到所需要的产品，无需关心创建的细节
2.在系统中需要增加新的产品，只需要增加新的产品类和对应的工厂，无需对原有的工厂进行修改，满足开闭原则

缺点
1.每增加一中产品，就需要增加一个产品类和产品工厂类，增加了系统的复杂度，理解难度

工厂方法模式的主要角色

1.抽象产品（Abstract Product）角色，定义产品的基本接口
2.具体产品（Concrete Product）角色，实现产品接口
3.抽象工厂（Abstract Factory）角色，定义工厂方法，用来返回一个产品
4.具体工厂（Concrete Product）角色，实现工厂方法，返回具体的产品

工厂方法模式的实现

创建抽象产品类 AbstractProcuct，定义产品的基本接口

/**
 * 抽象产品 ，定义产品的基本接口
 */
public interface AbstractProduct {

    public void product();
}

分别创建具体产品类，ConcreteProductA ,ConcreteProduceB，实现具体产品类的接口

/**
 * 具体产品A 实现抽象产品的接口
 */
public class ConcreteProductA implements AbstractProduct{
    @Override
    public void product() {
        System.out.println("具体产品A");
    }
}

/**
 * 具体产品B 实现抽象产品的接口
 */
public class ConcreteProductB implements AbstractProduct {
    @Override
    public void product() {
        System.out.println("具体产品B");
    }
}

创建抽象工厂类 AbstractFactory，定义工厂方法，返回抽象产品

/**
 * 抽象工厂类  定义工厂方法获得一个产品对象
 */
public interface AbstractFactory {
    public AbstractProduct creteProduct();
}

分别创建具体工厂类 ConcreteFactoryA，ConcreteFactoryB，实现工厂方法，返回具体的产品对象

/**
 * 具体工厂A  实现工厂方法，用于获得具体产品A
 */
public class ConcreteFactoryA implements AbstractFactory{
    @Override
    public AbstractProduct creteProduct() {
        return new ConcreteProductA();
    }
}

/**
 * 具体工厂B ，实现工厂方法 用户获取具体产品B
 */
public class ConcreteFactoryB implements AbstractFactory{
    @Override
    public AbstractProduct creteProduct() {
        return new ConcreteProductB();
    }
}

测试

    public static void main(String[] args) {
        // 具体产品 A
        AbstractFactory factoryA = new ConcreteFactoryA();
        factoryA.creteProduct().product();

        // 具体产品 B
        AbstractFactory factoryB = new ConcreteFactoryB();
        factoryB.creteProduct().product();
    }

结果

具体产品A
具体产品B

抽象工厂模式（Abstract Factroy Pattern）

抽象工厂模式（abstract factory pattern）是指提供一个创建一系列相关或者相互依赖对象的接口，无需指定它们的具体类

抽象工厂模式一般要满足一下条件

1.系统中有多个产品族，每个具体工厂创建同一产品组但属于不同结构的产品
2.系统一次只可能成消费一组产品，及统一产品族的产品

抽象工厂模式的优缺点

优点
抽象工厂模式除了具有工厂方法的优点外，还具有以下优点
1.创建和使用分离：使用者无需了解具体产品族的实现
2.约束性：使用者只能使用同一产品族的产品
3.易于扩展：增加新的产品族不需要修改别的商品族

缺点
1.当前要加入新的产品时所有的产品工厂类都要修改，不符合开闭原则