一、简单工厂模式
简单工厂模式(Simple Factory Pattern)是指由一个工厂对象决定创建出哪一种产品类 的实例。属于创建型模式，但它不属于 GOF，23 种设计模式
简单工厂模式适用于的场景：
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中设计模式之一，在工厂方法 模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符 合开闭原则。
/**
* @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 工厂接口
* @Author Bert
* @Date 2019\5\22 0022
*/
public interface ICoureFactory {
ICoure create();
}
/**
* @Description Java方法工厂
* @Author Bert
* @Date 2019\5\22 0022
*/
public class JavaICoureFactory implements ICoureFactory{
@Override
public ICoure create() {
return new JavaCoure();
}
}
/**
* @Description Python方法工厂
* @Author Bert
* @Date 2019\5\22 0022
*/
public class PythonICoureFactory implements ICoureFactory{
@Override
public ICoure create() {
return new PythonCoure();
}
}
/**
* @Description 工厂方法模式测试类
* @Author Bert
* @Date 2019\5\22 0022
*/
public class FactoryMethodTest {
public static void main(String[] args) {
ICoureFactory iCoureFactory = new JavaICoureFactory();
ICoure iCoure = iCoureFactory.create();
iCoure.record();
PythonICoureFactory iCoureFactory1 = new PythonICoureFactory();
ICoure iCoure1 = iCoureFactory1.create();
iCoure1.record();
}
}
类图如下：
工厂方法模式的适用场景：
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();
}
}
抽象工厂模式使用场景：
1、客户端(应用层)不依赖于产品类实例如何被创建，实现等细节。
2、强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量重复的代码。
3、提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体的实现。
抽象工厂模式优点：
1、具体产品在应用层代码隔离，无须关系创建细节。
2、将一个系列的产品族统一到一起创建。
抽象工厂模式缺点：
1、规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口。
2、增加了系统的抽象性和理解难度。
Spring 中用到的抽象工厂模式例如：DefaultListableBeanFactory
扫一扫
365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
