欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

简单工厂模式、工厂模式详解

程序员文章站 2022-06-24 11:57:24
文章目录一、简单工厂模式核心思想案例分析示例改进1改进2改进3一、简单工厂模式核心思想  工厂模式指的是对象实例的使用者不需要该实例是怎么创建的，只需要告诉工厂我要什么，那么工厂就会给你生产对应的对象实例，用于解决创建类的实例出现很多重复代码的场景。案例分析   以课程的类型为例，课程有Java课程、Python课程、C语言课程，假如我们想要获取到课程类型的实例，我们可以这样做:示例package patternsDesign.singleFactory;public interface...

文章目录

一、简单工厂模式

核心思想

  工厂模式指的是对象实例的使用者不需要该实例是怎么创建的，只需要告诉工厂我要什么，那么工厂就会给你生产对应的对象实例，用于解决创建类的实例出现很多重复代码的场景。

案例分析

   以课程的类型为例，课程有Java课程、Python课程、C语言课程，假如我们想要获取到课程类型的实例，我们可以这样做:

示例

package patternsDesign.singleFactory;

public interface ICourse {
    //录制课程
    void record();
}

java:

package patternsDesign.singleFactory;

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

python:

package patternsDesign.singleFactory;

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

客户端代码:

package patternsDesign.singleFactory;

public class Client {

    public static void main(String[] args) {
        ICourse java = new JavaCourse();
        java.record();
        ICourse python = new PythonCourse();
        python.record();
    }
}

随着业务增加，还有web课程、c#课程等，那么就需要对之前的代码进行修改，代码量会大大的增加，后期维护难度较大。

改进1 通过工厂方法来创建实例

package patternsDesign.singleFactory;

import javafx.scene.SubScene;

// 通过输入实例的名称来创建实例
public class Factory {


    public static ICourse create(String name) {
        if ("java".equals(name)) {
            return new JavaCourse();
        } else if ("python".equals(name)) {
            return new PythonCourse();
        }
        return null;
    }

    public static void main(String[] args) {
        Factory factory = new Factory();
        ICourse course = factory.create("java");
        System.out.println(course);
        ICourse python = factory.create("python");
        System.out.println(python);
    }
}

上述方式，完成了只需要告诉Factory需要啥，就能够给你new一个啥，传的方式为字符串，此方式的优点在一定程度上解决客户端的调用问题，让调用变的更简单，但是问题来了，如果随着业务的增加，那么Factory 的create()方法又需要继续修改，因此我们可以选择使用反射技术，通过反射动态的创建实例。

改进2 通过反射技术创建实例

目录结构为:
简单工厂模式、工厂模式详解

package patternsDesign.singleFactory;

// 通过反射来创建实例
public class ReflectionFactory {


    public ICourse create(String name) {
        if (!(null == name || "" == name)) {
            try {
                return (ICourse) Class.forName(name).newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public static void main(String[] args) {
        ReflectionFactory factory = new ReflectionFactory();
        //D:\maven_workspace\software_architecture_study\src\main\java\patternsDesign\singleFactory\JavaCourse.java
        //  类名需要在src//main//java后的绝对路径
        ICourse java = factory.create("patternsDesign.singleFactory.JavaCourse");
        ICourse python = factory.create("patternsDesign.singleFactory.PythonCourse");
        System.out.println(java);
        System.out.println(python);

    }
}

通过使用反射的类加载机制，我们发现代码量维护工作量明显的减少，是非常不错的选择，有一点不足是，需要每次输入类的路径来加载类

改进3 通过泛型来优化

package patternsDesign.singleFactory;

// 通过反射来创建实例,通过类名.class来创建实例
public class ImproveReflectionFactory {


    public ICourse create(Class<? extends ICourse> clazz) {
        if (null != clazz) {
            try {
                return clazz.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public static void main(String[] args) {
        ImproveReflectionFactory factory = new ImproveReflectionFactory();
        ICourse java = factory.create(JavaCourse.class);
        System.out.println(java);
        ICourse python = factory.create(PythonCourse.class);
        System.out.println(python);
    }
}

每次我们只需要传入类.class就能够完成创建实例，此方式是简单工厂模式的优化版，适用于对象数量少，场景不复杂的情况。

二、工厂模式

核心思想

   简单工厂模式对于处理单一的产品是比较友好的，随着同一类型的产品逐渐增多，如果每个课程的创建逻辑有区别, 那么简单工厂的职责就会变的非常多，不利于维护。

代码实现

   建立一个抽象工厂，另外Java课程的实例以及相关逻辑由Java工厂进行生产，Python课程的实例以及相关逻辑由python工厂来负责。

  1. 工厂抽象类 CourseFactory:
package patternsDesign.factory;

public interface CourseFactory {
    ICourse create();
}
  1. 课程抽象类ICourse：
package patternsDesign.factory;

public interface ICourse {

    //录制课程
    void record();

    //直播
    void live();
}
  1. Java工厂和Python工厂
    用来创建课程的实例
package patternsDesign.factory;

public class JavaFactory implements CourseFactory {

    public ICourse create() {
        return new JavaCourse();
    }
}


package patternsDesign.factory;

public class PythonFactory implements CourseFactory {

    public ICourse create() {
        return new PythonCourse();
    }
}
  1. Java课程和Python课程类
    用来处理与课程相关的业务逻辑
package patternsDesign.factory;

public class JavaCourse implements ICourse {

    public void record() {
        System.out.println("录制java课程! ");
    }

    public void live() {
        System.out.println("java直播课!");
    }
}


package patternsDesign.factory;

public class PythonCourse implements ICourse {


    public void record() {
        System.out.println("录制python课程!");
    }

    public void live() {
        System.out.println("python直播课!");
    }
}
  1. 客户端
package patternsDesign.factory;

public class client {

    public static void main(String[] args) {
        //获取java工厂
        CourseFactory javaFactory = new JavaFactory();
        ICourse java = javaFactory.create();
        java.record();
        java.live();

        //获取Python工厂
        CourseFactory pythonFactory = new PythonFactory();
        ICourse python = pythonFactory.create();
        python.record();
        python.live();

    }
}

工厂模式解决了简单工厂模式不可扩展的问题，符合开闭原则，有利于开发人员维护。

本文地址：https://blog.csdn.net/qq_33036061/article/details/110915384

相关标签： 软件架构和设计模式 简单工厂模式 java 工厂模式

上一篇： php使用lua+redis实现限流，计数器模式，令牌桶模式

下一篇： CSS常用布局二（flex布局）

推荐阅读