十年JAVA搬砖路——工厂模式

旧城等待， 2023-10-13 21:46 20阅读 0赞

### 定义 ###

**工厂模式**是一种创建性设计模式，它提供用于创建对象的接口或抽象类。它封装对象创建逻辑，并允许客户端代码在不知道特定类或实现详细信息的情况下创建对象。  
工厂模式背后的主要思想是将对象创建的责任委托给单独的工厂类。此工厂类包含确定要实例化并返回到客户端代码的具体类的必要逻辑。这样，客户端代码仅与工厂接互，使其更加灵活，并与实际的对象创建过程分离。  
工厂模式通常用于需要集中式对象创建、基于运行时条件创建对象的灵活性以及客户端代码与具体实现分离的方案。它有助于提高代码的可维护性、可伸缩性和可测试性。

### **分类** ###

**1. 简单工厂模式**：这是工厂模式的基本形式。它涉及一个单一的工厂类，该类具有根据特定参数或输入创建和返回对象的方法。工厂类封装了创建逻辑并返回适当的对象。但是，它违反了开闭原则，因为添加新类型的对象时需要修改工厂类。  
案例：

//抽象类
    public abstract class Pizza {
        public abstract void prepare();
        public abstract void bake();
        public abstract void cut();
        public abstract void box();
    }
    //具体类
     public class CheesePizza extends Pizza {
        // Implementation of CheesePizza class
    }
    //具体类
     public class PepperoniPizza extends Pizza {
        // Implementation of PepperoniPizza class
    }
    //具体类
     public class VeggiePizza extends Pizza {
        // Implementation of VeggiePizza class
    }
    //简单工厂类（如果添加新的Pizza类型还需要更改该类）
    public class SimplePizzaFactory {
        public Pizza createPizza(String type) {
            Pizza pizza = null;
             if (type.equals("cheese")) {
                pizza = new CheesePizza();
            } else if (type.equals("pepperoni")) {
                pizza = new PepperoniPizza();
            } else if (type.equals("veggie")) {
                pizza = new VeggiePizza();
            }
             return pizza;
        }
    }
    //具体使用工厂类创建各种类。
    public class PizzaStore {
        private SimplePizzaFactory pizzaFactory;
         public PizzaStore(SimplePizzaFactory pizzaFactory) {
            this.pizzaFactory = pizzaFactory;
        }
         public Pizza orderPizza(String type) {
            Pizza pizza = pizzaFactory.createPizza(type);
             pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
             return pizza;
        }
    }
    //测试类
     public class Test {
        public static void main(String[] args) {
            SimplePizzaFactory pizzaFactory = new SimplePizzaFactory();
            PizzaStore pizzaStore = new PizzaStore(pizzaFactory);
             Pizza cheesePizza = pizzaStore.orderPizza("cheese");
            Pizza pepperoniPizza = pizzaStore.orderPizza("pepperoni");
            Pizza veggiePizza = pizzaStore.orderPizza("veggie");
        }
    }

**2. 工厂方法模式**：这种模式定义了一个用于创建对象的接口或抽象类，但将实际创建委托给子类。每个子类负责创建特定类型的对象。这允许更灵活和可扩展性，因为可以通过创建新的子类添加新类型的对象，而无需修改现有代码。  
案例：

//抽象类
    public abstract class Vehicle {
        public abstract void drive();
    }
    public class Car extends Vehicle {
        // Implementation of Car class
    }
    public class Motorcycle extends Vehicle {
        // Implementation of Motorcycle class
    }
    public class Truck extends Vehicle {
        // Implementation of Truck class
    }
    //抽象工厂
    public abstract class VehicleFactory {
        public abstract Vehicle createVehicle();
    }
    //具体工厂
    public class CarFactory extends VehicleFactory {
        public Vehicle createVehicle() {
            return new Car();
        }
    }
    //具体工厂
    public class MotorcycleFactory extends VehicleFactory {
        public Vehicle createVehicle() {
            return new Motorcycle();
        }
    }
    //具体工厂
    public class TruckFactory extends VehicleFactory {
        public Vehicle createVehicle() {
            return new Truck();
        }
    }
    
    //测试
    public class Test {
        public static void main(String[] args) {
            VehicleFactory carFactory = new CarFactory();
            VehicleFactory motorcycleFactory = new MotorcycleFactory();
            VehicleFactory truckFactory = new TruckFactory();
             Vehicle car = carFactory.createVehicle();
            Vehicle motorcycle = motorcycleFactory.createVehicle();
            Vehicle truck = truckFactory.createVehicle();
             car.drive();
            motorcycle.drive();
            truck.drive();
        }
    }

**3. 抽象工厂模式**：这种模式为创建相关或依赖对象的系列提供了一个接口或抽象类。它封装了多个对象的创建，这些对象被设计为一起工作。客户端代码与抽象工厂接口交互，具体工厂实现创建相关对象。当存在多个对象系列且客户端代码需要一次创建一系列对象时，此模式非常有用。  
案例：  
让我们考虑一个场景，其中我们有一个支持不同操作系统（如 Windows 和 macOS）的 GUI（图形用户界面）框架。每个操作系统都有自己的一组 UI 组件，例如按钮和复选框。我们可以使用抽象工厂模式为每个操作系统创建一系列相关的 UI 组件。  
首先，我们定义抽象的 UI 组件类：

//公共工作的对象抽象
    public interface Button {
        void render();
    }
     public interface Checkbox {
        void render();
    }
    //创建不同需求的具体实例
    public class WindowsButton implements Button {
        public void render() {
            System.out.println("Rendering a Windows button");
        }
    }
     public class WindowsCheckbox implements Checkbox {
        public void render() {
            System.out.println("Rendering a Windows checkbox");
        }
    }
     public class MacOSButton implements Button {
        public void render() {
            System.out.println("Rendering a macOS button");
        }
    }
     public class MacOSCheckbox implements Checkbox {
        public void render() {
            System.out.println("Rendering a macOS checkbox");
        }
    }
    //创建一个抽象工厂类
    public interface GUIFactory {
        Button createButton();
        Checkbox createCheckbox();
    }
    // 具体的工厂，这里和工厂模式思想一样。
    public class WindowsFactory implements GUIFactory {
        public Button createButton() {
            return new WindowsButton();
        }
         public Checkbox createCheckbox() {
            return new WindowsCheckbox();
        }
    }
     public class MacOSFactory implements GUIFactory {
        public Button createButton() {
            return new MacOSButton();
        }
         public Checkbox createCheckbox() {
            return new MacOSCheckbox();
        }
    }
    //具体的应用
    public class Application {
        private GUIFactory factory;
        private Button button;
        private Checkbox checkbox;
         public Application(GUIFactory factory) {
            this.factory = factory;
        }
         public void createUI() {
            button = factory.createButton();
            checkbox = factory.createCheckbox();
        }
         public void renderUI() {
            button.render();
            checkbox.render();
        }
    }
     public class Test {
        public static void main(String[] args) {
            Application windowsApp = new Application(new WindowsFactory());
            windowsApp.createUI();
            windowsApp.renderUI();
             Application macApp = new Application(new MacOSFactory());
            macApp.createUI();
            macApp.renderUI();
        }
    }

### **优点：** ###

**1. 封装**：对象的创建封装在工厂内，将其与客户端代码分离。这增强了代码的可维护性和灵活性。  
**2. 松耦合**：客户端代码只与工厂接互，减少对具体类的依赖。这样可以更轻松地替换不同类型的对象。  
**3.单一责任原则**：工厂负责创造对象，坚持有单一理由改变的原则。  
**4.代码可重用性**：工厂可以复用创建多个相同类型的对象，减少代码重复。

### **缺点：** ###

\*\*1. 复杂性：\*\*实现工厂模式可能会给代码库带来额外的复杂性，尤其是在处理大量具体类和依赖项时。  
**2. 增加代码开销**：工厂模式需要创建额外的类，这可能会导致代码开销和复杂性增加。  
\*\*3. 灵活性降低：\*\*工厂模式可能不适合对象创建逻辑需要在运行时高度动态或可配置的方案。  
**4. 增加初始开发工作量**：实现工厂模式需要前期设计和开发工作，这对于简单或小规模应用程序可能不合理。

### 常见使用场景 ###

**1. 对象创建**：当应用程序需要根据某些条件或参数创建不同类型的对象时，可以使用工厂模式来封装对象创建逻辑。  
**2. 依赖关系注入**：当应用程序使用依赖关系注入来管理对象依赖关系时，工厂模式可用于创建和注入所需的依赖关系。  
**3. 动态对象创建**：当应用程序需要在运行时动态创建对象时，可以使用工厂模式提供灵活且可扩展的方式来创建对象。  
**4. 测试**：当应用程序需要创建模拟对象以进行测试时，可以使用工厂模式来创建模拟真实对象行为的模拟对象。  
\*\*5. 框架和库：\*\*在开发框架或库时，工厂模式可用于为客户端提供创建和与对象交互的标准化方式。