工厂模式

三种工厂模式

简单工厂模式

简单工厂模式(Simple Factory Pattern)是指由一个工厂对象决定创建出哪一种产品 类的实例,但它不属于 GOF,23 种设计模式。
简单工厂适用 于工厂类负责创建的对象较少的场景,且客户端只需要传入工厂类的参数,对于如何创 建对象的逻辑不需要关心。

代码实现:

//1.先定义一个课程接口
public interface ICourse {
	 /** 录制视频 */ 
 	public void record();
}
//2.创建一个 Java 课程的实现 JavaCourse 类:
public class JavaCourse implements ICourse {
	 public void record() { 
	 	System.out.println("录制 Java 课程"); 
	 }
}
//3.客户端调用代码
public static void main(String[] args) {
	 ICourse course = new JavaCourse(); 
	 course.record(); 
}

看上面的代码,父类 ICourse 指向子类 JavaCourse 的引用,应用层代码需要依赖 JavaCourse,如果业务扩展,我继续增加 PythonCourse 甚至更多,那么我们客户端 的依赖会变得越来越臃肿。因此,我们要想办法把这种依赖减弱,把创建细节隐藏。虽 然目前的代码中,我们创建对象的过程并不复杂,但从代码设计角度来讲不易于扩展。 现在,我们用简单工厂模式对代码进行优化。

1.先增加课程 PythonCourse 类:

public class PythonCourse implements ICourse { 
	public void record() { 
		System.out.println("录制 Python 课程"); 
	} 
}

2.创建 CourseFactory 工厂类:

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; 
		} 
	} 
}

3.修改客户端调用代码:

public class SimpleFactoryTest {
	public static void main(String[] args) { 
		CourseFactory factory = new CourseFactory(); 
		factory.create("java");
	}
}

当然,我们为了调用方便,可将 factory 的 create()改为静态方法。客户端调用是简单了,但如果我们业务继续扩展,要增加前端课程,那么工厂中的 create() 就要根据产品链的丰富每次都要修改代码逻辑。不符合开闭原则。因此,我们 对简单工厂还可以继续优化,可以采用反射技术。

工厂方法模式

工厂方法模式(Fatory Method Pattern)是指定义一个创建对象的接口,但让实现这 个接口的类来决定实例化哪个类,工厂方法让类的实例化推迟到子类中进行。在工厂 方法模式中用户只需要关心所需产品对应的工厂,无须关心创建细节,而且加入新的 产品符合开闭原则。
工厂方法模式主要解决产品扩展的问题,在简单工厂中,随着产品链的丰富,如果每个 课程的创建逻辑有区别的话,工厂的职责会变得越来越多,有点像万能工厂,并不便于维护。根据单一职责原则我们将职能继续拆分,专人干专事。Java 课程由 Java 工厂 创建, Python 课程由 Python 工厂创建,对工厂本身也做一个抽象。来看代码,
1.先创建 ICourseFactory 接口:

public interface ICourseFactory {
 ICourse create(); 
}

2.分别创建子工厂,JavaCourseFactory 类:

public class JavaCourseFactory implements ICourseFactory { 
	public ICourse create() { 
		return new JavaCourse(); 
	} 
}
public class PythonCourseFactory implements ICourseFactory { 
	public ICourse create() { 
		return new PythonCourse(); 
	} 
}

3.测试代码

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

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

抽象工厂模式

抽象工厂模式(Abastract Factory Pattern)是指提供一个创建一系列相关或相互依赖 对象的接口,无须指定他们具体的类。客户端(应用层)不依赖于产品类实例如何被创 建、实现等细节,强调的是一系列相关的产品对象(属于同一产品族)一起使用创建对 象需要大量重复的代码。需要提供一个产品类的库,所有的产品以同样的接口出现,从 而使客户端不依赖于具体实现。

在这里插入图片描述
以课程为例,学院第三期课程有了新的标准,每个课程不仅要提供课程的录播视频,而且还要提供老师的课堂笔记。相 当于现在的业务变更为同一个课程不单纯是一个课程信息,要同时包含录播视频、课堂笔记甚至还要提供源码才能构成一个完整的课程。

1.在产品等级中增加两个产品 IVideo 录播视频和 INote 课堂笔记。

//INote 接口:
public interface INote { 
	void edit(); 
}
//IVideo 接口:
public interface IVideo { 
	void record(); 
}

2.然后创建一个抽象工厂 CourseFactory 类:

/*** 抽象工厂是用户的主入口
 * 在 Spring 中应用得最为广泛的一种设计模式 
 * * 易于扩展
 */
 public interface CourseFactory { 
 	INote createNote(); 
 	IVideo createVideo(); 
 }

3.创建 Java 产品族,Java 视频 JavaVideo 类:

public class JavaVideo implements IVideo { 
	public void record() { 
		System.out.println("录制 Java 视频"); 
	} 
}

4.扩展产品等级Java课堂笔记JavaNote类:

public class JavaNote implements INote { 
	public void edit() { 
		System.out.println("编写 Java 笔记"); 
	} 
}

5.创建 Java 产品族的具体工厂 JavaCourseFactory

public class JavaCourseFactory implements CourseFactory {
 	public INote createNote() { 
 		return new JavaNote(); 
 	}
 	public IVideo createVideo() { 
 		return new JavaVideo(); 
 	} 
 }

6…然后创建 Python 产品,Python 视频 PythonVideo 类:

public class PythonVideo implements IVideo { 
	public void record() { 
		System.out.println("录制 Python 视频");
	 } 
}

7.扩展产品等级 Python 课堂笔记 PythonNote 类:

public class PythonNote implements INote { 
	public void edit() { 
		System.out.println("编写 Python 笔记");
	} 
}

8.创建 Python 产品族的具体工厂 PythonCourseFactory:

public class PythonCourseFactory implements CourseFactory { 
	public INote createNote() { 
		return new PythonNote();
	}
	public IVideo createVideo() { 
		return new PythonVideo(); 
	} 
}

9.客户端调用

public static void main(String[] args) { 
	JavaCourseFactory factory = new JavaCourseFactory(); 
	factory.createNote().edit(); 
	factory.createVideo().record(); 
}

上面的代码完整地描述了两个产品族 Java 课程和 Python 课程,也描述了两个产品等级视频和手记。抽象工厂非常完美清晰地描述这样一层复杂的关系。但是,如果我们再继续扩展产品等级,将源码 Source 也加入到课程中,那么我们的代码从抽象工厂,到具体工厂要全部调整,很显然不符合开闭原则。因此抽象工厂也是有缺点的:
1、规定了所有可能被创建的产品集合,产品族中扩展新的产品等级困难,需要修改抽象工 厂的接口。
2、增加了系统的抽象性和理解难度。

但在实际应用中,我们千万不能犯强迫症甚至有洁癖。在实际需求中产品等级结构升级 是非常正常的一件事情。我们可以根据实际情况,只要不是频繁升级,可以不遵循开 闭原则。

评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符 “速评一下”
©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页