设计模式文档无水印可复制

一、工厂模式概述

1.1 什么是工厂模式

工厂模式（Factory Pattern）是Java中最常用的设计模式之一，属于创建型模式。这种模式提供了一种将对象的实例化过程封装在工厂类中的方式，用于封装和管理对象的创建。

工厂模式包括三种不同的形式：简单工厂模式、工厂方法模式和抽象工厂模式。这三种模式在形式和特点上是极为相似的，都是为了更好地解耦。简单工厂模式是一种最简单的工厂模式，它提供了一个创建对象的最佳方式；工厂方法模式是一种将对象的实例化过程延迟到子类中进行的模式；抽象工厂模式是一种将创建一套产品族的操作交给一个工厂处理的模式。

总的来说，工厂模式的核心就是帮助我们针对抽象编程，而不是针对具体类编程。其主要目的是封装对象创建的过程，使得客户端不需要直接调用具体的类来创建对象，而只需要通过工厂类的接口来获取所需的对象。这样做的好处是降低了系统的耦合性，增加了程序的灵活性和可维护性。

1.2 简单实现工厂模式

工厂模式是一种创建型设计模式，它提供了一种在不指定具体类的情况下创建对象的方法。下面是一个简单的Java实现工厂模式的例子：

• 1、首先，我们定义一个接口Product，表示产品：

public interface Product {
    void show();
}

• 2、然后，我们创建两个实现了Product接口的具体产品类ProductA和ProductB：

public class ProductA implements Product {
    @Override
    public void show() {
        System.out.println("生产了产品A");
    }
}

public class ProductB implements Product {
    @Override
    public void show() {
        System.out.println("生产了产品B");
    }
}

• 3、接下来，我们创建一个工厂类ProductFactory，用于根据传入的参数创建相应的产品对象：

public class ProductFactory {
    public static Product createProduct(String type) {
        if ("A".equalsIgnoreCase(type)) {
            return new ProductA();
        } else if ("B".equalsIgnoreCase(type)) {
            return new ProductB();
        }
        return null;
    }
}

• 4、最后，我们在客户端代码中使用工厂类创建产品对象并调用其方法：

public class Client {
    public static void main(String[] args) {
        Product productA = ProductFactory.createProduct("A");
        productA.show();

        Product productB = ProductFactory.createProduct("B");
        productB.show();
    }
}

• 5、运行客户端代码，输出结果如下：

  生产了产品A
  生产了产品B

1.3 使用工厂模式注意事项

使用工厂模式时，有几点需要注意：

• 1、工厂模式适用于需要生成复杂对象的场景。如果对象创建过程简单，例如只需要通过new关键字就可以完成创建，那么无需使用工厂模式。

• 2、工厂模式分为简单工厂模式、工厂方法模式和抽象工厂模式，这三种模式在形式和特点上是极为相似的，最终目的都是为了解耦。

• 3、工厂模式的本质是对获取对象过程的抽象，因此在使用时，应尽量遵守面向接口编程的原则。

• 4、当需要增加新的产品时，只需增加一个新的具体产品类和相应的工厂类即可，无需修改原有代码。

• 5、工厂模式降低了系统中代码耦合度，增强了系统的扩展性。

• 6、在使用工厂模式时，要避免过度使用它，否则可能会导致系统变得复杂并降低性能。

二、工厂模式的用途

工厂模式是一种常用的设计模式，它的核心思想就是把创建对象和使用对象解耦，由工厂负责对象的创建，而用户只能通过接口来使用对象。这种模式具有灵活应对变化的业务需求的优点，可以方便代码管理，避免代码重复。

在实际应用中，工厂模式适用于以下场景：

• 1、对象的创建过程/实例化准备工作很复杂，需要初始化很多参数、查询数据库等。
• 2、类本身有好多子类，这些类的创建过程在业务中容易发生改变，或者对类的调用容易发生改变。

此外，工厂模式的实现方式有多种，包括简单工厂模式、工厂方法模式和抽象工厂模式等，每种实现方式都有其优点和缺点。例如，简单工厂模式的扩展性较差，新增产品时需要修改工厂类。因此，在选择使用工厂模式时，需要根据具体的需求和场景来决定使用哪种实现方式。

三、工厂模式实现方式

3.1 简单工厂模式（Simple Factory）

通过一个工厂类来创建对象，该工厂类负责根据传入的参数来决定创建哪个类的实例。

public interface Product {
    void show();
}

public class ProductA implements Product {
    @Override
    public void show() {
        System.out.println("ProductA");
    }
}

public class ProductB implements Product {
    @Override
    public void show() {
        System.out.println("ProductB");
    }
}

public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equalsIgnoreCase(type)) {
            return new ProductA();
        } else if ("B".equalsIgnoreCase(type)) {
            return new ProductB();
        }
        return null;
    }
}

3.2 工厂方法模式（Factory Method）

定义一个工厂接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

public interface Product {
    void show();
}

public class ProductA implements Product {
    @Override
    public void show() {
        System.out.println("ProductA");
    }
}

public class ProductB implements Product {
    @Override
    public void show() {
        System.out.println("ProductB");
    }
}

public abstract class Factory {
    public abstract Product createProduct();
}

public class ConcreteFactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

public class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

3.3 抽象工厂模式（Abstract Factory）

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

public interface Product {
    void show();
}

public interface Color {
    void show();
}

public class Red implements Color {
    @Override
    public void show() {
        System.out.println("Red");
    }
}

public class Blue implements Color {
    @Override
    public void show() {
        System.out.println("Blue");
    }
}

public interface Shape {
    void show();
}

public class Circle implements Shape {
    private Color color;

    public Circle(Color color) {
        this.color = color;
    }

    @Override
    public void show() {
        System.out.println("Circle with " + color.show());
    }
}

public class Square implements Shape {
    private Color color;

    public Square(Color color) {
        this.color = color;
    }

    @Override
    public void show() {
        System.out.println("Square with " + color.show());
    }
}

public abstract class AbstractFactory {
    public abstract Shape getShape();
    public abstract Color getColor();
}

public class ConcreteFactory1 extends AbstractFactory {
    @Override
    public Shape getShape() {
        return new Circle(new Red());
    }

    @Override
    public Color getColor() {
        return new Blue();
    }
}

public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public Shape getShape() {
        return new Square(new Blue());
    }

    @Override
    public Color getColor() {
        return new Red();
    }
}