简单工厂模式
- 定义
用户输入产品的名称，工厂通过产品名称负责生产具体的产品。
-
类图
简单工厂模式的主要思想是定义一个工厂类，提供一个创建产品的方法，参数为产品名称，通过case分支实现不同产品的实现。客户端只需要知道产品的名称即可得到对应的产品对象。
SimpleFactory.png 具体实现
package com.tomas.simpleFactory;
//通过指定产品名称和产品类的class实现创建产品
public class CourseFactory {
public ICourse createCourse(String courseName) {
if("Java".equals(courseName)){
return new JavaCourse();
}else if("Python".equals(courseName)){
return new PythonCourse();
}
//基于className的反射实现
// if(!( courseName == null || "".equals(courseName))){
// Class clazz = null;
// try {
// clazz = Class.forName(courseName);
// return (ICourse) clazz.newInstance();
//
// } catch (Exception e) {
// e.printStackTrace();
// }
// }
return null;
}
//基于class的反射实现
public ICourse createCourse(Class <? extends ICourse> clazz) {
try {
return clazz.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
package com.tomas.simpleFactory;
public interface ICourse {
void record();
}
package com.tomas.simpleFactory;
public class JavaCourse implements ICourse {
@Override
public void record() {
System.out.println("Java");
}
}
package com.tomas.simpleFactory;
public class PythonCourse implements ICourse {
@Override
public void record() {
System.out.println("Python");
}
}
package com.tomas.simpleFactory;
public class Test {
public static void main(String[] args) {
ICourse course = new CourseFactory().createCourse("Java");
course.record();
ICourse course1 = new CourseFactory().createCourse(JavaCourse.class);
course1.record();
}
}
- 应用场景
适用于产品比较少并且比较稳定的场景，例如Java中的
Calendar createCalendar(TimeZone zone,Locale aLocale) - 优缺点
优点：
- 应用程序只需要和工厂类交互就可以获得产品，不需要主动去实例化，实现了代码的解耦。
缺点： - 名字严格区分大大小写，名字如果传错，无法生产出产品。可以使用反射的方式解决。
- 如果产品频繁增加或者变化，需要修改源码，不符合开闭原则。
工厂方法模式
- 定义
一个创建对象的接口，由具体的实现类决定创建哪个产品。每个工厂只负责生产单一的一种产品。
-
类图
工厂方法的主要思想是，创建一个抽象工厂，定义一个抽象产品，抽象工厂提供一个抽象创建方法来创建抽象产品。具体这个创建方法创建出来什么产品，由具体的工厂决定。这样，每一个产品只用来创建一种具体产品。
MethodFactory.png 具体实现
package com.tomas.factoryMethod;
public interface ICourse {
void record();
}
public interface ICourseFactory {
ICourse create();
}
package com.tomas.factoryMethod;
public class JavaCourse implements ICourse {
@Override
public void record() {
System.out.println("Java");
}
}
package com.tomas.factoryMethod;
public class JavaCourseFactory implements ICourseFactory {
@Override
public ICourse create() {
return new JavaCourse();
}
}
package com.tomas.factoryMethod;
public class PythonCourse implements ICourse {
@Override
public void record() {
System.out.println("Python");
}
}
package com.tomas.factoryMethod;
public class PythonCourseFactory implements ICourseFactory {
@Override
public ICourse create() {
return new PythonCourse();
}
}
public class Test {
public static void main(String[] args) {
ICourseFactory javaCourseFactory = new JavaCourseFactory();
javaCourseFactory.create().record();
ICourseFactory pythonCourseFactory = new PythonCourseFactory();
pythonCourseFactory.create().record();
}
}
- 应用场景
一个类通过其子类决定具体的实现。
客户端不依赖产品对象的创建细节。 - 优缺点
当需要增加新的产品的时候，可以通过增加产品具体工厂和具体产品的方式进行扩展，符合开闭原则。但是这样也带来来类数量的剧增，增加类复杂度。
抽象工厂模式
- 定义
为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们 的具体类。
-
类图
抽象工厂模式是工厂方法模式的延伸，其思想是，定义一个抽象工厂，里面有多个创建方法用于创建不同的产品。客户端不依赖具体的产品创建和实现。
这里面的多个产品放在一起叫做产品族。通过具体的工厂来实现具体产品的创建。例如美的工厂生产冰箱、彩电。格力工厂也生产冰箱、彩电。冰箱和彩电放一起就是产品族。
AbstractFactory.png 具体实现
package com.tomas.AbstractFactory;
public abstract class AbstractCourseFactory {
protected abstract INote createNote();
protected abstract IVideo createVideo();
}
package com.tomas.AbstractFactory;
public interface INote {
void note();
}
package com.tomas.AbstractFactory;
public interface IVideo {
void video();
}
package com.tomas.AbstractFactory;
public class JavaCourseFactory extends AbstractCourseFactory {
@Override
protected INote createNote() {
return new JavaNote();
}
@Override
protected IVideo createVideo() {
return new JavaVideo();
}
}
package com.tomas.AbstractFactory;
public class JavaNote implements INote {
@Override
public void note() {
System.out.println("Java Note");
}
}
package com.tomas.AbstractFactory;
public class JavaVideo implements IVideo {
@Override
public void video() {
System.out.println("Java Video");
}
}
package com.tomas.AbstractFactory;
public class PythonCourseFactory extends AbstractCourseFactory {
@Override
protected INote createNote() {
return new PythonNote();
}
@Override
protected IVideo createVideo() {
return new PythonVideo();
}
}
package com.tomas.AbstractFactory;
public class PythonNote implements INote {
@Override
public void note() {
System.out.println("Python Note");
}
}
package com.tomas.AbstractFactory;
public class PythonVideo implements IVideo {
@Override
public void video() {
System.out.println("Python Video");
}
}
public class TestAbstractFactory {
public static void main(String[] args) {
AbstractCourseFactory factory = new JavaCourseFactory();
INote note = factory.createNote();
note.note();
IVideo video = factory.createVideo();
video.video();
}
}
- 应用场景
系统中出现产品族，并且每次只使用其中某一种产品族。 - 优缺点
- 能够清晰的描述产品族和产品等级的关系。
- 抽象工厂模式规定了产品族中包含的所有产品，当产品族发生变化的时候，所有的类都要做相应的修改。
- 增加了系统的抽象性和理解难度。
