首页 > 资讯 > 后端开发 > Python >Java工厂模式优雅地创建对象以及提高代码复用率和灵活性

176

分享到

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

Java工厂模式 Java工厂设计模式设计模式工厂模式 2023-05-18 17:05:20 176人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录介绍简单工厂模式工厂方法模式抽象工厂模式总结介绍 Java工厂设计模式主要分为三种: 简单工厂模式(Simple Factory Pattern):使用一个工厂类来封装对象创建的

介绍

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

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

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

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

简单工厂模式

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

package com.fanqiechaodan.factory.simple.product;

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;

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;

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;

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;

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;

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;

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;

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工厂模式内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

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

本文链接: https://www.lsjlt.com/news/212250.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

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

目录介绍简单工厂模式工厂方法模式抽象工厂模式总结介绍 Java工厂设计模式主要分为三种: 简单工厂模式(Simple Factory Pattern):使用一个工厂类来封装对象创建的...

99+

2023-05-18

Java工厂模式 Java工厂设计模式设计模式工厂模式
Java享元设计模式优化对象创建提高性能和效率

目录介绍实现总结优点缺点应用场景介绍 Java中的享元模式(Flyweight Pattern)是一种结构型设计模式,旨在通过共享尽可能多的对象来减少内存占用和提高性能. Java享...

99+

2023-05-17

Java享元设计模式 Java享元模式 Java设计模式
利用 VUE 模块化优化你的代码库：提高效率和灵活性

可读性和维护性提高：将代码分解成较小的模块可以显著提高代码库的可读性和维护性，尤其是在大型应用程序中。代码复用：模块允许在整个应用程序中轻松地复用代码，避免重复和错误。提高灵活性：模块化使你可以独立开发和部署代码库的不同部分，增强了...

99+

2024-03-10

模块化的优势模块化是一种在不同代码模块中组织和封装功能的软件开发技术。它为 Vue.js 应用程序提供了许多优势：