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

50 阅读5分钟

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..."
    }
}

总结

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

工厂模式的优点在于

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

工厂模式的缺点在于

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

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