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

拼搏现实的明天。 2024-04-03 07:42 73阅读 0赞

**目录**

1、工厂模式阐述

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

3、工厂模式的适用场景

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

--------------------

#### 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、为什么要使用工厂模式？ ####

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

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

#### 3、工厂模式的适用场景 ####

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

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

#### 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` 接口，它们是具体的产品实现。

在客户端代码中，我们使用抽象工厂接口来创建产品对象，具体的工厂实现类和产品实现类都是在运行时动态创建的。这样，我们就可以通过切换不同的工厂实现类来创建不同的产品族，而无需修改客户端代码。

总之，抽象工厂模式提供了一种灵活的方式来创建一系列相关或依赖的产品对象，它可以在运行时动态切换产品族，而不会对客户端代码产生影响。

// 抽象工厂本身并不复杂，之所以觉得复杂，是因为没很多文章没有清楚或者过于啰嗦。