简单工厂模式
是指由一个工厂对象决定创建哪一种产品类的实例,但是它不属于23种设计模式之一。
适用场景
适用于工厂类负责创建的对象较少的场景,且客户端只需要传入工厂类的参数,对于如何创建对象不需要关注。
测试案例
package test20;
/**
* 课程接口
*/
public interface ICourse {
//录制视频
void record();
}
package test20;
/**
* java课程类
*/
public class JavaCourse implements ICourse {
@Override
public void record() {
System.out.println("录制Java课程");
}
}
package test20;
/**
* python课程类
*/
public class PythonCourse implements ICourse {
@Override
public void record() {
System.out.println("录制python课程");
}
}
package test20;
/**
* 课程 工厂类
*/
public class CourseFactory {
public static ICourse create(Class<? extends ICourse> clazz){
try{
if(null != clazz){
return clazz.newInstance();
}
}catch (Exception e){
e.printStackTrace();
}
return null;
}
}
package test20;
public class Main {
public static void main(String[] args) {
ICourse course = CourseFactory.create(JavaCourse.class);
course.record();
ICourse pyCourse = CourseFactory.create(PythonCourse.class);
pyCourse.record();
}
}
运行结果如下:
应用案例
工厂方法模式
定义一个创建对象的接口,让实现这个接口的类来决定实例化哪个类,工厂方法模式让类的实例化推迟到子类中进行。
在工厂方法模式中用户只需要关心所需产品 对应的工厂,无须关注创建细节,而且加入新的产品时符合开闭原则。
主要解决产品扩展的问题,因此对工厂本身也做一个抽象。
适用场景
- 创建对象需要大量重复的代码
- 客户端不依赖产品类实例如何被创建、如何被实现等细节
- 一个类通过其子类来指定创建哪个对象
测试案例
- 课程接口及其实现
package test21;
/**
* 课程接口
*/
public interface ICourse {
//录制视频
void record();
}
package test21;
/**
* java课程类
*/
public class JavaCourse implements ICourse {
@Override
public void record() {
System.out.println("录制Java课程");
}
}
package test21;
/**
* python课程类
*/
public class PythonCourse implements ICourse {
@Override
public void record() {
System.out.println("录制python课程");
}
}
- 工厂接口及其实现
package test21;
/**
* 工厂接口
*/
public interface ICourseFactory {
//创建工厂方法
ICourse create();
}
package test21;
/**
* Java工厂
*/
public class JavaCourseFactory implements ICourseFactory {
@Override
public ICourse create() {
return new JavaCourse();
}
}
package test21;
/**
* Python工厂
*/
public class PythonCourseFactory implements ICourseFactory {
@Override
public ICourse create() {
return new PythonCourse();
}
}
- 测试类
package test21;
public class Main {
public static void main(String[] args) {
ICourseFactory factory = new JavaCourseFactory();
ICourse course = factory.create();
course.record();
ICourseFactory factory1 = new PythonCourseFactory();
ICourse course1 = factory1.create();
course1.record();
}
}
- 运行结果如下:
应用案例
缺点
- 类的个数容易过多,增加复杂性
- 增加了系统的抽象性和理解难度
抽象工厂模式
是指提供一个创建一系列相关或相互依赖对象的接口,无须指定它们的具体类。客户端不依赖产品类实例如何被创建,如何被实现等细节。
适用场景
强调一系列相关的产品对象(属于同一个产品族)一起使用创建对象需要大量重复的代码。需要提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖具体实现。
测试案例
- 课程接口及其实现
package test22;
/**
* 笔记接口
*/
public interface INote {
void edit();
}
package test22;
/**
* 视频接口
*/
public interface IVideo {
void record();
}
package test22;
public class JavaNote implements INote {
@Override
public void edit() {
System.out.println("编写Java笔记");
}
}
package test22;
public class JavaVideo implements IVideo {
@Override
public void record() {
System.out.println("java视频");
}
}
package test22;
public class PythonNote implements INote {
@Override
public void edit() {
System.out.println("Python笔记");
}
}
package test22;
public class PythonVideo implements IVideo {
@Override
public void record() {
System.out.println("python视频");
}
}
- 工厂接口及其实现
package test22;
/**
* 工厂接口
*/
public interface CourseFactory {
INote createNode();
IVideo createVideo();
}
package test22;
/**
* Java产品族的工厂
*/
public class JavaCourseFactory implements CourseFactory {
@Override
public INote createNode() {
return new JavaNote();
}
@Override
public IVideo createVideo() {
return new JavaVideo();
}
}
package test22;
public class PythonCourseFactory implements CourseFactory {
@Override
public INote createNode() {
return new PythonNote();
}
@Override
public IVideo createVideo() {
return new PythonVideo();
}
}
- 测试类
package test22;
public class Main {
public static void main(String[] args) {
CourseFactory factory = new JavaCourseFactory();
factory.createNode().edit();
factory.createVideo().record();
CourseFactory factory1 = new PythonCourseFactory();
factory1.createNode().edit();
factory1.createVideo().record();
}
}
- 运行结果如下
应用案例
数据库连接(例如mysql,oracle)
缺点
- 规定了所有可能被创建的产品集合,产品族中扩展新的产品困难,需要修改抽象工厂的接口
- 增加了系统的抽象性和理解难度