Java设计模式（工厂模式）

        工厂模式用于封装对象的创建过程，使代码更具灵活性和可维护性。它通过定义一个创建对象的接口，由子类决定实例化哪个类。

简单工厂模式

简单工厂模式通过一个工厂类根据输入条件创建不同类型的对象，但不符合开闭原则

interface Product {
    void show();
}

class ProductA implements Product {
    @Override
    public void show() {
        System.out.println("Product A");
    }
}

class ProductB implements Product {
    @Override
    public void show() {
        System.out.println("Product B");
    }
}

class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            default:
                throw new IllegalArgumentException("Invalid type");
        }
    }
}

// 使用
Product product = SimpleFactory.createProduct("A");
product.show();
 

工厂方法模式

工厂方法模式将对象创建延迟到子类，每个子类负责一种具体产品的创建，符合开闭原则。

interface Product {
    void show();
}

class ProductA implements Product {
    @Override
    public void show() {
        System.out.println("Product A");
    }
}

class ProductB implements Product {
    @Override
    public void show() {
        System.out.println("Product B");
    }
}

interface Factory {
    Product createProduct();
}

class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

// 使用
Factory factory = new FactoryA();
Product product = factory.createProduct();
product.show();
 

抽象工厂模式

抽象工厂模式用于创建一系列相关或依赖的对象，无需指定具体类。适合产品族（多个关联产品）的创建。

interface CPU {
    void process();
}

interface RAM {
    void store();
}

class IntelCPU implements CPU {
    @Override
    public void process() {
        System.out.println("Intel CPU processing");
    }
}

class SamsungRAM implements RAM {
    @Override
    public void store() {
        System.out.println("Samsung RAM storing");
    }
}

interface ComputerFactory {
    CPU createCPU();
    RAM createRAM();
}

class HighEndFactory implements ComputerFactory {
    @Override
    public CPU createCPU() {
        return new IntelCPU();
    }
    @Override
    public RAM createRAM() {
        return new SamsungRAM();
    }
}

// 使用
ComputerFactory factory = new HighEndFactory();
CPU cpu = factory.createCPU();
RAM ram = factory.createRAM();
cpu.process();
ram.store();
 

适用场景

• 简单工厂模式：对象创建逻辑简单，且无需频繁扩展。
• 工厂方法模式：需要支持多种产品，且可能动态扩展。
• 抽象工厂模式：需要创建多个关联产品（如不同操作系统下的UI组件）。

通过工厂模式，可以解耦客户端代码与具体类，提升系统的可扩展性和可维护性。