Java工厂模式优雅地创建对象以及提高代码复用率和灵活性

更新时间：2023年05月04日 09:18:06 作者：.番茄炒蛋

Java工厂模式是一种创建型设计模式，通过定义一个工厂类来封装对象的创建过程，将对象的创建和使用分离，提高代码的可维护性和可扩展性，同时可以实现更好的代码复用和灵活性

介绍

Java工厂设计模式主要分为三种:

简单工厂模式(Simple Factory Pattern):使用一个工厂类来封装对象创建的过程,客户端只需要通过传递不同的参数来获取不同的产品对象,从而避免了客户端直接创建产品对象的操作

工厂方法模式(Factory Method Pattern):将工厂类抽象出来,每个具体产品类对应一个具体工厂类,工厂类通过多态性来创建对应的产品对象,客户端只需要知道工厂接口及其实现类即可,可以根据需求动态切换工厂实现,扩展性更好.

抽象工厂模式(Abstract Factory Pattern):在工厂方法模式的基础上,将工厂类再进行一次抽象,将多个工厂接口放到一个工厂接口中,每个具体产品对应一个具体工厂类,通过多态性来创建对应的产品对象,具有更好的扩展性和更高的抽象程度,但是也增加了系统复杂度

简单工厂模式

首先先定义一个抽象产品类:

package com.fanqiechaodan.factory.simple.product;
/**
 * @Classname Product
 * @Description 抽象产品类
 */
public abstract class Product {
    public abstract void use();
}

然后定义具体产品类

public class ProductA extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类A...");
    }
}
public class ProductB extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类B...");
    }
}
public class ProductC extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类C...");
    }
}

接下来定义工厂类,用于创建不同的产品

package com.fanqiechaodan.factory.simple.factory;
import com.fanqiechaodan.factory.simple.product.Product;
import com.fanqiechaodan.factory.simple.product.ProductA;
import com.fanqiechaodan.factory.simple.product.ProductB;
import com.fanqiechaodan.factory.simple.product.ProductC;
/**
 * @Classname SimpleFactory
 * @Description 工厂类
 */
public class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            case "C":
                return new ProductC();
            default:
                throw new RuntimeException("不支持的产品类型:" + type);
        }
    }
}

测试:

package com.fanqiechaodan.factory.simple;
import com.fanqiechaodan.factory.simple.factory.SimpleFactory;
import com.fanqiechaodan.factory.simple.product.Product;
/**
 * @Classname Demo
 * @Description 简单工厂模式
 */
public class Demo {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();
        Product productB = SimpleFactory.createProduct("B");
        productB.use();
        Product productC = SimpleFactory.createProduct("C");
        productC.use();
        Product productD = SimpleFactory.createProduct("D");
        productD.use();
    }
}

工厂方法模式

首先定义一个接口表示产品

package com.fanqiechaodan.factory.method.product;
/**
 * @Classname Product
 * @Description 产品接口
 */
public interface Product {
    void use();
}

其次定义两个具体的产品实现类

public class ProductA implements Product{
    @Override
    public void use() {
        System.out.println("使用具体产品A...");
    }
}
public class ProductB implements Product{
    @Override
    public void use() {
        System.out.println("使用具体产品B...");
    }
}

然后定义一个工厂接口用于创建产品

package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
/**
 * @Classname Factory
 * @Description 工厂接口
 */
public interface Factory {
    Product createProduct();
}

接下来,定义两个具体的工厂实现类,分别用于创建不同的产品

public class FactoryA implements Factory{
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}
public class FactoryB implements Factory{
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

测试

package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
import com.fanqiechaodan.factory.method.product.ProductB;
/**
 * @Classname FactoryB
 * @Description 工厂实现类B
 */
public class FactoryB implements Factory{
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

抽象工厂模式

首先定义抽象产品

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

其次定义具体产品

public class ProductA1 implements ProductA{
    @Override
    public void doSomething() {
        System.out.println("ProductA1 doSomething ...");
    }
}
public class ProductA2 implements ProductA{
    @Override
    public void doSomething() {
        System.out.println("ProductA2 doSomething ...");
    }
}
public class ProductB1 implements ProductB{
    @Override
    public void doSomething() {
        System.out.println("ProductB1 doSomething ...");
    }
}
public class ProductB2 implements ProductB{
    @Override
    public void doSomething() {
        System.out.println("ProductB2 doSomething ...");
    }
}

然后定义抽象工厂

package com.fanqiechaodan.factory.abstractfactory.factory;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
/**
 * @Classname AbstractFactory
 * @Description 抽象工厂
 */
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

接下来定义具体工厂

public class Factory1 implements AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }
    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}
public class Factory2 implements AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }
    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

测试

package com.fanqiechaodan.factory.abstractfactory;
import com.fanqiechaodan.factory.abstractfactory.factory.AbstractFactory;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory1;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory2;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
/**
 * @Classname Demo
 * @Description 抽象工厂模式
 */
public class Demo {
    public static void main(String[] args) {
        // 使用具体工厂1创建产品A和产品B
        AbstractFactory factory1 = new Factory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.doSomething();
        productB1.doSomething();
        // 使用具体工厂2创建产品A和产品B
        AbstractFactory factory2 = new Factory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.doSomething();
        productB2.doSomething();
    }
}

总结

简单工厂模式

优点:

简单易用,客户端只需要知道工厂类和产品类即可
工厂类负责创建对象,客户端无需知道具体得实现细节
可以根据参数动态创建对象

缺点:

工厂类负责创建所有得产品对象,当产品类型过多时,工厂类会变得十分臃肿
添加新产品需要修改工厂类的代码,违反了开闭原则

工厂方法模式

优点:

将每个产品类型的创建部分分散到具体的工厂类中,避免了简单工厂模式中工厂类臃肿的问题
添加新产品只需要添加具体工厂类即可,符合开闭原则

缺点:

客户端需要知道所有具体工厂类,使用起来不够灵活
每个产品类型都需要对应一个具体的工厂类,增加了系统类的个数,增加了系统的复杂度

抽象工厂模式

优点:

可以创建一组相关的产品对象,确保这些对象之间的兼容性
隐藏了产品对象的具体实现,客户端只需要知道抽象工厂和抽象产品即可
可以通过替换具体工厂来实现不同的产品组合,提高了系统的灵活性

缺点;

增加了系统的抽象性和复杂度,需要定义多个抽象工厂接口和多个具体工厂类
不容易支持新种类的产品,需要添加新的产品工厂接口和具体工厂类

到此这篇关于Java工厂模式优雅地创建对象以及提高代码复用率和灵活性的文章就介绍到这了,更多相关Java工厂模式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

JAVA匿名内部类(Anonymous Classes)的具体使用
本文主要介绍了JAVA匿名内部类，匿名内部类在我们JAVA程序员的日常工作中经常要用到，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2021-08-08
Eclipse+Java+Swing+Mysql实现电影购票系统(详细代码)
这篇文章主要介绍了Eclipse+Java+Swing+Mysql实现电影购票系统并附详细的代码详解，需要的小伙伴可以参考一下
2022-01-01
Java中创建对象的6种方式
大家好，本篇文章主要讲的是Java中创建对象的6种方式，感兴趣的同学赶快来看一看吧，对你有帮助的话记得收藏一下的相关资料
2022-02-02
Nacos封装通用HttpClient详解
这篇文章主要介绍了Nacos封装通用HttpClient用法,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2024-01-01
SpringBoot解析JSON数据的三种方案
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,易于人阅读和编写,同时也易于机器解析和生成,本文给大家介绍了SpringBoot解析JSON数据的三种方案,需要的朋友可以参考下
2024-03-03
Java实现监控多个线程状态的简单实例
下面小编就为大家带来一篇Java实现监控多个线程状态的简单实例。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-03-03
Java设计模式之解释器模式_动力节点Java学院整理
解释器模式是一个比较少用的模式，本人之前也没有用过这个模式。下面我们就来一起看一下解释器模式
2017-08-08
Mybatis一对一延迟加载实现过程解析
这篇文章主要介绍了Mybatis一对一延迟加载实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-10-10
log4j升级log4j2遇到的问题及解决方式
这篇文章主要介绍了log4j升级log4j2遇到的问题及解决方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-12-12
OpenJDK源码调试图文教程
这篇文章主要介绍了OpenJDK源码调试,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2021-04-04