详细讲解什么是工厂模式

当我们谈论工厂模式时，我们实际上是在讨论一种创建对象的设计模式。工厂模式的目的是封装对象的创建过程，并将其交给一个单独的工厂类来处理。这种方式有助于解耦对象的创建和使用，使得系统更加灵活、可维护。

有三种主要的工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式：

---

简单工厂模式是一种创建型设计模式，它提供了一个简单的工厂类，该工厂类负责根据给定的条件创建对象。这个模式通常包括以下几个角色：

1. 产品接口（Product Interface）： 定义了产品的接口或抽象类。

2. 具体产品（Concrete Product）： 实现了产品接口的具体类。

3. 工厂类（Factory Class）： 包含一个方法，根据输入条件创建并返回具体产品的实例。

下面是一个简单的例子，假设我们有一个形状接口 Shape 和两个具体的形状类 Circle 和 Square：

// 1. 产品接口
interface Shape {
    void draw();
}
 
// 2. 具体产品类
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}
 
class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制正方形");
    }
}
 
// 3. 工厂类
class ShapeFactory {
    // 工厂方法，根据输入条件创建并返回具体产品的实例
    public Shape createShape(String shapeType) {
        if ("Circle".equalsIgnoreCase(shapeType)) {
            return new Circle();
        } else if ("Square".equalsIgnoreCase(shapeType)) {
            return new Square();
        } else {
            throw new IllegalArgumentException("无法创建该形状类型");
        }
    }
}

使用简单工厂模式的客户端代码如下：

public class Client {
    public static void main(String[] args) {
        // 创建工厂实例
        ShapeFactory shapeFactory = new ShapeFactory();
 
        // 通过工厂创建具体产品实例
        Shape circle = shapeFactory.createShape("Circle");
        Shape square = shapeFactory.createShape("Square");
 
        // 调用产品的方法
        circle.draw();
        square.draw();
    }
}

在这个例子中，ShapeFactory 是工厂类，负责根据输入的字符串条件创建相应的形状对象。这样，客户端代码不需要直接实例化具体的形状类，而是通过工厂类来获取所需的对象，从而达到解耦的效果。

工厂方法模式（Factory Method Pattern）：

---

工厂方法模式是一种创建型设计模式，它定义了一个创建对象的接口，但由子类决定要实例化的类。换句话说，工厂方法模式将对象的实例化推迟到子类中进行。

角色：

1. 抽象产品接口（Product Interface）： 定义了产品的接口或抽象类。

2. 具体产品类（Concrete Product）： 实现了产品接口的具体类。

3. 抽象工厂类（Creator）： 声明了创建产品的工厂方法，可以包含一些默认的实现。

4. 具体工厂类（Concrete Creator）： 实现了抽象工厂类，负责实际创建具体产品的实例。

下面是一个简单的例子，假设我们有一个抽象的日志接口 Logger 和两个具体的日志类 FileLogger 和 ConsoleLogger：

// 1. 抽象产品接口
interface Logger {
    void logMessage(String message);
}
 
// 2. 具体产品类
class FileLogger implements Logger {
    @Override
    public void logMessage(String message) {
        System.out.println("写入日志到文件: " + message);
    }
}
 
class ConsoleLogger implements Logger {
    @Override
    public void logMessage(String message) {
        System.out.println("在控制台打印日志: " + message);
    }
}
 
// 3. 抽象工厂类
abstract class LoggerFactory {
    // 工厂方法，由子类实现，用于创建具体产品实例
    public abstract Logger createLogger();
}
 
// 4. 具体工厂类
class FileLoggerFactory extends LoggerFactory {
    @Override
    public Logger createLogger() {
        return new FileLogger();
    }
}
 
class ConsoleLoggerFactory extends LoggerFactory {
    @Override
    public Logger createLogger() {
        return new ConsoleLogger();
    }
}

使用工厂方法模式的客户端代码如下：

public class Client {
    public static void main(String[] args) {
        // 创建具体工厂实例
        LoggerFactory fileLoggerFactory = new FileLoggerFactory();
        LoggerFactory consoleLoggerFactory = new ConsoleLoggerFactory();
 
        // 使用具体工厂创建具体产品实例
        Logger fileLogger = fileLoggerFactory.createLogger();
        Logger consoleLogger = consoleLoggerFactory.createLogger();
 
        // 调用产品的方法
        fileLogger.logMessage("这是一个文件日志");
        consoleLogger.logMessage("这是一个控制台日志");
    }
}

在工厂方法模式中，具体产品的创建由具体工厂类决定，这样就可以轻松地扩展和变化产品系列，同时保持客户端代码的稳定性。

抽象工厂模式（Abstract Factory Pattern）：

---

抽象工厂模式是一种创建型设计模式，它提供一个接口，用于创建相关或依赖对象的家族，而不需要指定它们的具体类。抽象工厂模式是工厂方法模式的升级版，它引入了多个工厂方法，每个工厂方法负责创建一组相关的产品。

角色：

1. 抽象产品接口（Abstract Product Interface）： 定义了一组产品的接口或抽象类。

2. 具体产品类（Concrete Product）： 实现了产品接口的具体类。

3. 抽象工厂接口（Abstract Factory）： 声明了一组创建产品的抽象方法，每个方法对应一个产品。

4. 具体工厂类（Concrete Factory）： 实现了抽象工厂接口，负责创建一组相关的产品。

下面是一个简单的Java抽象工厂模式的实例，假设我们有两个产品家族：电脑和手机，每个家族有两个具体产品：台式电脑、笔记本电脑、智能手机和功能手机。

// 抽象产品接口
interface Computer {
    void show();
}
 
interface Phone {
    void display();
}
 
// 具体产品实现
class DesktopComputer implements Computer {
    @Override
    public void show() {
        System.out.println("Desktop Computer");
    }
}
 
class LaptopComputer implements Computer {
    @Override
    public void show() {
        System.out.println("Laptop Computer");
    }
}
 
class Smartphone implements Phone {
    @Override
    public void display() {
        System.out.println("Smartphone");
    }
}
 
class FeaturePhone implements Phone {
    @Override
    public void display() {
        System.out.println("Feature Phone");
    }
}
 
// 抽象工厂接口
interface ElectronicsFactory {
    Computer createComputer();
    Phone createPhone();
}
 
// 具体工厂实现
class DellFactory implements ElectronicsFactory {
    @Override
    public Computer createComputer() {
        return new DesktopComputer();
    }
 
    @Override
    public Phone createPhone() {
        return new Smartphone();
    }
}
 
class LenovoFactory implements ElectronicsFactory {
    @Override
    public Computer createComputer() {
        return new LaptopComputer();
    }
 
    @Override
    public Phone createPhone() {
        return new FeaturePhone();
    }
}
 
// 客户端
public class Client {
    public static void main(String[] args) {
        // 使用Dell工厂创建产品
        ElectronicsFactory dellFactory = new DellFactory();
        Computer dellComputer = dellFactory.createComputer();
        Phone dellPhone = dellFactory.createPhone();
 
        dellComputer.show();
        dellPhone.display();
 
        // 使用Lenovo工厂创建产品
        ElectronicsFactory lenovoFactory = new LenovoFactory();
        Computer lenovoComputer = lenovoFactory.createComputer();
        Phone lenovoPhone = lenovoFactory.createPhone();
 
        lenovoComputer.show();
        lenovoPhone.display();
    }
}

        在这个例子中，Computer 和 Phone 是抽象产品接口，DesktopComputer、LaptopComputer、Smartphone 和 FeaturePhone 是具体产品的实现。ElectronicsFactory 是抽象工厂接口，DellFactory 和 LenovoFactory 是具体工厂的实现。

客户端通过具体工厂来创建产品，而无需关心产品的具体实现。这样，如果需要更改产品的实现，只需更改具体工厂的实现，而客户端代码保持不变，实现了对象的创建和使用之间的解耦。