设计模式——工厂模式(Factory）

前言

---

工厂方法（Factory）

工厂方法是一种实例化对象的方法，是一个创造型模式，它用来从一组实现特定逻辑的类中实例化某个队象。

UML图

虚线代表依赖关系

• 产品类（Product）:定义了工厂方法所创建的对象接口。

• 具体产品类（ConcreteProduct）：实现产品类接口。

• 工厂类（Creator）：声明工厂方法，返回一个产品类对象。定义了产品类创建过程所需的所有细节和基本行为。

• 具体工厂类（ConcreteCreator）：重写创建具体产品类对象的方法。

代码示例

应用场景：程序中的日志记录场景

日志记录功能有多个不同的用途，如文件记录日志、数据库记录日志、控制台记录日志等。

我们可以把这些功能模块共同原型抽象在一个接口中。

利用工厂方法创建不同模块。

1. 产品基类

public interface AppLogger {
    void log(String logMsg);
}

2. 产品实现类

public class DataBaseLogger implements AppLogger{
    @Override
    public void log(String logMsg) {
        //打开数据库连接
        //记录日志
    }
}

public class ConsoleLogger implements AppLogger{
    @Override
    public void log(String logMsg) {
        System.out.println(logMsg);
    }
}

public class FileLogger implements AppLogger{
    @Override
    public void log(String logMsg) {
        //记录到文件
    }
}

3. 具体工厂类

public class LoggerFactory {
    public AppLogger getLogger(String logger) {
        if ("file".equals(logger)) return new FileLogger();
        if ("dataBase".equals(logger)) return new DataBaseLogger();
        if ("console".equals(logger)) return new ConsoleLogger();
        else return null;
    }
}

4. 用户端测试程序

public class ClientMain {
    public static void main(String[] args) {
    	//实例化工厂
        LoggerFactory loggerFactory = new LoggerFactory();
        
        //工厂根据不同的参数创建不同的模块
        AppLogger logger = loggerFactory.getLogger("console");
        //AppLogger logger = loggerFactory.getLogger("file");
		
        logger.log("logMsg");
    }
}

抽象工厂（Abstract Factory）

抽象工厂返回的是一组类的工厂。

与工厂方法类似（返回众多子类中的一个），此方法会返回一个工厂，而这个工厂又会返回一个子类。

UML图

• 抽象工厂（AbstractFactory）：声明一个创建产品实例接口
• 具体工厂（ConcreteFactory）：实现接口操作
• 抽象产品（AbstractProduct）：声明用于一类产品对象的接口
• 具体产品（ConcreteProduct）：定义由相应的具体工厂来创建的产品对象
• 客户端（Client）：使用由抽象工厂和抽象产品类声明的接口

应用代码示例

场景：假设我们需要得到一辆车各部分零件的规格。不同的零件包括wheel（车轮）、engine（引擎）、body（车身）等，不同品牌的车使用不同品牌的零件。

1. 声明一个Car基类，扮演工厂类的角色

public abstract class Car {
    public abstract Parts getWheels();
    public abstract Parts getEngine();
    public abstract Parts getBody();
}
//这个类中包含四个方法，返回四个不同品牌的零件。

2. Parts类，会创建不同的零件

public class Parts {
    private String partName;

    public Parts(String partName) {
        this.partName = partName;
    }

    public String getPartName() {
        return partName;
    }
}

3. 具体产品类（Car的子类）

public class TheGreatWall extends Car {
    @Override
    public Parts getWheels() {
        return new Parts("TheGreatWall wheel");
    }

    @Override
    public Parts getEngine() {
        return new Parts("TheGreatWall engine");
    }

    @Override
    public Parts getBody() {
        return new Parts("TheGreatWall body");
    }
}

public class JiLi extends Car{
    @Override
    public Parts getWheels() {
        return new Parts("JiLi wheel");
    }

    @Override
    public Parts getEngine() {
        return new Parts("JiLi engine");
    }

    @Override
    public Parts getBody() {
        return new Parts("JiLi Body");
    }
}

public class BYD extends Car {
    @Override
    public Parts getWheels() {
        return new Parts("BYD wheel");
    }

    @Override
    public Parts getEngine() {
        return new Parts("BYD engine");
    }

    @Override
    public Parts getBody() {
        return new Parts("BYD body");
    }
}

4. 抽象工厂类CarType,返回工厂类Car

public class CarType {
    Car car = null;

    public Car getCar(String carType) {
        if ("BYD".equals(carType)) car = new BYD();
        if ("TheGreatWall".equals(carType)) car = new TheGreatWall();
        if ("jiLi".equals(carType)) car = new JiLi();
        
        return car;
    }

}

5. 客户端

public class Main {
    public static void main(String[] args) {
        CarType carType = new CarType();
        Car car = carType.getCar("BYD");
        //CarFactory car = carType.getCar("TheGreatWall");
        System.out.println(car.getBody().getPartName());
        System.out.println(car.getEngine().getPartName());
        System.out.println(car.getWheels().getPartName());

    }
}