Java设计模式（2）工厂模式

Jensen_97

发布于 2024-04-18 13:24:27

600

发布于 2024-04-18 13:24:27

前言

在软件开发的世界里，设计模式如同一本精妙的编码诗集，已经成为一种标准的编程实践。在Java编程中，设计模式很重要。是软件开发中广泛应用的一种编程方法，它可以帮助开发人员更快地编写出高效、可靠和可维护的代码。本人将制作一个关于Java设计模式的系列文章，总共23种设计模式将以一篇一篇文章讲解，代码笔记已开源：Gitee点击跳转。在上一篇《Java设计模式（1）单例模式》文章中，我们介绍了单例模式。本文是这个系列的第二篇章，我们将讲解一下工厂模式的实现方式、应用场景以及它的用途。

工厂模式

工厂模式是一种创建型设计模式，其主要目标是封装对象的创建过程，使客户端代码与具体类的实例化解耦。通过使用工厂模式，客户端无需直接调用具体类的构造函数，而是通过调用工厂方法或工厂接口来获取所需的对象。这提高了系统的灵活性，使得更容易更换或扩展产品对象。

工厂模式包含以下几个核心角色：

抽象产品（Abstract Product）：定义了产品的共同接口或抽象类。它可以是具体产品类的父类或接口，规定了产品对象的共同方法。
具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。
抽象工厂（Abstract Factory）：声明了创建产品的抽象方法，可以是接口或抽象类。它可以有多个方法用于创建不同类型的产品。
具体工厂（Concrete Factory）：实现了抽象工厂接口，负责实际创建具体产品的对象。

工厂模式的优点包括：

封装了对象的创建过程，降低了客户端与具体类的耦合度。
提高了系统的灵活性和可扩展性，可以方便地更换或新增产品类。
符合开闭原则，对扩展开放，对修改关闭。

简单工厂模式

在简单工厂模式中，有一个单一的工厂类，该工厂类负责根据客户端的需求创建不同的产品对象。客户端通过向工厂类传递参数来获取所需的产品实例。

应用场景

创建对象过程比较复杂：如果创建一个对象需要进行复杂的初始化过程，或者需要从多个地方获取数据才能创建对象，那么使用工厂模式可以将这些过程封装起来，让客户端代码更加简洁和易于理解。
需要动态扩展：如果需要增加或修改某个对象的创建过程，而又不希望对客户端代码产生影响，那么使用工厂模式可以很方便地实现这个需求。
统一管理对象：如果需要统一管理对象的创建过程，或者需要对创建的对象进行某些统一的处理，那么使用工厂模式可以很好地实现这个需求。
负责对对象的创建：如果需要根据不同的条件来创建不同类型的对象，那么使用工厂模式可以很方便地实现这个需求

代码实现

定义一个产品接口，有苹果和橘子两种产品

public interface Product {
    void produce();
}

创建produceApple类和produceOrange类

public class produceApple implements Product {
    @Override
    public void produce() {
        System.out.println("我是生产苹果的");
    }
}

public class produceOrange implements Product {
    @Override
    public void produce() {
        System.out.println("我是生产橘子的");
    }
}

创建一个拱外部使用的工厂 SimpleFactory类

public class SimpleFactory {
    public static Product createProduct(String name){
        return switch (name){
            case "apple"->  new produceApple();
            case "orange" ->  new produceOrange();
            default -> throw new IllegalArgumentException("没有这个产品");
        };
    }
}

外部调用工厂

System.out.println("------------------------------简单工厂模式-----------------------------");
SimpleFactory.createProduct("apple").produce();
SimpleFactory.createProduct("orange").produce();

输出：

抽象工厂模式

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定具体实现类。通过使用抽象工厂模式，可以将客户端与具体产品的创建过程解耦，使得客户端可以通过工厂接口来创建一族产品。

应用场景

避免直接使用new操作符：抽象工厂模式通过工厂接口的方法来创建对象，避免了直接使用 new 操作符实例化具体类。这样的设计更符合面向对象的原则，使得系统更易于扩展和维护。
产品对象之间存在关联关系：如果产品对象之间存在关联关系，并且这些关联关系在整个产品族中都是一致的，可以使用抽象工厂模式来确保产品对象之间的关联性。
当需要遵循“开闭原则”：不需要修改已有代码，可以使用抽象工厂模式。

代码实现

这里就拿汽车的例子来实现一下，分别有德系汽车和美式汽车两个大系，它们下面分别有凯迪拉克制造商、林肯制造商；奔驰制造商、宝马制造商；它们都由豪华汽车生产商统一管理。

定义 AmericanCar 和 GermanCar 产品接口

public interface AmericanCar {
    void manufacture();
}

public interface GermanCar {
    void manufacture();
}

创建类 Cadillac、Lincoln、Benz、Bmw

/**
 * 凯迪拉克汽车制造
 * @author Jensen
 * @date 2024-01-19
 * */
public class Cadillac implements AmericanCar {
    @Override
    public void manufacture() {
        System.out.println("制造美系-凯迪拉克汽车");
    }
}
/**
 * 林肯汽车制造
 * @author Jensen
 * @date 2024-01-19
 * */
public class Lincoln implements AmericanCar {
    @Override
    public void manufacture() {
        System.out.println("制造美系-林肯汽车");
    }
}
/**
 * 奔驰汽车制造
 * @author Jensen
 * @date 2024-01-19
 * */
public class Benz implements GermanCar {
    @Override
    public void manufacture() {
        System.out.println("制造德系-奔驰汽车");
    }
}
/**
 * 宝马汽车制造
 * @author Jensen
 * @date 2024-01-19
 * */
public class Bmw implements GermanCar {
    @Override
    public void manufacture() {
        System.out.println("制造德系-宝马汽车");
    }
}

创建一个抽象工厂类并定义几个品牌的汽车制造商，进行统一管理

public abstract class CarFactory {
    public abstract AmericanCar createCadillacCar();
    public abstract AmericanCar createLincolnCar();
    public abstract GermanCar createBmwCar();
    public abstract GermanCar createBenzCar();
}

创建拱客户端调用的生产汽车工厂类（抽象方法的具体实现）

public class ManufactureCarFactory extends CarFactory{
    @Override
    public AmericanCar createCadillacCar() {
        return new Cadillac();
    }
    @Override
    public AmericanCar createLincolnCar() {
        return new Lincoln();
    }
    @Override
    public GermanCar createBmwCar() {
        return new Bmw();
    }
    @Override
    public GermanCar createBenzCar() {
        return new Benz();
    }
}

外部调用工厂：

System.out.println("------------------------------抽象工厂模式-----------------------------");
ManufactureCarFactory manufactureCarFactory = new ManufactureCarFactory();
manufactureCarFactory.createCadillacCar().manufacture();
manufactureCarFactory.createBmwCar().manufacture();
manufactureCarFactory.createLincolnCar().manufacture();
manufactureCarFactory.createBenzCar().manufacture();

输出：