工厂模式

核心本质：

实例化对象不使用new，用工厂方法创建对象
使用工厂统一管理对象的创建，将调用者跟实现类解耦

三种模式：

1. 简单工厂模式

建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

优点是比较好理解，简单易操作。
缺点是类的创建依赖工厂类，如果想要拓展程序，必须对工厂类进行修改，这违反了设计模式的开闭原则（OCP），即对扩展开放，对修改关闭。

手机接口类：

public interface Phone {
    public void call();
}
123

两个手机实现类：

public class IPhone implements Phone{
    @Override
    public void call() {
        System.out.println("用苹果手机打电话！");
    }
}
123456
public class MPhone implements Phone{
    @Override
    public void call() {
        System.out.println("用小米手机打电话！");
    }
}

生产手机的工厂类：

public class PhoneFactory {
    public Phone create(String type){
        if (type.equals("IPhone")){
            return new IPhone();
        }else if (type.equals("MPhone")){
            return new MPhone();
        }else
            return null;
    }
}

测试类：

public class Test {

    public static final String IPhone = "IPhone";

    public static final String MPhone = "MPhone";

    public static void main(String[] args) {
        // 生产小米手机
        PhoneFactory factory1 = new PhoneFactory();
        factory1.create(MPhone).call();

        // 生产苹果手机
        PhoneFactory factory2 = new PhoneFactory();
        factory2.create(IPhone).call();
    }
}

运行结果：

用小米手机打电话！
用苹果手机打电话！
12

2. 工厂方法模式

对简单工厂模式的改进，使用一个工厂接口，创建多个工厂类，每个工厂创建对应的对象。

工厂方法模式，创建一个工厂接口和创建多个工厂实现类，一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。有利于代码的维护和扩展。

工厂接口：

public interface PhoneFactory {
    public Phone create();
}

小米手机工厂：

public class MPhoneFactory implements PhoneFactory{
    @Override
    public Phone create() {
        return new MPhone();
    }
}

苹果手机工厂：

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

测试类：

public class Test {
    public static void main(String[] args) {
        // 生产小米手机
        PhoneFactory factory1 = new MPhoneFactory();
        factory1.create().call();

        // 生产苹果手机
        PhoneFactory factory2 = new IPhoneFactory();
        factory2.create().call();
    }
}

运行结果：

用小米手机打电话！
用苹果手机打电话！

3. 抽象工厂模式

围绕一个超级工厂创建其他工厂，每个工厂可以生产不同类型的产品

抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
将工厂抽象成两层，抽象工厂和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂集合，更利于代码的维护和扩展。

超级工厂：

public interface Factory {

    public Phone createPhone();

    public Book createBook();
}

苹果工厂：

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

    @Override
    public Book createBook() {
        return new MacBook();
    }
}

小米工厂：

public class XiaoMiFactory implements Factory{
    @Override
    public Phone createPhone() {
        return new MPhone();
    }

    @Override
    public Book createBook() {
        return new MiBook();
    }
}

电脑接口类：

public interface Book {
    public void play();
}

电脑接口的两个实现类：

public class MacBook implements Book{
    @Override
    public void play() {
        System.out.println("用苹果电脑打游戏！");
    }
}
123456
public class MiBook implements Book{
    @Override
    public void play() {
        System.out.println("用小米电脑打游戏！");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        // 实例化苹果工厂，生产苹果手机和电脑
        Factory factory = new AppleFactory();
        factory.createBook().play();
        factory.createPhone().call();

        // 实例化小米工厂，生产小米手机和电脑
        Factory factory1 = new XiaoMiFactory();
        factory1.createBook().play();
        factory1.createPhone().call();
    }
}

运行结果：

用苹果电脑打游戏！
用苹果手机打电话！
用小米电脑打游戏！
用小米手机打电话！
1234

抽象工厂设计模式是一种创建型设计模式，其主要特点是将一组相关或相互依赖的对象的创建交给一个抽象工厂接口，由具体的工厂类来实现这个接口，从而实现对象的创建。它的主要特点包括：

封装了对象的创建过程：抽象工厂模式将对象的创建过程封装在一个接口中，客户端只需要通过该接口来创建对象，无需关心对象的具体创建过程和类名。
提供一组相关对象：抽象工厂模式通常用于创建一组相关或相互依赖的对象，这些对象之间有一定的关联关系。
支持多种实现：通过定义抽象工厂接口和具体工厂类，可以支持不同的实现，从而在运行时选择不同的工厂来创建不同的对象。
与单一工厂模式的区别：抽象工厂模式与简单工厂模式（单一工厂模式）不同，简单工厂模式通过一个工厂类来创建所有对象，而抽象工厂模式使用一个工厂接口和多个具体工厂类来创建一组相关对象。
提供了一定程度的灵活性：由于抽象工厂模式封装了对象的创建过程，当需要更换或添加新的产品族时，只需要实现新的工厂类和产品类，无需修改客户端代码。

抽象工厂模式适用于以下场景：

系统需要一组相关或相互依赖的对象，并希望对其进行统一管理和创建。
系统需要在不同的平台或环境下使用不同的对象实现。

总体而言，抽象工厂设计模式提供了一种创建对象的灵活方式，能够更好地支持系统的扩展和维护。但需要根据具体的应用场景来决定是否使用该模式，因为它会引入更多的抽象层次和类，增加了代码的复杂性。

目录CONTENT

工厂模式

工厂模式

1. 简单工厂模式

2. 工厂方法模式

3. 抽象工厂模式

评论区