多种工厂模式

作用：
实现了创建者和调用者的分离

• 实例化对象不使用new，用工厂方法替代
• 将选择实现类，创建对象统一管理和控制。从而将调者跟我们的实现类解耦。

详细分类：

简单工厂模式
用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码）
工厂方法模式
用来生产同一等级结构中的固定产品（支持增加任意产品）
抽象工厂模式
围绕一个超级工厂创建其他工厂。该超级工厂称为其他工厂的工厂。

1. 简单工厂模式（静态工厂）

某种程度上不符合设计原则，但实际使用最多。

有一个演变过程，从最原始的方法 - 静态工厂方法

原始方法

定义一个接口（工厂），里面你写一个方法（机器），需要什么类型的产品就创建一个类实现这个接口和重新方法

public interface Car {
    public void name();
}

public class Tesla implements Car{
@Override
    public void name(){
        System.out.println("特斯拉！");
    }
}

public class WuLing implements Car{
@Override
    public void name(){
        System.out.println("五菱宏光！");
    }
}

public class Consumer {
    public static void main(String[] args) {
        // 接口，所有实现类
        Car car=new WuLing();
        Car car2=new Tesla();
        car.name();
        car2.name();
        // Car car = CarFactory.getCar("五菱");
        // car.name();
    }
}

有缺陷：
①设备和工厂是固定死的，不灵活
②需要知道所有接口和实现类才能使用

静态工厂方法

类中的所有方法都是静态的，需要向其中添加参数来返回不同的对象实例。

public class CarFactory {
    // 方法一
    public static Car getCar(String car){
        if(car.equals("五菱")){
            return new WuLing();
        }else if(car.equals("特斯拉")){
            return new Tesla();
        }else {
            return null;
        }
    }
    // 方法二
    public static Car getWuLing(){
        return new WuLing();
    }
    public static Car getTesla(){
        return new Tesla();
    }
}

public class Consumer {
    public static void main(String[] args) {
        // 接口，所有实现类
        // Car car=new WuLing();
        // Car car2=new Tesla();
        // car.name();
        // car2.name();
        Car car = CarFactory.getCar("五菱");
        Car car2 = CarFactory.getCar("特斯拉");
        car.name();
        car2.name();
    }
}

2.工厂方法模式

根据设计原则：工厂方法模式

根据实际业务：简单工厂模式（实际使用较多）

简单工厂模式，无乱咋样只要增加产品类，就需要修改已有类的！
所以有了工厂方法模式，来不修改已有类的前提下，可以增加产品类。
工作模型：

实现：

3、抽象工厂模式

定义:抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类

适用场景:

• 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
• 强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量的重复代码（一次一起全部创建，很少更改）
• 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现

优点:

• 具体产品在应用层的代码隔离，无需关心创建的细节
• 将一个系列的产品统一到一起创建

缺点:

• 规定了所有可能被创建的产品集合，产品簇中扩展新的产品困难;
• 增加了系统的抽象性和理解难度

package factory.abstract_2;
public class Client {
    public static void main(String[] args) {
        System.out.println("===========小米系列产品===========");
        xiaomiFactory xf=new xiaomiFactory();
        IPhoneProduct xiaomiIPhoneProduct= xf.produceIPhone();
        // xiaomiIPhone xiaomiiphone2= (xiaomiIPhone) xf.produceIPhone();
        // xiaomiiphone2.open();
        xiaomiIPhoneProduct.open();
        xiaomiIPhoneProduct.callUp();
        IRouterProduct xiaomiIRouterProduct = xf.produceIRouter();
        xiaomiIRouterProduct.open();
        xiaomiIRouterProduct.openWifi();
        System.out.println();
        System.out.println("===========华为系列产品===========");
        huaweiFactory hf=new huaweiFactory();
        IPhoneProduct huaweiIPhoneProduct = hf.produceIPhone();
        huaweiIPhoneProduct.open();
        huaweiIPhoneProduct.callUp();
        IRouterProduct huaweiIRouterProduct = hf.produceIRouter();
        huaweiIRouterProduct.open();
        huaweiIRouterProduct.openWifi();
    }
}