工厂模式系列

说明：

工厂模式属于创建型模式，它将对象的使用者与该对象的创建逻辑进行分离（降低耦合度），单独抽象出一个角色用来负责创建工作，这个角色就是工厂类。
在某些业务场景，创建对象时可能需要做一些逻辑判断以及前置处理等等，工厂类将一个对象的创建过程及细节进行封装，使用者只需要告诉工厂类需要哪个对象实例即可，无须关心创建细节。
工厂模式根据其具体的实现方式，大概分为以下三种：

1. 简单工厂模式

定义

简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例。

代码案例

/**
 * @program: factory
 * @description: 手机工厂类
 * @author: wxw
 * @create: 2023-12-24 15:37
 **/
public class IphoneFactory {

    public static IPhone createIPhone(String name){
        if ("Apple".equals(name)){
            return new Apple();
        }else if ("OPPO".equals(name)){
            return new Oppo();
        }else {
            return null;
        }
    }
}

/**
 * @program: factory
 * @description: 简单工程测试类
 * @author: wxw
 * @create: 2023-12-24 15:34
 **/
public class SimpleFactoryTest {

    public static void main(String[] args) {
        /**
         * 没有使用简单工厂模式时，创建对象的步骤由调用方实现
         */
        IPhone iPhone = new Apple();
        iPhone.callOut();

        IPhone oppo = new Oppo();
        oppo.callOut();

        System.out.println("========================================");

        /**
         * 使用简单工厂模式时，创建对象的步骤交给工厂类
         */
        IPhone apple = IphoneFactory.createIPhone("Apple");
        apple.callOut();
        IPhone oppo1 = IphoneFactory.createIPhone("OPPO");
        oppo1.callOut();
    }
}

总结

简单工厂就是创建一个工厂类，专门用来创建某类产品的实例，用户只需要告诉工厂类创建哪个产品，而不需要关心具体的创建细节。
简单工厂结构简单，标准度低，几乎可以创建任何的产品实例。但是如果创建的产品实例种类过于繁多、复杂，就会影响工厂类的健壮性，每次修改、新增产品实例都会改动工厂类，不符合开闭原则。

2. 工厂方法模式

定义

工厂方法模式（Factory Method Pattern）是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。

代码案例

/**
 * @program: factory
 * @description: 手机工厂接口
 * @author: wxw
 * @create: 2023-12-24 17:14
 **/
public interface IIphoneFactory {

    IPhone createIPhone();
}

/**
 * @program: factory
 * @description: 苹果手机工厂
 * @author: wxw
 * @create: 2023-12-24 17:17
 **/
public class AppleIPhoneFactroy implements IIphoneFactory {

    @Override
    public IPhone createIPhone() {
        return new Apple();
    }
}

/**
 * @program: factory
 * @description: OPPO手机工厂
 * @author: wxw
 * @create: 2023-12-24 17:18
 **/
public class OppoIPhoneFactory implements IIphoneFactory {

    @Override
    public IPhone createIPhone() {
        return new Oppo();
    }
}

/**
 * @program: factory
 * @description: 工厂方法模式测试类
 * @author: wxw
 * @create: 2023-12-24 17:20
 **/
public class factoryMehtodTest {

    public static void main(String[] args) {
        /**
         * 工厂方法将简单工厂的创建细节进行了分配，不同的产品使用不同工厂类创建，这些工厂类需要遵守一同个规范
         */
        IIphoneFactory appleIphoneFactory = new AppleIPhoneFactroy();
        IPhone apple = appleIphoneFactory.createIPhone();
        apple.callOut();

        IIphoneFactory oppoIphoneFactory = new OppoIPhoneFactory();
        IPhone oppo = oppoIphoneFactory.createIPhone();
        oppo.callOut();
    }

}

总结

工厂方法模式是在简单工厂模式的基础上对工厂进行抽象，创建一个工厂的接口，让具体实现这个接口的工厂类来创建对象实例，符合开闭原则。

3. 抽象工厂模式

定义

抽象工厂模式（Abastract Factory Pattern）是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类。

代码案例

/**
 * @program: factory
 * @description: 手机工厂接口
 * @author: wxw
 * @create: 2023-12-24 18:09
 **/
public interface IIphoneFactroy {

    /**
     * 生产手机
     * @return
     */
    IPhone createIPhone();

    /**
     * 生产耳机
     * @return
     */
    IHeadset createHeadset();

}

/**
 * @program: factory
 * @description: 苹果手机工厂
 * @author: wxw
 * @create: 2023-12-24 18:15
 **/
public class AppleIphoneFactory implements IIphoneFactroy{
    @Override
    public IPhone createIPhone() {
        return new Apple();
    }

    @Override
    public IHeadset createHeadset() {
        return new AppleHeadset();
    }
}

/**
 * @program: factory
 * @description: OPPO手机工厂
 * @author: wxw
 * @create: 2023-12-24 18:16
 **/
public class OppoIphoneFactory implements IIphoneFactroy{
    @Override
    public IPhone createIPhone() {
        return new Oppo();
    }

    @Override
    public IHeadset createHeadset() {
        return new OppoHeadset();
    }
}

/**
 * @program: factory
 * @description: 抽象工厂测试类
 * @author: wxw
 * @create: 2023-12-24 18:15
 **/
public class AbstractFactoryTest {

    public static void main(String[] args) {
        /**
         * 抽象工厂在工厂方法的基础上，每个工厂类需要创建不同的产品类型
         */
        IIphoneFactroy appleIphoneFactory = new AppleIphoneFactory();
        appleIphoneFactory.createIPhone().callOut();
        appleIphoneFactory.createHeadset().makeSound();

        IIphoneFactroy oppoIphoneFactory = new OppoIphoneFactory();
        oppoIphoneFactory.createIPhone().callOut();
        oppoIphoneFactory.createHeadset().makeSound();
    }
}

总结

抽象工厂就是抽象出一个工厂类，定义多个创建不同产品类型的抽象方法，然后让每个具体的工厂类对其进行实现，它解决了产品族与产品等级结构的问题，由于结构过于复杂，每次新增产品等级结构具体的子工厂都需要改动，不符合开闭原则。