当前位置: 开发笔记 > 编程语言 > 正文

创建型模式————工厂模式（2.2）

作者：秋林学士_809 | 来源：互联网 | 2023-09-02 15:21

创建型模式————工厂模式（2.2）,Go语言社区,Golang程序员人脉社

什么是工厂模式？

工厂模式是创建型模式的一种，工厂是用来生产的，而在Java里，是用来生产对象实例的。

和单例模式相似，工厂模式同样聚焦于在考虑整个软件构建的情况下合理创建对象，从而保证软件的扩展性和稳定性。

工厂模式分为三种：

简单工厂模式
工厂方法模式
抽象工厂模式

简单工厂模式（实现服务端自扩展）

服务端：提供代码的人（作者）

客户端：使用代码的人（用户）

【对于程序员来说，自己是作者，用户是普通人；那么对于发明语言,框架的人来说，创建者是作者，而普通程序员是用户】

假设没有使用简单工厂模式：

定义一个Coder接口，然后定义JavaCoder和PythonCoder实现Coder接口。客户端通过new来创建对象。（耦合）

//服务端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}

//===============================================================================
public class ProductManager     //客户端
{
    public static void main(String[] args) {

        Coder javaCoder = new JavaCoder();
        javaCoder.express();

        
    }



}

当服务端需要扩展一个类时：需要进行1,2两步

//服务端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder    //1.服务端扩展
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}
//===============================================================================
public class ProductManager     //客户端
{
    public static void main(String[] args) {

        Coder javaCoder = new JavaCoder();
        javaCoder.express();

        Coder goCoder = new GoCoder();   //2.客户端跟着修改
        goCoder.express();
    }



}

服务端和客户端处于高度耦合状态。（服务端的变化会引起客户端的变化）

使用简单工厂模式：（如果服务端要扩展一个GoCoder，客户端无需做修改）

//服务端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder    //1.服务端扩展
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}

class SimpleFactory
{

    //使用静态内部类实现单例模式
    private static class StaticClassInnerInstance {
        private static final SimpleFactory INSTANCE = new SimpleFactory();
    }
    

    public static SimpleFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    public Coder createCoder(String language)
    {
        Coder coder = null;
        if(language.equals("Java"))
        {
            coder= new JavaCoder();

        }
        else if(language.equals("Python"))
        {
            coder= new PythonCoder();
        }
        else if(language.equals("Go"))  //2.扩展条件
        {
            coder= new GoCoder();
        }
        return coder;
    }
}
//===============================================================================
public class ProductManager     //客户端
{

    public static void main(String[] args) {

        SimpleFactory factory = SimpleFactory.getInstance();
        Coder javaCoder = factory.createCoder("Java");
        javaCoder.express();


    }



}

简单工厂UML类图：

1565531609458

简单工厂的优缺点:

优点：

解决了服务端与客户端的耦合问题，实现了服务端的自扩展。

缺点：

当客户端需要进行功能扩展时，无法在SimpleFactory中添加对应修改代码。

简单工厂可以完成服务端的自扩展，但客户端只能调用，无法扩展。

工厂方法模式（实现客户端自扩展）

//服务端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder    //1.服务端扩展
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}

interface CoderFactory   //抽象出CoderFactory
{
    public Coder createCoder(String language);
}

class ServerFactory implements CoderFactory
{

    private static class StaticClassInnerInstance {
        private static final ServerFactory INSTANCE = new ServerFactory();
    }

    public static ServerFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    @Override
    public Coder createCoder(String language)
    {
        Coder coder = null;
        if(language.equals("Java"))
        {
            coder= new JavaCoder();

        }
        else if(language.equals("Python"))
        {
            coder= new PythonCoder();
        }
        else if(language.equals("Go"))  //2.扩展条件
        {
            coder= new GoCoder();
        }
        return coder;
    }
}
//===============================================================================

class RustCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Rust Coder");

    }
}

class ClientFactory implements CoderFactory
{
    private static class StaticClassInnerInstance1 {
        private static final ClientFactory INSTANCE = new ClientFactory();
    }

    public static ClientFactory getInstance() {
        return ClientFactory.StaticClassInnerInstance1.INSTANCE;
    }

    @Override
    public Coder createCoder(String language)
    {

        return new RustCoder();
    }
}

public class ProductManager     //客户端
{

    public static void main(String[] args) {

       ClientFactory clientFactory = ClientFactory.getInstance();
       Coder coder = clientFactory.createCoder("Rust");
       coder.express();
    }
}

工厂方法UML类图：

1565532368140

工厂方法模式的优缺点：

优点：实现了客户端的自扩展。

缺点：无法扩展多个产品。

抽象工厂模式（实现产品簇）

适应多个产品，加入设计师。

抽象工厂中可以生产多个产品，产品之间存在内在联系。比如说JavaCoder对应JavaDesigner。

而实例化的工厂就是根据这种内在联系来划分的。

同一个工厂的产品属于一个产品簇，不同产品簇之间是不能互相组合的。比如说GoDesigner和PythonCoder是不能组合到一个工厂里的。

//服务端
interface Coder {

    void express();
}
interface Designer {

    void express();
}


class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}

class JavaDesigner implements Designer
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Designer!");

    }
}
class PythonDesigner implements Designer
{
    @Override
    public void express()
    {
        System.out.println("I am a Python Designer!");

    }
}
class GoDesigner implements Designer
{
    @Override
    public void express()
    {
        System.out.println("I am a Go Designer!");

    }
}

interface ProductFactory
{
    public Coder createCoder();
    public Designer createDesigner();

}

class GoFactory implements ProductFactory
{

    private static class StaticClassInnerInstance {
        private static final GoFactory INSTANCE = new GoFactory();
    }

    public static GoFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    @Override
    public Coder createCoder()
    {

            Coder coder= new GoCoder();

        return coder;
    }
    @Override
    public Designer createDesigner()
    {
        Designer designer= new GoDesigner();

        return designer;
    }

}

class JavaFactory implements ProductFactory
{

    private static class StaticClassInnerInstance {
        private static final JavaFactory INSTANCE = new JavaFactory();
    }

    public static JavaFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    @Override
    public Coder createCoder()
    {

        Coder coder= new JavaCoder();

        return coder;
    }
    @Override
    public Designer createDesigner()
    {
        Designer designer= new JavaDesigner();

        return designer;
    }

}
//===============================================================================



public class ProductManager     //客户端
{

    public static void main(String[] args) {
        JavaFactory javaFactory = JavaFactory.getInstance();
        Coder coder =javaFactory.createCoder();
        Designer designer = javaFactory.createDesigner();
        coder.express();
        designer.express();




    }



}

抽象工厂UML类图：

1565533010264

工厂模式总结
简单工厂模式：适用客户端无需扩展的应用场景

工厂方法模式：适合客户端创建单个产品的应用场景

抽象工厂模式：适合创建多个产品的应用场景（但产品类别需要固定）

-------------------------------------------------------------------------------------------------------------2019.8.11

推荐阅读

select
Java 15 发布，带来多项重要更新！

2020年9月15日，Oracle正式发布了最新的JDK 15版本。本次更新带来了许多新特性，包括隐藏类、EdDSA签名算法、模式匹配、记录类、封闭类和文本块等。 ... [详细]

蜡笔小新 2024-11-14 12:11:09
byte
Java 9 及以上版本中 String 类为何使用 byte[] 而非 char[]?

传统上，Java 的 String 类一直使用 char 数组来存储字符数据。然而，在 Java 9 及更高版本中，String 类的内部实现改为使用 byte 数组。本文将探讨这一变化的原因及其带来的好处。 ... [详细]

蜡笔小新 2024-11-14 18:40:52
utf-8
Spring Data JdbcTemplate 入门指南

本文将介绍如何使用 Spring JdbcTemplate 进行数据库操作，包括查询和插入数据。我们将通过一个学生表的示例来演示具体步骤。 ... [详细]

蜡笔小新 2024-11-14 10:33:29
search
Java反射机制详解及应用场景

本文详细介绍了Java反射机制的基本概念、获取Class对象的方法、反射的主要功能及其在实际开发中的应用。通过具体示例，帮助读者更好地理解和使用Java反射。 ... [详细]

蜡笔小新 2024-11-13 16:08:08
select
Java DAO模式详解与代码示例

DAO（Data Access Object）模式是一种用于抽象和封装所有对数据库或其他持久化机制访问的方法，它通过提供一个统一的接口来隐藏底层数据访问的复杂性。 ... [详细]

蜡笔小新 2024-11-13 12:25:33
get
Java高并发与多线程（二）：线程的实现方式详解

本文将深入探讨Java中线程的三种主要实现方式，包括继承Thread类、实现Runnable接口和实现Callable接口，并分析它们之间的异同及其应用场景。 ... [详细]

蜡笔小新 2024-11-12 14:31:23
express
Java设计模式详解：解释器模式的应用与实现

本文详细介绍了Java设计模式中的解释器模式，包括其定义、应用场景、优缺点以及具体的实现示例。通过音乐解释器的例子，帮助读者更好地理解和应用这一模式。 ... [详细]

蜡笔小新 2024-11-14 21:00:34
utf-8
使用Python爬取妙笔阁小说信息并保存为TXT和CSV格式

本文介绍了如何使用Python爬取妙笔阁小说网仙侠系列中所有小说的信息，并将其保存为TXT和CSV格式。主要内容包括如何构造请求头以避免被网站封禁，以及如何利用XPath解析HTML并提取所需信息。 ... [详细]

蜡笔小新 2024-11-14 19:54:58
search
Android Studio SQLite 数据库增删改查简单（代码参考）

一个建表一个执行crud操作建表代码importandroid.content.Context;importandroid.database.sqlite.SQLiteDat ... [详细]

蜡笔小新 2024-11-14 11:01:49
search
Python基础：使用NLTK和Python构建机器学习应用

本文节选自《NLTK基础教程——用NLTK和Python库构建机器学习应用》一书的第1章第1.2节，作者Nitin Hardeniya。本文将带领读者快速了解Python的基础知识，为后续的机器学习应用打下坚实的基础。 ... [详细]

蜡笔小新 2024-11-13 21:23:34
char
Java初学者必备的六大核心知识点

本文总结了Java初学者需要掌握的六大核心知识点，帮助你更好地理解和应用Java编程。无论你是刚刚入门还是希望巩固基础，这些知识点都是必不可少的。 ... [详细]

蜡笔小新 2024-11-13 18:24:59
import
Spring – Bean Life Cycle

Spring – Bean Life Cycle ... [详细]

蜡笔小新 2024-11-13 13:24:40
byte
面试中如何回答“零拷贝”技术问题？

零拷贝技术是提高I/O性能的重要手段，常用于Java NIO、Netty、Kafka等框架中。本文将详细解析零拷贝技术的原理及其应用。 ... [详细]

蜡笔小新 2024-11-13 02:03:52
import
Java 并发编程：深入解析 AtomicInteger 和 CAS 无锁算法

在多线程并发环境中，普通变量的操作往往是线程不安全的。本文通过一个简单的例子，展示了如何使用 AtomicInteger 类及其核心的 CAS 无锁算法来保证线程安全。 ... [详细]

蜡笔小新 2024-11-12 16:40:04
get
PHP 对象生命周期与内存管理

本文详细介绍了 PHP 中对象的生命周期、内存管理和魔术方法的使用，包括对象的自动销毁、析构函数的作用以及各种魔术方法的具体应用场景。 ... [详细]

蜡笔小新 2024-11-12 13:35:26

秋林学士_809

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章