设计模式---工厂模式

最新推荐文章于 2024-04-12 16:15:11 发布
最新推荐文章于 2024-04-12 16:15:11 发布
阅读量141 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IT_10/article/details/101229784
版权

工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式。

简单工厂模式

该模式对对象创建管理方式最为简单，因为其仅仅简单的对不同类对象的创建进行了一层薄薄的封装。该模式通过向工厂传递类型来指定要创建的对象，其UML类图如下：
在这里插入图片描述
抽象产品和实现：

public interface Product {
    void doSomething();
    void doAnything();
}

public class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ConcreteProductA doAnything");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductB doSomething");

    }

    @Override
    public void doAnything() {
        System.out.println("ConcreteProductB doAnything");
    }
}

工厂类：

public class Creator {
    public static Product createProduct(String type) {
        Product product = null;
        switch (type) {
            case "A":
                product = new ConcreteProductA();
                break;
            case "B":
                product = new ConcreteProductB();
                break;
        }
        return product;
    }
}

测试：

public class Client {

    public static void main(String[] args) {
        Product productA = Creator.createProduct("A");
        productA.doSomething();
        productA.doAnything();
      
        Product productB = Creator.createProduct("B");
        productB.doSomething();
        productB.doAnything();
    }
}

优点：

  • 客户端不需要依赖具体的产品类，只依赖工厂类，传入不同的参数就可以得到不同的对象

缺点：

  • 工厂类的扩展比较困难，每增加一个产品，就要在工厂中添加相应的分支，对扩展开放的同时对修改也开放了，不符合开闭原则

使用场景：

  • 产品种类较少，并且种类需求已确定，比如计算器，已知的运算类型较少并且具体由多少种类型是已知的

工厂方法模式

和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂。也就是定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，将生产任务交给不同的派生类工厂，这样不用通过指定类型来创建对象了。其UML类图如下：
在这里插入图片描述

抽象产品和实现同简单工厂模式

抽象工厂类：

public interface Creator {
    Product createProduct();
}

具体工厂类-生产A产品的工厂：

public class ConcreteCreatorA implements Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

具体工厂类-生产B产品的工厂：

public class ConcreteCreatorB implements Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

测试：

public static void main(String[] args) {
    Creator creatorA = new ConcreteCreatorA();
    Product productA = creatorA.createProduct();
    productA.doSomething();
    productA.doAnything();

    Creator creatorB = new ConcreteCreatorB();
    Product productB = creatorB.createProduct();
    productB.doSomething();
    productB.doAnything();
}

优点：

  • 良好的封装性，代码结构清晰
  • 工厂方法模式的扩展性好
    增加产品类的时候，不用去修改原有工厂类的逻辑，而是直接新建一个工厂类的实现即可
    降低程序间的耦合性

缺点：
每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量

扩展

利用反射机制来解决"每增加一个产品类，就需要增加一个对应的工厂类"的问题
抽象工厂类：

public interface Creator {
    <T extends Product> T createProduct(Class<T> clazz);
}

具体工厂类：

public class ConcreteCreator implements Creator {
    @Override
    public <T extends Product> T createProduct(Class<T> clazz) {
        Product product= null;
        try {
            product = (Product) Class.forName(clazz.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) product;
    }
}

测试：

public class Client {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();

        Product productA = creator.createProduct(ConcreteProductA.class);
        productA.doSomething();
        productA.doAnything();

        Product productB = creator.createProduct(ConcreteProductB.class);
        productB.doSomething();
        productB.doAnything();
    }
}
小结

工厂方法模式是对简单工厂模式的进一步抽象和解耦，避免了简单工厂违背开闭原则的缺点，利用反射机制提高开发效率。

抽象工厂模式

UML如下：
在这里插入图片描述
抽象产品A接口：

public interface ProductA {
    void doSomething();
    void doAnything();
}

抽象产品B接口：

public interface ProductB {
    void doSomething();
    void doAnything();
}

产品A1的具体实现：

public class ConcreteProductA1 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA1 doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ConcreteProductA1 doAnything");
    }
}

产品A2的具体实现：

public class ConcreteProductA2 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA2 doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ConcreteProductA2 doAnything");
    }
}

产品B1的具体实现：

public class ConcreteProductB1 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductB1 doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ConcreteProductB1 doAnything");
    }
}

产品B2的具体实现：

public class ConcreteProductB2 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductB2 doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ConcreteProductB2 doAnything");
    }
}

抽象工厂类：

public interface Creator {
    /**
     * 创建A产品家族
     * @return
     */
    ProductA createProductA();

    /**
     * 创建B产品家族
     * @return
     */
    ProductB createProductB();

    // ...
    // 有N个产品族，在抽象工厂类中就应该有N个创建方法
}

具体工厂类：

public class ConcreteCreator1 implements Creator {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteCreator2 implements Creator {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

//产品种类有多少个，就有多少个实现类

客户端：

public class Client {
    public static void main(String[] args) {
        Creator creator1 = new ConcreteCreator1();

        ProductA productA1 = creator1.createProductA();
        productA1.doSomething();
        productA1.doAnything();

        ProductB productB1 = creator1.createProductB();
        productB1.doSomething();
        productB1.doAnything();

        Creator creator2 = new ConcreteCreator2();

        ProductA productA2 = creator2.createProductA();
        productA2.doSomething();
        productA2.doAnything();

        ProductB productB2 = creator2.createProductB();
        productB2.doSomething();
        productB2.doAnything();
    }
}

JDK源码中的简单抽象工厂模式

jdk8

Calendar类对象的创建就使用了简单抽象工厂模式，对Calendar cal = Calendar.getInstance();这段代码，进入getInstance()方法内部：

public static Calendar getInstance()
{
	//TimeZone就相当于一个工厂类，getDefault()用于获取实例化对象
    return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
}

再进入getDefault()方法内部：

private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
        	//这里就是一个简单工厂模式，根据caltype值的不同返回不同的实例对象
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

总结

  • 工厂模式的意义就在于将实例化对象的代码提取出来，放到一个类（工厂类）中统一管理和维护，达到和主项目依赖关系的解耦，从而提高项目的扩展和维护性。

设计模式中依赖抽象的原则：

  • 创建对象的时候，不要在客户端直接使用new，而是把实例化对象的过程放在一个工厂类中
  • 不要让类继承具体类，而是继承抽象类或者实现接口
  • 不要覆盖类中已经实现的方法
IT_10-
关注
专栏目录
设计模式——抽象工厂模式
姑娘眼中的明月色，就只有你一人，轻轻望去，才能发现。
04-19 1610
1.抽象工厂模式动机 在工厂方法模式中具体工厂负责生产具体的产品,每一个具体工厂对应一种具体产品，工厂方法也具有唯一性，一般情况下，一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象，如一个电器设备工厂，它可以生产电视机、电冰箱、空调等设备,而不只是生成某种类型的电器。 因此我们引入了一个新的设计模式：抽象工厂模式。 抽象工厂模式定义：抽象工厂模式是工厂方法模式的泛化版，工厂方法...
设计模式之工厂模式
Eamon
11-09 830
Define an interface for creating an object, but let subclasses decide which class to insantiate.Factory Method lets a class defer instantiation to subclasses. 定义 定义一个用于创建对象的接口，然子类决定实例化哪一个类。工厂方法使一个类的额实例化延迟到其子类。 工厂方法的通用类图： 工厂方法模式中，抽象产品类Product负责定义产品的共性，实现.
Java 中工厂设计模式，请用代码具体举例
最新发布
u011091199的博客
04-12 368
在这个例子中，Product 接口定义了产品的操作方法 operation()，ConcreteProduct1 和 ConcreteProduct2 是具体的产品类实现了该接口。Factory 接口定义了创建产品的方法 createProduct()，ConcreteFactory1 和 ConcreteFactory2 是具体的工厂类实现了该接口，分别用于创建 ConcreteProduct1 和 ConcreteProduct2。
Java设计模式-工厂模式
Java硬件工程师的博客
02-09 3728
1.概述 需求：设计一个咖啡店点餐系统。 设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。 具体类的设计如下： 在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重(CoffeeStore对AmericanCoffr)，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果
设计模式——创建型设计模式
qq_43935080的博客
06-14 439
文章目录前言创建型设计模式单例模式初始化类时创建单例延迟创建单例简单工厂模式工厂方法模式建造者模式参考资料 前言 这个系列的文章主要总结《Android进阶之光》中关于这23种三大类的设计模式相关知识。 创建型设计模式 这类设计模式与创建对象相关，包括单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。 单例模式 定义：保证一个类只有一个实例，并提供一个访问它的全局访问点 使用场景： 在一个系统中，要求一个类有且仅有一个对象，它的具体使用场景如下： 整个项目需要一个共享访问点或共享数据。 创建一个
c++设计模式-工厂方法模式
06-04
在标题“c++设计模式-工厂方法模式”中，我们关注的是如何在C++中实现工厂方法这一设计模式。工厂方法模式的核心思想是定义一个创建对象的接口，但让子类决定实例化哪一个类。这样，工厂方法可以使类的实例化过程...
设计模式-工厂模式.pdf
04-11
### 设计模式之工厂模式详解 #### 一、概述 工厂模式是一种常用的设计模式，属于创建型模式之一。它的核心思想在于将对象的创建过程封装起来，并通过特定的工厂类来实现对象的创建，以此达到降低系统耦合度的目的...
创建型设计模式---工厂设计模式实现
08-13
创建型设计模式---工厂设计模式实现
JAVA-设计模式-创建型模式-工厂模式
08-10
JAVA-设计模式-创建型模式-工厂模式
创建型设计模式----抽象工厂模式
08-13
抽象工厂模式是创建型设计模式的一种，它提供了一种创建对象族（一组具有相互依赖关系的对象）的方法，而无需指定具体类。这种模式的核心在于它允许客户端代码与具体实现细节解耦，使得更换一个产品族变得更为容易。...
设计模式---工厂模式（Factory）
元勇温的博客
09-27 235
1. 什么是工厂模式？ 工厂模式定义一个创建对象的接口，这个接口决定实例的生成方式，但是并不决定所要生成的具体的类，具体的处理全部交给子类处理。 2. 什么时候使用工厂模式？ 如果需要创建多种对象，同时这些对象又有极大的相似点，可以考虑使用工厂设计模式。 3.怎么使用工厂模式？ 3.1 工厂模式中的角色 Product（产品） Product是一个抽象类，它定义了工厂模式中生成的那些实例所持有...
设计模式创建型——工厂模式
tszc95的博客
04-04 4507
工程模式是通过工厂获取一个一个的新对象。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
设计模式之工厂模式（创建型）
light的博客
06-25 681
设计模式之工厂模式（创建型）
图解设计模式（四）工厂模式
zhangmiaoping23的专栏
09-08 185
package com.design; import java.util.ArrayList; import java.util.List; public class TestFactory { public static void main(String[] args) { Factory factory = new IDCardFactory(); Product card1 = factory.create("小明"); Product card2 = factory.crea...
创建型设计模式（6种）学习
C/C++Linux、音视频、DPDK
07-12 2620
Linux服务器开发/后台架构师知识体系整理 创建型设计模式有： 共6种 简单工厂模式（Simple Factory） 工厂方法模式（Factory Method） 抽象工厂模式（Abstract Factory） 建造者模式（Builder） 原型模式（Prototype） 单例模式（Singleton） 简单工厂模式 功能：主要用于创建对象。新添加类时，不会影响以前的系统代码。核心思想是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的virtual函数得到不同的结果。 优点： 适用于不同情况
设计模式Part3——简单工厂模式
leikang111的博客
04-01 767
简单工厂模式
设计模式Part5——抽象工厂模式
leikang111的博客
04-04 813
抽象工厂模式
设计模式总结03--抽象工厂模式
zhouyuming_hbxt的博客
09-08 779
一、什么是抽象工厂模式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值