JAVA设计模式-创建型模式(如何创建对象)-工厂模式学习

前言：

在大多情况下，我们都是用new去实例化对象。但是，有时候有的对象的类别有很多种，又存在着共性，就好比如手机，有华为，苹果，小米等品牌，如果是一个一个去创建类，那就需要创建很多，因此就需要用到工厂模式。

工厂模式分为 简单工厂模式、工厂模式、抽象工厂模式，下面以电子产品为场景来写DEMO以及模式的优缺点学习

1-1 简单工厂模式

介绍：简单工厂模式就是定义产品接口，然后定义接口去实现这个接口。

先定一个枚举类，手机品牌有华为，苹果等等。。。

public enum PhoneEnum {
    HUAWEI("HUAWEI","华为"),
    IPHONE("IPHONE","苹果");

    private String code;
    private String name;

    PhoneEnum(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    /***
     * <简述>提供对外获取
     * <详细描述>
     * @author syf
     * @date 2023/8/14 10:40
     * @param code
     * @return com.ratelimiter.enums.PayTypes
     */
    public static PhoneEnum getEnum(String code){
        for(PhoneEnum en:PhoneEnum.values()){
            if(en.code.equals(code)){
                return en;
            }
        }
        return null;
    }

}

1-1-1 定义产品类接口

定义手机类产品接口，具有打电话功能

public interface Phone {
    //手机打电话功能
    void call();
}

1-1-2 定义产品类

定义华为手机类产品，实现手机接口。

public class HuaWei implements Phone{

    @Override
    public void call() {
        System.out.println("使用华为手机打电话。。。。。");
    }
}

定义iPhone手机产品类，实现手机接口

public class Iphone implements Phone{
    
    @Override
    public void call() {
        System.out.println("使用苹果手机打电话。。。。。");
    }
}

1-1-3定义工工厂类，用于生产手机类

@Component
public class easyFactory {

    public Phone CreatePhone(String type){
        PhoneEnum enums = PhoneEnum.getEnum("HUAWEI");
        if (null == enums){
            return  null;
        }
        //根据传入类型返回对象实例
        return ("HUAWEI").equals(enums.getCode()) ?  new HuaWei() :  new Iphone();
    }
}

1-1--4测试以及结果展示

@SpringBootTest
public class FactoryTest {
    @org.junit.jupiter.api.Test
    public void test() {
        easyFactory easyFactory = new easyFactory();
        Phone huawei = easyFactory.CreatePhone(PhoneEnum.getEnum("HUAWEI").getCode());
        huawei.call();
    }

}

结果

使用华为手机打电话。。。。。

总结：通过以上编写，

优点：客户端无需关心具体产品的创建过程，只需要通过工厂类来获取所需的产品对象，使得代码更加灵活可扩展。不需要修改业务代码。完成了解耦。

缺点：需要注意的是，简单工厂模式的缺点是当新增产品时，需要修改工厂类的代码，不符合开闭原则。并且比如华为要生产PAD还要新增相关的接口，工厂类也要编写，显得十分臃肿。

2-2 工厂方法模式（基于以上简单工厂模式已创建的类）

工厂方法模式（Factory Method Pattern）是一种常用的创建型设计模式，它通过定义一个创建对象的接口，但让子类决定具体实例化哪个类。这样，工厂方法模式将对象的实例化延迟到子类中进行，符合开闭原则。

2-2-1定义工厂接口

UML 类图展示

/**
 * <简述>
 * <详细描述>
 * @author syf
 * @date 2023年08月16日 22:10
 */
public interface Factory{
    //生产手机
    public abstract Phone createPhone();
}

 2-2-2 定义具体的工厂类

华为工厂类

public class HUAWEIFactory implements Factory{
    @Override
    public Phone createPhone() {
        return new HuaWei();
    }
}

苹果工厂类

public class IPhoneFactory implements Factory{
    @Override
    public Phone createPhone() {
        return new Iphone();
    }
}

 测试

  @org.junit.jupiter.api.Test
    public void test1() {
        Factory abstractFactory = new HUAWEIFactory();
        Phone phone = abstractFactory.createPhone();
        phone.call();
    }

结果：

使用华为手机打电话。。。。。 

 1-3抽象工厂模式

应用场景

产品和产品族的概念在设计模式中得到了广泛应用。例如，抽象工厂模式用于创建一组相关的产品族，工厂方法模式用于创建单个产品对象，建造者模式用于逐步构建复杂的产品对象等

介绍：

产品族：一系列相关的产品，整合到一起使他们有关联性。

产品等级：相同的产品标准（即同一个继承体系），不同的特征区别。

UML展示

1-3-1新增PAd看抖音

public interface Pad {

    //刷抖音
    void watch();
}

华为pad

public class HuaWeiPad implements Pad{

    @Override
    public void watch() {
        System.out.println("使用华为pad看抖音。。。。。");
    }
}

 苹果pad

public class IphonePad implements Pad{
    
    @Override
    public void watch() {
        System.out.println("使用苹果pad看抖音。。。。。");
    }
}

1-3-2 定义抽象类去生成整合产品

public abstract class AbstractFactory {
    public void init(){
        System.out.println("打开支付链接");
    }
    //创建手机
    public abstract Phone creatPhone();
    //创建pad
    public abstract Pad createPad();
}

华为去继承抽象类

public class HUAWEIFactoryNew  extends AbstractFactory{
    @Override
    public Phone creatPhone() {
        return new HuaWei();
    }

    @Override
    public Pad createPad() {
        return new HuaWeiPad();
    }
}

 苹果继承抽象类

public class IPhoneFactoryNew extends AbstractFactory{
    @Override
    public Phone creatPhone() {
        return new Iphone();
    }

    @Override
    public Pad createPad() {
        return new IphonePad();
    }
}

测试以及结果展示

  @org.junit.jupiter.api.Test
    public void test2() {
         AbstractFactory abstractFactory = new HUAWEIFactoryNew();
        Phone phone = abstractFactory.creatPhone();
        phone.call();

        AbstractFactory abstractFactory1 = new IPhoneFactoryNew();
        Pad pad = abstractFactory1.createPad();
        pad.watch();
    }

使用华为手机打电话。。。。。
使用苹果pad看抖音。。。。。

 总结：
工厂模式适用于需要创建单一类型的对象，而抽象工厂模式适用于需要创建一组相关对象的情况。工厂模式相对简单，而抽象工厂模式更加灵活。选择使用哪种模式取决于具体的需求和设计结构。