一起来学设计模式之工厂模式

程序员皮卡秋
632 阅读7分钟

前言

目前正在出一个设计模式专题系列教程, 篇幅会较多, 喜欢的话，给个关注❤️ ~

本节给大家讲一下设计模式中的工厂模式~

本专题的所有案例代码主要以Java语言为主, 好了, 废话不多说直接开整吧~

工厂模式

工厂模式是一种常用的设计模式，它提供了一种创建对象的方式，该方式隐藏了对象创建的细节并提供了一个通用的接口，从而使得代码更加灵活和可扩展。在工厂模式中，我们将对象的创建过程封装到一个工厂类中，通过工厂类来创建具体的对象，这样客户端就不需要关心对象的创建过程，只需要调用工厂类提供的接口来获取所需的对象即可。

工厂模式包括三种常见的类型：简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式 Simple Factory Pattern

简单工厂模式是最基本的工厂模式，也叫静态工厂方法模式。它由一个工厂类负责创建所有的对象，客户端只需要传入相应的参数即可得到所需的对象。例如，我们可以定义一个简单工厂类，通过传入不同的参数，返回不同的对象

请看如下代码:

class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            return null;
        }
    }
}

interface Product {
}

class ConcreteProductA implements Product {
    
}

class ConcreteProductB implements Product {

}

工厂方法模式（Factory Method Pattern）

工厂方法模式是简单工厂模式的一种变形，它不再由一个工厂类来负责创建所有的对象，而是由一个抽象工厂类定义了一个工厂方法接口，由子类来实现该接口以创建具体的产品对象。这样，每个具体产品都有一个对应的工厂类，客户端只需要和具体的工厂类交互，而不需要知道具体产品的创建过程。例如，我们可以定义一个抽象工厂类和两个具体工厂类，

下面一起实现一下

public interface MethodFactory {
    public MethodProduct createProduct();
}

interface MethodProduct {

}

class ConcreteFactoryA implements MethodFactory {
    @Override
    public MethodProduct createProduct() {
        return new ProductA();
    }
}

class ConcreteFactoryB implements MethodFactory {
    @Override
    public MethodProduct createProduct() {
        return new ProductB();
    }
}

class ProductA implements MethodProduct {}
class ProductB implements MethodProduct {}

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式是一种更加复杂的工厂模式，它通过提供一组相关或者相互依赖的产品对象组成的工厂，来实现创建一系列相关或者相互依赖的对象。在抽象工厂模式中，客户端不需要关心具体的产品对象，只需要关心所需要的产品对象所属的工厂即可。例如，我们可以定义一个抽象工厂接口和两个具体工厂类

public interface AbstractFactory {
    AbsProductA createAbsProductA();
    AbsProductB createAbsProductB();
}

interface AbsProductA {}
interface AbsProductB {}

class ProductA1 implements AbsProductA{}
class ProductB1 implements AbsProductB{}

class ProductA2 implements AbsProductA{}
class ProductB2 implements AbsProductB{}

class AbsProductFactory1 implements AbstractFactory {

    @Override
    public AbsProductA createAbsProductA() {
        return new ProductA1();
    }

    @Override
    public AbsProductB createAbsProductB() {
        return new ProductB1();
    }
}

class AbsProductFactory2 implements AbstractFactory {

    @Override
    public AbsProductA createAbsProductA() {
        return new ProductA2();
    }

    @Override
    public AbsProductB createAbsProductB() {
        return new ProductB2();
    }
}

客户端可以根据需要使用不同的工厂来创建不同的产品对象

class AbsFactoryTest {
    public static void main(String[] args) {
        AbstractFactory fa1 = new AbsProductFactory1();
        AbsProductA p1a = fa1.createAbsProductA();
        AbsProductB p1b = fa1.createAbsProductB();

        AbstractFactory fa2 = new AbsProductFactory2();
        AbsProductA p2a = fa2.createAbsProductA();
        AbsProductB p2b = fa2.createAbsProductB();
    }
}

总之，工厂模式能够提高代码的可维护性和可扩展性，将对象的创建和使用分离，使得系统更加灵活和易于修改。在实际开发中，可以根据具体的需求选择不同的工厂模式。

下面通过一个小例子来看一下它的实际应用，假设我们正在开发一个电商平台，需要实现不同支付方式的支付功能。我们可以使用抽象工厂模式来创建不同的支付方式对象。首先，我们定义一个支付接口和多个具体支付类

public interface Payment {
    void pay();
}

public class WxPay implements Payment {

    @Override
    public void pay() {
        System.out.println("微信支付");
    }
}

public class JdPay implements Payment {
    @Override
    public void pay() {
        System.out.println("京东支付");
    }
}

public class AliPay implements Payment {
    @Override
    public void pay() {
        System.out.println("支付宝支付");
    }
}

然后，我们定义一个抽象支付工厂接口和多个具体支付工厂类，用于创建不同类型的支付方式对象

public interface PayFactory {
    Payment createPayment();
}

public class JdPayFactory implements PayFactory {
    @Override
    public Payment createPayment() {
        return new JdPay();
    }
}

public class AliPayFactory implements PayFactory {
    @Override
    public Payment createPayment() {
        return new AliPay();
    }
}

public class WxPayFactory implements PayFactory{
    @Override
    public Payment createPayment() {
        return new WxPay();
    }
}

最后，我们可以在电商平台中使用不同的工厂来创建不同类型的支付方式对象,假如我想调用微信支付:

public class PayTest {
    public static void main(String[] args) throws Exception {
        PayFactory wxPay = new WxPayFactory();
        Payment wxPayPayment = wxPay.createPayment();
        wxPayPayment.pay();
    }
}

运行一下：

微信支付

在这个例子中，我们使用抽象工厂模式将支付方式对象的创建和使用分离开来，使得系统更加灵活和易于扩展。如果我们需要添加新的支付方式，只需要添加相应的具体支付类和工厂类即可，不需要修改已有的代码。同时，通过使用抽象工厂模式，我们可以保证创建出来的支付方式对象是相互依赖的，符合设计原则，使得代码更加健壮和可靠。

结束语

下节给大家讲建造者模式~

本着把自己知道的都告诉大家，如果本文对您有所帮助，点赞+关注鼓励一下呗~

相关文章

项目源码(源码已更新 欢迎star⭐️)

Kafka 专题学习

项目源码(源码已更新 欢迎star⭐️)

ElasticSearch 专题学习

项目源码(源码已更新 欢迎star⭐️)

往期并发编程内容推荐

推荐 SpringBoot & SpringCloud (源码已更新 欢迎star⭐️)

博客(阅读体验较佳)

本文正在参加「金石计划」

avatar
文章
阅读
粉丝