java设计模式：02-03-工厂方法模式

工厂方法模式（Factory Method Pattern）

工厂方法模式（Factory Method Pattern）定义了一个用于创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法使一个类的实例化延迟到其子类。它属于创建型设计模式。

工厂方法模式的应用场景

• 当一个类不知道它所需要创建的对象的类：工厂方法模式可以把对象的创建委托给子类来决定。
• 当一个类希望由其子类来指定要创建的对象：例如，框架开发时，框架定义了接口，具体的实现由应用程序提供。
• 当类的实例化操作需要集中管理，以便于后续扩展和维护。

工厂方法模式的实现方式

1. 简单工厂方法

思想：简单工厂方法定义一个静态方法，根据传入的参数决定要实例化的类，返回实例。这种方式不属于正式的设计模式，而是一种创建对象的简单方法。

实现方式：

interface Product {
    void use();
}

class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using Product A");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using Product B");
    }
}

class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("Unknown product type");
        }
    }
}

public class SimpleFactoryPattern {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();

        Product productB = SimpleFactory.createProduct("B");
        productB.use();
    }
}

优点：

• 简单易用，集中管理对象创建。

缺点：

• 违反开闭原则（对扩展开放，对修改关闭），每次增加新产品都需要修改工厂方法。
• 工厂方法的参数决定了产品类型，工厂类变得复杂。

2. 标准工厂方法

思想：标准工厂方法模式定义一个创建对象的接口，让子类决定实例化哪一个类。通过这种方式，把实例化操作延迟到子类。

实现方式：

interface Product {
    void use();
}

class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using Product A");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using Product B");
    }
}

interface Factory {
    Product createProduct();
}

class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public class FactoryMethodPattern {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

优点：

• 遵循开闭原则，可以通过增加新工厂来扩展产品，而不需要修改已有代码。
• 工厂方法可以隐藏对象创建的细节，提供更灵活的扩展性。

缺点：

• 增加了系统的复杂度，每增加一种产品都需要增加相应的工厂类。

3. 参数化工厂方法

思想：工厂方法可以通过参数化来创建不同类型的对象，这样可以减少工厂类的数量，但也会增加方法的复杂度。

实现方式：

interface Product {
    void use();
}

class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using Product A");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using Product B");
    }
}

abstract class Factory {
    abstract Product createProduct(String type);
}

class ConcreteFactory extends Factory {
    public Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("Unknown product type");
        }
    }
}

public class ParameterizedFactoryMethodPattern {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product productA = factory.createProduct("A");
        productA.use();

        Product productB = factory.createProduct("B");
        productB.use();
    }
}

优点：

• 可以通过一个工厂类创建多种类型的产品，减少类的数量。

缺点：

• 工厂方法变得复杂，违反单一职责原则。

总结

实现方式	优点	缺点
简单工厂方法	实现简单，集中管理对象创建	违反开闭原则，增加新产品需要修改工厂方法，工厂类变得复杂
标准工厂方法	遵循开闭原则，增加新产品只需增加相应工厂类，隐藏创建细节	增加了系统复杂度，每增加一种产品都需要增加相应的工厂类
参数化工厂方法	可以通过一个工厂类创建多种类型的产品，减少类的数量	工厂方法变得复杂，违反单一职责原则

不同的实现方式适用于不同的应用场景，选择哪种实现方式应根据具体的需求和系统的复杂度来决定。如果系统中需要频繁增加新产品类型，标准工厂方法是一个较好的选择。如果产品类型较少且创建逻辑简单，简单工厂方法和参数化工厂方法也可以考虑。