设计模式-工厂模式：让你的代码像工厂生产线一样高效！

Java 设计模式简介

Java 设计模式是一套被广泛应用于面向对象软件设计的可复用解决方案。它提供了一系列经过验证的设计思想和方法，可以帮助我们解决常见的软件设计问题，并提高软件的可维护性、可扩展性和可重用性。

Java 设计模式通常被分为三类：创建型模式、结构型模式和行为型模式。其中，创建型模式主要用于处理对象的创建过程，结构型模式主要用于处理对象的组合和关系，行为型模式主要用于处理对象之间的通信和协作。

下面，我们将介绍基于 Java 的工厂模式，并举例说明它们的实际场景和运用。

Java 创建型模式

工厂模式（Factory Pattern）

工厂模式是一种常见的创建型模式，它通过定义一个工厂类来创建对象，将对象的创建过程与使用过程分离。工厂模式通常分为简单工厂模式、工厂方法模式和抽象工厂模式三种形式。

实际场景

在一个订单系统中，我们需要根据用户的订单类型来创建不同的订单对象，比如普通订单、团购订单、促销订单等。这时，我们可以使用工厂模式来创建订单对象，将订单的创建过程封装在工厂类中，根据不同的订单类型返回不同的订单对象。

简单工厂模式 - 代码示例：

// 订单工厂类
class OrderFactory {
    public static Order createOrder(String type) {
        switch (type) {
            case "normal":
                return new NormalOrder();
            case "group":
                return new GroupOrder();
            case "promotion":
                return new PromotionOrder();
            default:
                throw new IllegalArgumentException("Invalid order type: " + type);
        }
    }
}

// 订单接口
interface Order {
    void process();
}

// 普通订单类
class NormalOrder implements Order {
    public void process() {
        System.out.println("Processing normal order...");
    }
}

// 团购订单类
class GroupOrder implements Order {
    public void process() {
        System.out.println("Processing group order...");
    }
}

// 促销订单类
class PromotionOrder implements Order {
    public void process() {
        System.out.println("Processing promotion order...");
    }
}

// 客户端代码
class Client {
    public static void main(String[] args) {
        // 创建普通订单对象
        Order normalOrder = OrderFactory.createOrder("normal");
        normalOrder.process(); // 输出 "Processing normal order..."
        
        // 创建团购订单对象
        Order groupOrder = OrderFactory.createOrder("group");
        groupOrder.process(); // 输出 "Processing group order..."
        
        // 创建促销订单对象
        Order promotionOrder = OrderFactory.createOrder("promotion");
        promotionOrder.process(); // 输出 "Processing promotion order..."
        
        // 创建一个无效的订单类型，会抛出 IllegalArgumentException 异常
        Order invalidOrder = OrderFactory.createOrder("invalid");
    }
}

工厂方法模式：

// 订单工厂接口
interface OrderFactory {
    Order createOrder();
}

// 普通订单工厂实现类
class NormalOrderFactory implements OrderFactory {
    public Order createOrder() {
        return new NormalOrder();
    }
}

// 团购订单工厂实现类
class GroupOrderFactory implements OrderFactory {
    public Order createOrder() {
        return new GroupOrder();
    }
}

// 促销订单工厂实现类
class PromotionOrderFactory implements OrderFactory {
    public Order createOrder() {
        return new PromotionOrder();
    }
}

// 客户端代码
class Client {
    public static void main(String[] args) {
        // 创建普通订单工厂对象
        OrderFactory normalFactory = new NormalOrderFactory();
        // 使用普通订单工厂对象创建普通订单对象
        Order normalOrder = normalFactory.createOrder();
        normalOrder.process(); // 输出 "Processing normal order..."
        
        // 创建团购订单工厂对象
        OrderFactory groupFactory = new GroupOrderFactory();
        // 使用团购订单工厂对象创建团购订单对象
        Order groupOrder = groupFactory.createOrder();
        groupOrder.process(); // 输出 "Processing group order..."
        
        // 创建促销订单工厂对象
        OrderFactory promotionFactory = new PromotionOrderFactory();
        // 使用促销订单工厂对象创建促销订单对象
        Order promotionOrder = promotionFactory.createOrder();
        promotionOrder.process(); // 输出 "Processing promotion order..."
    }
}

抽象工厂模式：

// 订单工厂接口
interface OrderFactory {
    NormalOrder createNormalOrder();
    GroupOrder createGroupOrder();
    PromotionOrder createPromotionOrder();
}

// 订单工厂实现类
class ConcreteOrderFactory implements OrderFactory {
    public NormalOrder createNormalOrder() {
        return new ConcreteNormalOrder();
    }
    public GroupOrder createGroupOrder() {
        return new ConcreteGroupOrder();
    }
    public PromotionOrder createPromotionOrder() {
        return new ConcretePromotionOrder();
    }
}

// 普通订单接口
interface NormalOrder {
    void process();
}

// 团购订单接口
interface GroupOrder {
    void process();
}

// 促销订单接口
interface PromotionOrder {
    void process();
}

// 具体普通订单类
class ConcreteNormalOrder implements NormalOrder {
    public void process() {
        System.out.println("Processing concrete normal order...");
    }
}

// 具体团购订单类
class ConcreteGroupOrder implements GroupOrder {
    public void process() {
       System.out.println("Processing concrete group order...");
    }
}

// 具体促销订单类
class ConcretePromotionOrder implements PromotionOrder {
    public void process() {
        System.out.println("Processing concrete promotion order...");
    }
}

// 客户端代码
class Client {
    public static void main(String[] args) {
        // 创建具体订单工厂对象
        OrderFactory factory = new ConcreteOrderFactory();
        
        // 使用具体订单工厂对象创建具体普通订单对象
        NormalOrder normalOrder = factory.createNormalOrder();
        normalOrder.process(); // 输出 "Processing concrete normal order..."
        
        // 使用具体订单工厂对象创建具体团购订单对象
        GroupOrder groupOrder = factory.createGroupOrder();
        groupOrder.process(); // 输出 "Processing concrete group order..."
        
        // 使用具体订单工厂对象创建具体促销订单对象
        PromotionOrder promotionOrder = factory.createPromotionOrder();
        promotionOrder.process(); // 输出 "Processing concrete promotion order..."
    }
}

总结

工厂模式是一种创建型模式，它提供了一种创建对象的最佳方式，将对象的创建和使用分离开来，从而降低了系统的耦合度。

工厂模式的优点在于：

• 将对象的创建和使用分离，降低了系统的耦合度，客户端代码只需要关心抽象产品类和工厂类，而无需关心具体产品类的实现及其创建过程。
• 可以通过工厂方法来控制对象的创建过程，从而灵活地适应不同的需求。
• 可以将对象的创建过程集中在一个工厂类中，便于统一管理和维护。

工厂模式的缺点在于：

• 增加了系统的复杂度，引入了新的类和接口，增加了代码量和理解难度。
• 工厂类需要知道所有具体产品类的实现细节，当具体产品类发生变化时，可能需要修改工厂类的代码。
• 工厂模式可能会导致系统中类的数量增加，增加了系统的维护成本。

总的来说，工厂模式是一种非常常用的设计模式，它可以方便地创建对象，降低系统的耦合度，提高代码的可维护性。在实际开发中，可以根据具体情况选择不同的工厂模式来解决问题，比如简单工厂模式、工厂方法模式、抽象工厂模式等。