详细讲解什么是工厂模式

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

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

简单工厂模式:


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

  1. 产品接口(Product Interface): 定义了产品的接口或抽象类。

  2. 具体产品(Concrete Product): 实现了产品接口的具体类。

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

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

// 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 和两个具体的日志类 FileLoggerConsoleLogger

// 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();
    }
}

        在这个例子中,ComputerPhone 是抽象产品接口,DesktopComputerLaptopComputerSmartphoneFeaturePhone 是具体产品的实现。ElectronicsFactory 是抽象工厂接口,DellFactoryLenovoFactory 是具体工厂的实现。

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

你可能感兴趣的:(设计模式,java,开发语言,工厂模式)