深入解析工厂模式：简单工厂、工厂方法与抽象工厂-CSDN博客

工厂模式是软件工程中一种常用的创建型设计模式，它提供了一种创建对象的最佳方式，而无需直接指定具体的类。工厂模式的核心思想是将对象的创建逻辑封装起来，使得客户端可以专注于使用对象，而无需关心对象的创建细节。根据工厂模式的复杂程度和应用场景，可以将其分为三种主要形式：简单工厂模式、工厂方法模式和抽象工厂模式。本文将通过手机生产的案例，详细解析这三种工厂模式的基本原理、实现方法及其适用场景。

1. 简单工厂模式（Simple Factory Pattern）

1.1 基本原理

简单工厂模式是最基础的工厂模式，它通过一个工厂类来封装对象的创建逻辑。客户端通过向工厂类传递一个参数（如类型标识），工厂类根据参数决定创建哪种具体的产品对象。这种模式的优点是简单易用，但缺点是工厂类集中了所有产品的创建逻辑，扩展性较差。

1.2 实现过程

为了实现简单工厂模式，我们需要定义一个抽象产品接口（或抽象类），具体的产品类实现该接口，最后通过工厂类根据参数创建具体的产品对象。

1.3 示例代码

抽象产品接口

public interface Phone {
    void make();
}

具体产品类：小米手机

public class MiPhone implements Phone {
    @Override
    public void make() {
        System.out.println("Making MiPhone...");
    }
}

具体产品类：苹果手机

public class IPhone implements Phone {
    @Override
    public void make() {
        System.out.println("Making IPhone...");
    }
}

工厂类

public class PhoneFactory {
    public Phone createPhone(String type) {
        if ("MiPhone".equalsIgnoreCase(type)) {
            return new MiPhone();
        } else if ("IPhone".equalsIgnoreCase(type)) {
            return new IPhone();
        } else {
            return null;
        }
    }
}

客户端代码

public class Client {
    public static void main(String[] args) {
        PhoneFactory factory = new PhoneFactory();
        Phone miPhone = factory.createPhone("MiPhone");
        miPhone.make(); // 输出：Making MiPhone...

        Phone iPhone = factory.createPhone("IPhone");
        iPhone.make(); // 输出：Making IPhone...
    }
}

1.4 uml类图（PlantUML代码）

@startuml
interface Phone {
  +make()
}

class MiPhone {
  +make()
}

class IPhone {
  +make()
}

class PhoneFactory {
  +createPhone(String): Phone
}

Phone <|.. MiPhone
Phone <|.. IPhone
PhoneFactory --> Phone : createPhone
@enduml

1.5 适用场景

简单工厂模式适用于产品种类较少且不经常变动的场景。由于所有产品的创建逻辑都集中在一个工厂类中，因此扩展新的产品类型时需要修改工厂类的代码，这违反了开闭原则。

2. 工厂方法模式（Factory Method Pattern）

2.1 基本原理

工厂方法模式是简单工厂模式的改进，它通过定义一个抽象工厂接口，将具体的创建逻辑延迟到子类中实现。每个子类工厂负责创建一种具体的产品对象。这种模式的优点是符合开闭原则，易于扩展新的产品类型，但缺点是需要定义多个工厂类。

2.2 实现过程

为了实现工厂方法模式，我们需要定义一个抽象工厂接口，具体工厂类实现该接口，具体实现创建特定产品对象的逻辑。

2.3 示例代码

抽象工厂接口

public interface PhoneFactory {
    Phone createPhone();
}

具体工厂类：小米手机工厂

public class MiPhoneFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new MiPhone();
    }
}

具体工厂类：苹果手机工厂

public class IPhoneFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new IPhone();
    }
}

客户端代码

public class Client {
    public static void main(String[] args) {
        PhoneFactory miFactory = new MiPhoneFactory();
        Phone miPhone = miFactory.createPhone();
        miPhone.make(); // 输出：Making MiPhone...

        PhoneFactory iPhoneFactory = new IPhoneFactory();
        Phone iPhone = iPhoneFactory.createPhone();
        iPhone.make(); // 输出：Making IPhone...
    }
}

2.4 uml类图（PlantUML代码）

@startuml
interface Phone {
  +make()
}

class MiPhone {
  +make()
}

class IPhone {
  +make()
}

interface PhoneFactory {
  +createPhone(): Phone
}

class MiPhoneFactory {
  +createPhone(): Phone
}

class IPhoneFactory {
  +createPhone(): Phone
}

Phone <|.. MiPhone
Phone <|.. IPhone
PhoneFactory <|.. MiPhoneFactory
PhoneFactory <|.. IPhoneFactory
@enduml

2.5 适用场景

工厂方法模式适用于产品种类较多且可能经常变动的场景。由于每个具体工厂类只负责创建一种具体的产品对象，因此扩展新的产品类型时只需添加新的具体工厂类，而无需修改现有的工厂类代码。

3. 抽象工厂模式（Abstract Factory Pattern）

3.1 基本原理

抽象工厂模式是工厂方法模式的进一步扩展，它提供了一个创建一系列相关或依赖对象的接口，而不需要指定它们的具体类。这种模式适用于产品族的创建，即一组相关的产品对象需要一起使用。抽象工厂模式通过定义一个抽象工厂接口，包含多个创建不同产品对象的方法，具体工厂类实现这些方法，分别创建不同产品族中的产品对象。

3.2 实现过程

为了实现抽象工厂模式，我们需要定义一个抽象工厂接口，具体工厂类实现该接口，具体实现创建一组相关产品对象的逻辑。

3.3 示例代码

抽象产品接口：手机

public interface Phone {
    void make();
}

具体产品类：小米手机

public class MiPhone implements Phone {
    @Override
    public void make() {
        System.out.println("Making MiPhone...");
    }
}

具体产品类：苹果手机

public class IPhone implements Phone {
    @Override
    public void make() {
        System.out.println("Making IPhone...");
    }
}

抽象产品接口：电脑

public interface PC {
    void make();
}

具体产品类：小米电脑

public class MiPC implements PC {
    @Override
    public void make() {
        System.out.println("Making MiPC...");
    }
}

具体产品类：苹果电脑

public class MAC implements PC {
    @Override
    public void make() {
        System.out.println("Making MAC...");
    }
}

抽象工厂接口

public interface AbstractFactory {
    Phone createPhone();
    PC createPC();
}

具体工厂类：小米工厂

public class MiFactory implements AbstractFactory {
    @Override
    public Phone createPhone() {
        return new MiPhone();
    }

    @Override
    public PC createPC() {
        return new MiPC();
    }
}

具体工厂类：苹果工厂

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone createPhone() {
        return new IPhone();
    }

    @Override
    public PC createPC() {
        return new MAC();
    }
}

客户端代码

public class Client {
    public static void main(String[] args) {
        AbstractFactory miFactory = new MiFactory();
        Phone miPhone = miFactory.createPhone();
        miPhone.make(); // 输出：Making MiPhone...
        PC miPC = miFactory.createPC();
        miPC.make(); // 输出：Making MiPC...

        AbstractFactory appleFactory = new AppleFactory();
        Phone iPhone = appleFactory.createPhone();
        iPhone.make(); // 输出：Making IPhone...
        PC mac = appleFactory.createPC();
        mac.make(); // 输出：Making MAC...
    }
}

3.4 uml类图（PlantUML代码）

@startuml
interface Phone {
  +make()
}

class MiPhone {
  +make()
}

class IPhone {
  +make()
}

interface PC {
  +make()
}

class MiPC {
  +make()
}

class MAC {
  +make()
}

interface AbstractFactory {
  +createPhone(): Phone
  +createPC(): PC
}

class MiFactory {
  +createPhone(): Phone
  +createPC(): PC
}

class AppleFactory {
  +createPhone(): Phone
  +createPC(): PC
}

Phone <|.. MiPhone
Phone <|.. IPhone
PC <|.. MiPC
PC <|.. MAC
AbstractFactory <|.. MiFactory
AbstractFactory <|.. AppleFactory
@enduml

3.5 适用场景

抽象工厂模式适用于产品族的创建场景，即一组相关的产品对象需要一起使用。这种模式的优点是可以创建一系列相关的产品对象，易于扩展新的产品族，但缺点是代码结构较为复杂，需要定义多个抽象和具体类。

总结

工厂模式是设计模式中非常重要的一种创建型模式，它通过封装对象的创建逻辑，使得客户端可以专注于使用对象，而无需关心对象的创建细节。本文通过手机生产的案例，详细解析了简单工厂模式、工厂方法模式和抽象工厂模式的基本原理、实现方法及其适用场景。在实际开发中，可以根据具体需求选择合适的工厂模式，以实现代码的高内聚、低耦合和易于扩展。

工厂模式参照：设计模式之工厂模式（factory pattern） - alpha_panda - 博客园