工厂模式学习笔记

简单工厂模式

简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类 的实例，但它不属于 GOF23 种设计模式

举例

我们先定义一个顶层课程接口，然后创建一个Java课程实现这个接口

public interface ICourse{
	//录制
	void record();
}

public class JavaCourse implements ICourse{  
	//录制
	void record(){
		println("Java");
	}
}

//调用
public static void main(String args[]){
	ICourse course = new JavaCourse();
	course.record();
}

此时，我们需要新增一些课程，当课程变多以后，调用过程逐渐变的臃肿。
我们采用简单工厂模式进行优化：

public class CourseFactory {
    public ICourse create(String name) {
        if ("java".equals(name)) {
            return new JavaCourse();
        } else if ("python".equals(name)) {
            return new PythonCourse();
        } else {
            return null;
        }
    }
}

//调用
public static void main(String args[]){
	CourseFactory factory = new CourseFactory(); 
	ICourse course = factory.create("java");
	course.record();
}

每次新增新的课程类时，就需要在create()方法中增加新的代码，不符合开闭原则，我们可以采用反射技术进行优化

public class CourseFactory {
    public ICourse create(Class <? extends ICourse> clazz) {
       try{
			if (clazz != null) { 
			   return clazz.newInstance(); 
			}
		} catch (Exception e){
			e.printStackTrace();
		}
		return null;
    }
} 

//调用
public static void main(String args[]){
	CourseFactory factory = new CourseFactory(); 
	ICourse course = factory.create(JavaCourse.class); 
	course.record();
}

简单工厂模式只适用于对象的创建，不适合处理复杂的业务逻辑

工厂方法模式

工厂方法模式（Fatory Method Pattern）是指定义一个创建对象的接口，但让实现这个 接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。

实例

根据单一职责原则我们将职能继续拆分。Java 课程由 Java 工厂创建， Python 课程由 Python 工厂创建，对工厂本身也做一个抽象。

//课程工厂
public interface ICourseFactory{
	ICourse create();
}

//课程顶层接口
public interface ICourse{
	void record();
}

//Java课程工厂
public class JavaCourseFactory implements ICourseFactory {
	public ICourse create() {
		//实例化课程过程
		return new JavaCourse();
	}
}

//Python课程工厂
public class PythonCourseFactory implements ICourseFactory {
	public ICourse create() {
		return new PythonCourse();
	}
}

//调用
public static void main(String args[]){
	ICourseFactory factory = new JavaCourseFactory();
	ICourse course = factory.create();
	course.record();
}

工厂方法适用于以下场景：
1、创建对象需要大量重复的代码。
2、客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
3、一个类通过其子类来指定创建哪个对象。
工厂方法也有缺点：
1、类的个数容易过多，增加复杂度。
2、增加了系统的抽象性和理解难度

抽象工厂模式

抽象工厂模式（Abastract Factory Pattern）是指提供一个创建一系列相关或相互依赖，对象的接口，无须指定他们具体的类。

实例

例如提供网课的网站，不光需要提供网课视频，还需要提供网课笔记

public interface INote {
	void write();
}

public interfae IVideo {
	void record();
}

//创建一个工厂类
public interface CourseFactory {
	INote createNote();
	IVideo createVideo();
}

//Java笔记
public class JavaNote implements INote {
	public void write() {
		println("java note");
	}
}

//Java视频
public class JavaVideo implements IVideo {
	public void record(){
		println("java video");
	}
}

//Java笔记工厂
public class JavaCourseFactory implements CourseFactory{
	INote createNote(){
		return new JavaNote();
	}
	IVideo createVideo(){
		return new JavaIVideo();
	}
}

//调用
public static void main(String args[]){
	CourseFactory factory = new JavaCourseFactory();
	INote note = factory.ceateNote();
	note.write();
}

当有新的课程时，按照上面的方式继承INote和IVideo接口，当需要在课程下添加新的类目时，比如Java课程再提供源码，那么需要在Java课程工厂中添加新的createSource()方法，不符合开闭原则

1. 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂 的接口。
2. 增加了系统的抽象性和理解难度。

抽象工厂存在这样的缺点，但是实际开发中，不必一定遵循开闭原则，按照实际需求选择设计结构

参考咕泡学院课程