设计模式-工厂方法模式

1. 概念

工厂方法模式是一种创建型设计模式，它通过引入一个抽象工厂类来封装对象的创建过程。

2. 代码示例

2.1 简单工厂模式代码示例

问题分析：当需要增加新的具体产品时，需要修改简单工厂类的代码，这违反了开闭原则（对扩展开放，对修改封闭）。

java 复制代码

public class Phone {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

java 复制代码

public class BZPhone extends Phone {
    public BZPhone() {
        setName("BZ Phone");
    }
}

java 复制代码

public class HZPhone extends Phone {
    public HZPhone() {
        setName("HZ Phone");
    }
}

java 复制代码

public class PhoneSimpleFactory {

    private PhoneSimpleFactory() {}

    public static Phone getPhone(String phoneType) {
        Phone phone = null;
        if ("BZPhone".equals(phoneType)) {
            phone = new BZPhone();
        } else if ("HZPhone".equals(phoneType)) {
            phone = new HZPhone();
        }
        return phone;
    }
}

java 复制代码

public class MakePhoneTest {

    public static void main(String[] args) {
        Phone phone = PhoneSimpleFactory.getPhone("BZPhone");
        System.out.println(phone.getName() + "制造完成...");
        Phone phone2 = PhoneSimpleFactory.getPhone("HZPhone");
        System.out.println(phone2.getName() + "制造完成...");
    }
}

2.2 工厂方法模式代码示例

java 复制代码

class ElectronicsProduct {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

class BZPhone001 extends ElectronicsProduct {
    public BZPhone001() {
        setName("BZPhone001");
    }
}

class BZPC001 extends ElectronicsProduct {
    public BZPC001() {
        setName("BZPC001");
    }
}

class HZPhone001 extends ElectronicsProduct {
    public HZPhone001() {
        setName("HZPhone001");
    }
}

class HZPC001 extends ElectronicsProduct {
    public HZPC001() {
        setName("HZPC001");
    }
}

interface AbsFactory {
    ElectronicsProduct create(String type);
}

class BZFactory implements AbsFactory {

    @Override
    public ElectronicsProduct create(String type) {
        if ("Phone".equals(type)) {
            return new BZPhone001();
        } else if ("PC".equals(type)) {
            return new BZPC001();
        }
        return null;
    }
}

class HZFactory implements AbsFactory {

    @Override
    public ElectronicsProduct create(String type) {
        if ("Phone".equals(type)) {
            return new HZPhone001();
        } else if ("PC".equals(type)) {
            return new HZPC001();
        }
        return null;
    }
}

public class FactoryMethodTest {
    public static void main(String[] args) {
        HZFactory hzFactory = new HZFactory();
        ElectronicsProduct hzPhone = hzFactory.create("Phone");
        ElectronicsProduct hzPc = hzFactory.create("PC");
        System.out.println(hzPhone.getName() + "制造完成...");
        System.out.println(hzPc.getName() + "制造完成...");


        BZFactory bzFactory = new BZFactory();
        ElectronicsProduct bzPhone = bzFactory.create("Phone");
        ElectronicsProduct bzPc = bzFactory.create("PC");
        System.out.println(bzPhone.getName() + "制造完成...");
        System.out.println(bzPc.getName() + "制造完成...");
    }
}

UML类图

3. 作用

将产品的实例化延迟到具体工厂中完成

4. 工厂方法模式的优缺点

优点
- 不关心创建细节：用户只需要知道所需产品的工厂，无需关心创建的细节过程。
- 符合开闭原则：当需要加入新产品时，只需扩展新的工厂类而不必修改现有代码，提高了系统的可扩展性。
- 良好的封装性：具体的产品类被隐藏，调用者仅需提供产品类名称，使得代码结构清晰且易于维护。
缺点
- 增加复杂性：在添加新产品时，可能需要引入新的工厂类或者修改现有的工厂类，增加了系统的复杂度。
- 难以管理产品族的扩展：当产品种类增多时，可能导致工厂类的判断逻辑变得复杂，不容易维护。

5. 应用场景

重复代码：当创建对象时需要使用大量重复的代码，可以通过工厂方法模式来减少重复代码。
隐藏具体产品类：客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由对应的工厂创建。

6. JDK中的使用

集合框架：例如，当我们需要创建一个新的ArrayList或HashMap时，我们实际上是在使用工厂方法模式。这些类提供了一些静态工厂方法，如Collections.synchronizedList()，用于创建特定类型的对象。
线程池：Java的线程池（ThreadPoolExecutor）也使用了工厂方法模式。它提供了一些静态工厂方法，如Executors.newFixedThreadPool()，用于创建不同类型的线程池。
日期和时间API：Java 8引入了新的日期和时间API，其中包含了一些工厂方法，如LocalDate.now()和LocalDateTime.of()，用于创建日期和时间对象。
IO流：Java的IO流库中也使用了工厂方法模式。例如，我们可以使用FileInputStream.open()和FileOutputStream.open()等方法来创建输入/输出流对象。

7. 简单工厂vs工厂方法vs抽象工厂

	简单工厂	工厂方法	抽象工厂
模式特点	一个工厂创建所有产品	每个产品对应具体工厂	具体工厂创建多个具体产品
应用场景	产品线少，解耦客户端和具体产品	产品线较多	创建一系列相关产品