工厂模式
简单工厂模式（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.当前要加入新的产品时所有的产品工厂类都要修改，不符合开闭原则
