Java设计模式之工厂模式（精髓版）

swadian2008

已于 2023-04-12 17:51:48 修改

阅读量249

点赞数

分类专栏：设计模式文章标签：设计模式工厂模式抽象工厂模式工厂方法模式

于 2022-09-30 16:35:42 首次发布

本文链接：https://blog.csdn.net/swadian2008/article/details/127124421

版权

设计模式专栏收录该内容

19 篇文章 10 订阅

订阅专栏

1、工厂模式阐述

Java 工厂模式是一种创建型设计模式，它提供了一种将对象的创建与使用分离的方式，可以更加灵活地创建对象。

在 Java 中，工厂模式可以通过三种方式来实现：简单工厂模式、工厂方法模式和抽象工厂模式。

（1）简单工厂模式：简单工厂模式是通过一个静态方法来创建对象，根据传入的参数来决定创建哪种类型的对象。这种方式适用于创建对象的种类比较少，且客户端不需要关心对象的创建过程。例如：// 静态方法中的 if-else ，一系列条件语句

public class CarFactory {
    public static Car createCar(String type) {
        if (type.equals("Audi")) {
            return new Audi();
        } else if (type.equals("BMW")) {
            return new BMW();
        } else {
            return null;
        }
    }
}

Car car = CarFactory.createCar("Audi");

（2）工厂方法模式：工厂方法模式是将对象的创建交给子类来完成，客户端通过调用工厂方法来创建对象。这种方式适用于需要创建多种类型的对象，且客户端需要根据具体情况来选择创建哪种类型的对象。例如：

public interface CarFactory {
    Car createCar();
}

public class AudiFactory implements CarFactory {
    public Car createCar() {
        return new Audi();
    }
}

public class BMWFactory implements CarFactory {
    public Car createCar() {
        return new BMW();
    }
}

CarFactory factory = new AudiFactory();
Car car = factory.createCar();

（3）抽象工厂模式：抽象工厂模式是一种针对产品族的创建模式，它提供了一个接口来创建一系列相关或相互依赖的对象。例如：

public interface CarFactory {
    Engine createEngine();
    Aircondition createAircondition();
}

public class AudiFactory implements CarFactory {
    public Engine createEngine() {
        return new AudiEngine();
    }
    public Aircondition createAircondition() {
        return new AudiAircondition();
    }
}

public class BMWFactory implements CarFactory {
    public Engine createEngine() {
        return new BMWEngine();
    }
    public Aircondition createAircondition() {
        return new BMWAircondition();
    }
}

CarFactory factory = new AudiFactory();
Engine engine = factory.createEngine();
Aircondition aircondition = factory.createAircondition();

在使用工厂模式时，可以将对象的创建和使用分离，降低了类之间的耦合度，使得系统更加灵活和可扩展。

2、为什么要使用工厂模式？

工厂模式是一种常用的设计模式，它的主要作用是将对象的创建和使用分离开来，从而降低系统的耦合度。具体来说，使用工厂模式有以下几个优点：

降低耦合度：工厂模式通过将对象的创建和使用分离开来，使得客户端不需要知道具体产品的实现细节，从而降低了客户端与产品类之间的耦合度。
提高代码的复用性：工厂模式可以提供一种统一的创建产品的接口，从而使得系统可以灵活地更换产品实现，提高了代码的复用性。
方便添加新产品：工厂模式可以通过添加新的具体产品类来扩展系统的功能，从而方便了添加新产品。
便于管理对象：工厂模式可以将对象的创建集中管理，从而方便统一管理和维护对象。

3、工厂模式的适用场景

需要创建复杂的对象：当需要创建一个复杂的对象时，可以使用工厂模式来将对象的创建过程集中管理，从而使代码更加清晰和易于维护。
需要统一管理对象的创建：当系统中存在多个对象需要创建时，可以使用工厂模式来将对象的创建集中管理，从而方便统一管理和维护对象。
需要动态地指定对象的创建方式：当需要根据不同的条件来动态地指定对象的创建方式时，可以使用工厂模式来灵活地创建对象。
需要隔离具体的实现：当需要隔离具体实现并将它们替换为不同的实现时，可以使用工厂模式来将实现和客户端代码解耦。
需要通过接口来调用具体的实现：当需要通过接口来调用具体实现时，可以使用工厂模式来实现接口与具体实现之间的解耦。

// 总之，工厂模式一般使用在对象的创建上，在创建对象的时候可以考虑下

4、抽象工厂的详细描述和具体实现

抽象工厂模式是一种对象创建型模式，它提供一个接口，用于创建一系列相关或依赖对象的家族，而不需要指定具体的类。抽象工厂模式是工厂方法模式的扩展，它支持创建一系列相关的产品。// 在一个工厂里创建的产品比较多，并非单一的产品，比如在一个工厂同时生产了手机和电视机，这是两个不同的对象，简单点来理解就是同时创建了多个对象。

在抽象工厂模式中，通常会定义一个抽象工厂接口，它包含了一系列用于创建不同产品族的方法，每个方法都返回一个抽象产品类型。同时，还需要定义一组抽象产品接口，每个接口表示一个产品族中的某个具体产品。具体工厂实现这些抽象接口，以生产特定的产品族。

抽象工厂模式通过封装一组相关的产品，使得客户端无需关心产品的实现细节，从而提高了代码的灵活性和可维护性。客户端只需要使用工厂接口来创建产品对象，而不需要关心这些对象的具体类型和实现方式。

下面是一个简单的抽象工厂模式示例，假设我们需要创建不同类型的手机和电视机：

// 抽象手机接口
public interface Phone {
    void call();
}

// 抽象电视机接口
public interface Television {
    void play();
}

// 抽象工厂接口
public interface AbstractFactory {
    Phone createPhone();
    Television createTelevision();
}

// 具体工厂实现类1
public class Factory1 implements AbstractFactory {
    public Phone createPhone() {
        return new Phone1();
    }
    public Television createTelevision() {
        return new Television1();
    }
}

// 具体工厂实现类2
public class Factory2 implements AbstractFactory {
    public Phone createPhone() {
        return new Phone2();
    }
    public Television createTelevision() {
        return new Television2();
    }
}

// 具体手机实现类1
public class Phone1 implements Phone {
    public void call() {
        System.out.println("Phone1 is calling");
    }
}

// 具体手机实现类2
public class Phone2 implements Phone {
    public void call() {
        System.out.println("Phone2 is calling");
    }
}

// 具体电视机实现类1
public class Television1 implements Television {
    public void play() {
        System.out.println("Television1 is playing");
    }
}

// 具体电视机实现类2
public class Television2 implements Television {
    public void play() {
        System.out.println("Television2 is playing");
    }
}

// 客户端使用抽象工厂创建产品
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new Factory1();
        AbstractFactory factory2 = new Factory2();

        Phone phone1 = factory1.createPhone();
        phone1.call();

        Television television2 = factory2.createTelevision();
        television2.play();
    }
}

在上述示例中，AbstractFactory 是抽象工厂接口，它包含了用于创建不同产品族的方法。Phone 和 Television 是抽象产品接口，每个接口定义了一个产品族中的某个具体产品。具体工厂类 Factory1 和 Factory2 分别实现了 AbstractFactory 接口，它们用于生产不同的产品族。具体产品类 Phone1、Phone2、Television1、Television2 实现了 Phone 和 Television 接口，它们是具体的产品实现。