JAVA 设计模式之工厂模式详解

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

一、简单工厂模式

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

（参考资料： http://en.wikipedia.org/wiki/Design_Patterns#Patterns_by_Type）。

简单工厂模式适用于的场景：

1、适用于工厂类负责创建的对象较少的场景，

2、且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。

简单工厂模式缺点：

1、工厂类的职业相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背开闭原则

2、不易于扩展过于复杂的产品结构

下面手写一个简单的工厂模式

/**
* @Description 需要实现的接口
* @Author Bert
* @Date 2019\5\21
*/
public interface ICoure {
public void record();
}/**
* @Description 实现ICoure
* @Author Bert
* @Date 2019\5\21 0021
*/
public class JavaCoure implements ICoure { @Override
public void record() {
System.out.println("录制Java课程!");
}
}/**
* @Description 工厂类将类的创建过程封装到工厂里面
* @Author Bert
* @Date 2019\5\21 0021
*/
public class CourseFactory {
/**
* @Description 通过name判断，创建对应的对象
* @Date 2019\5\21 0021 23:05
* @Param [name]
* @return com.bert.simple.factory.ICoure
*/
public ICoure create(String name){
if("Java".equals(name))
return new JavaCoure();
if("Python".equals(name))
return new PythonCoure();
else
return null;
}
/**
* @Description //通过类的全路径
* @Date 2019\5\21 0021
* @Param [className]
* @return com.bert.simple.factory.ICoure
*/
public ICoure create1(String className){
try {
if( null != className && !"".equals(className)){
return (ICoure)Class.forName(className).newInstance();
}
}catch (Exception e){
e.printStackTrace();
}
return null;
} /**
* @Description 传入一个Class，可以避免输入错误的内容
* @Date 2019\5\21 0021
* @Param [clazz]
* @return com.bert.simple.factory.ICoure
*/
public ICoure create2(Class clazz){
if (null != clazz) {
try {
return (ICoure) clazz.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
}/**
* @Description 测试类
* @Author Bert
* @Date 2019\5\21 0021
*/
public class SimpleFactoryTest { public static void main(String[] args) {
CourseFactory factory = new CourseFactory();
/**
* 通过简单的工厂创建
*/
ICoure iCoure = factory.create("Java");//方式1
iCoure.record(); ICoure factory1 = factory.create1("com.bert.simple.factory.JavaCoure");//方式2
factory1.record(); ICoure factory2 = factory.create2(JavaCoure.class);//方式3
factory2.record(); }
}

简单工厂模式在 JDK 源码也是无处不在现在我们来举个例子：

/* 里面通过createCalendar(TimeZone zone, Locale aLocale)传入时区、语言创建不同时区的时间 */
Calendar calendar = Calendar.getInstance();/* getInstance()是一个工厂模式，也是一个单例模式 *///Calendar 源码
public static Calendar getInstance()
{
return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
} /* getLogger(Class<?> clazz) 典型的工厂模式 */
Logger logger = LoggerFactory.getLogger(SimpleFactoryTest.class);/*也是一个单例*///LoggerFactory源码public static Logger getLogger(Class<?> clazz) {
Logger logger = getLogger(clazz.getName());
if (DETECT_LOGGER_NAME_MISMATCH) {
Class<?> autoComputedCallingClass = Util.getCallingClass();
if (autoComputedCallingClass != null && nonMatchingClasses(clazz, autoComputedCallingClass)) {
Util.report(String.format("Detected logger name mismatch. Given name: \"%s\"; computed name: \"%s\".", logger.getName(), autoComputedCallingClass.getName()));
Util.report("See http://www.slf4j.org/codes.html#loggerNameMismatch for an explanation");
}
} return logger;
}

二、工厂方法模式

工厂方法模式（Fatory Method Pattern）是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。属于创建型模式，23中设计模式之一，在工厂方法模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符合开闭原则。

类图如下：

工厂方法模式的适用场景：

1、创建对象需要大量重复的代码

2、客户端（应用层）不依赖于产品类实例如何被创建、实现等细节，一个类通过其子类来指定创建哪个对象。

工厂方法模式的优点：

1、用户只关系所需产品对应的工厂，无须关心创建细节。

2、加入新产品符合开闭原则，提高了系统的可扩展性。

工厂方法模式的缺点：

1、类的个数容易过多，增加了代码结构的复杂度。

2、增加了系统的抽象性和理解难度。

三、抽象工厂模式

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

属于创建型设计模式。

/**
* @Description 需要实现的接口
* @Author Bert
* @Date 2019\5\21
*/
public interface ICoure {
public void record();
}/**
* @Description 实现ICoure
* @Author Bert
* @Date 2019\5\21 0021
*/
public class JavaCoure implements ICoure { @Override
public void record() {
System.out.println("录制Java课程!");
}
}/**
* @Description TODO
* @Author Bert
* @Date 2019\5\21 0021
*/
public class PythonCoure implements ICoure { @Override
public void record() {
System.out.println("录制Python课程!");
}
}/**
* @Description 要求所有的工厂都实现这个工厂
* 一个品牌的抽象
* 1、抽象工厂不符合开闭原则（在顶层接口中添加的抽象方法，在继承他的类都需要继承）
* 2、扩展性强
* @Author Bert
* @Date 2019\5\22 0022
*/
public interface ICouseeFactory { ICoure createCourse(); Inote createNote(); Ivideo createVideo();}/**
* @Description TODO
* @Author Bert
* @Date 2019\5\22 0022
*/
public interface Inote {}/**
* @Description TODO
* @Author Bert
* @Date 2019\5\22 0022
*/
public interface Ivideo {}/**
* @Description TODO
* @Author Bert
* @Date 2019\5\22 0022
*/
public class JavaNote implements Inote{
}/**
* @Description TODO
* @Author Bert
* @Date 2019\5\22 0022
*/
public class JavaVideo implements Ivideo {
}/**
* @Description TODO
* @Author Bert
* @Date 2019\5\22 0022
*/
public class PythonNote implements Inote {
}/**
* @Description TODO
* @Author Bert
* @Date 2019\5\22 0022
*/
public class PythonVideo implements Ivideo {
}/**
* @Description JAVA 课程实现
* @Author Bert
* @Date 2019\5\22 0022
*/
public class JavaCourseFactory implements ICouseeFactory { @Override
public ICoure createCourse() {
return new JavaCoure();
} @Override
public Inote createNote() {
return new JavaNote();
} @Override
public Ivideo createVideo() {
return new JavaVideo();
}
}/**
* @Description Python课程实现
* @Author Bert
* @Date 2019\5\22 0022
*/
public class PythonCourseFactory implements ICouseeFactory { @Override
public ICoure createCourse() {
return new PythonCoure();
} @Override
public Inote createNote() {
return new PythonNote();
} @Override
public Ivideo createVideo() {
return new PythonVideo();
}
}/**
* @Description 抽象工厂测试类
* @Author Bert
* @Date 2019\5\22 0022
*/
public class AbstactFactoryTest {
public static void main(String[] args) { ICouseeFactory factory = new JavaCourseFactory();
factory.createCourse().record();
factory.createNote();
factory.createVideo(); }
}