设计模式之工厂模式及抽象工厂模式

工厂模式：

作用：实现了创建者和调用者的分离**
分类：简单工厂模式、工厂方法模式、抽象工厂模式
**OOP七大原则：**开闭原则（有A和B，想扩展C，因此不要动A和B，可以在外面增加C，如果C对A和B有影响或者修改了原有代码就不可以了）、依赖倒置原
则（不需要每个类都要一个接口，可以提取公共接口）、迪米特法则
核心本质：
1.实例化对象不使用new，用工厂方法代替
2.将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

简单工厂模式：
用来生产同一等级结构中的任意产品（对于增加新的产品，需要球盖已有的代码）

public interface Car {
    void name();
}


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

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

//静态工厂模式（它是一个简单的工厂模式）
//增加一个新的产品，如果那你不修改代码，做不到的

//开闭原则(这里是没有满足的)
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) {
//        接口，所有的实现类
        WuLing wuLing = new WuLing();
        Tesla tesla = new Tesla();
        wuLing.name();
        tesla.name();

//        使用工厂创建(实例化对象不使用new，用工厂方法代替)
        Car car = CarFactory.getCar("五菱");
        Car car1 = CarFactory.getCar("特斯拉");
        car.name();
        car1.name();
    }
}

工厂方法模式：
用来生产同一等级结构中的固定产品（支持增加任意产品）

public class Consumer {
    public static void main(String[] args) {
//        接口，所有的实现类
        WuLing wuLing = new WuLing();
        Tesla tesla = new Tesla();
        wuLing.name();
        tesla.name();

//        使用工厂创建(实例化对象不使用new，用工厂方法代替)
        Car car = CarFactory.getCar("五菱");
        Car car1 = CarFactory.getCar("特斯拉");
        car.name();
        car1.name();
    }
}

//工厂方法模式
public interface CarFactory {
    Car getCar();
}

public class Consumer {
    public static void main(String[] args) {
        Car car = new WuLingFactory().getCar();
        Car car1 = new TeslaFactory().getCar();

        car.name();
        car1.name();
    }
}

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

public class TeslaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

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

public class WuLingFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new WuLing();
    }
}

应用场景：
1.JDK中Calendar的getInstance方法
2.JDBC中的Connection对象的获取
3.Spring中IOC容器创建管理bean对象
4.反射中Class对象的newInstance方法
**
抽象工厂模式：
围绕一个超级工厂创建其他工厂。这个超级工厂又称为其他工厂的工厂。
**定义：**抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，不需要指定它们具体的类

//手机产品接口
public interface IphoneProduct {
    void start();
    void shutdown();
    void callUp();
    void sendSMS();
}

//抽象产品工厂
public interface IProductFactory {

//    生产手机
    IphoneProduct iphoneProduct();


//    生产路由器
    IRouterProduct irouterProduct();
}

//路由器产品接口
public interface IRouterProduct {
//    开机
    void start();
//    关机
    void shutdown();

    void openWife();
//    设置wife密码
    void setting();
}

public class XiaomiIphone implements IphoneProduct{
    @Override
    public void start() {
        System.out.println("开启小米手机");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭小米手机");
    }

    @Override
    public void callUp() {
        System.out.println("用小米手机打电话");
    }

    @Override
    public void sendSMS() {
        System.out.println("用小米手机发送信息");
    }
}

public class XiaomiIRouter implements IRouterProduct{
    @Override
    public void start() {
        System.out.println("小米路由器开机");
    }

    @Override
    public void shutdown() {
        System.out.println("小米路由器关机");
    }

    @Override
    public void openWife() {
        System.out.println("小米路由器打开wife");
    }

    @Override
    public void setting() {
        System.out.println("小米路由器设置");
    }
}

public class XiaomiFactory implements IProductFactory{

    @Override
    public IphoneProduct iphoneProduct() {
        return new XiaomiIphone();
    }

    @Override
    public IRouterProduct irouterProduct() {
        return new XiaomiIRouter();
    }
}

public class HuaweiIphone implements IphoneProduct{
    @Override
    public void start() {
        System.out.println("开启华为手机");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭华为手机");
    }

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

    @Override
    public void sendSMS() {
        System.out.println("用华为手机发送信息");
    }
}

public class HuaweiIRouter implements IRouterProduct{
    @Override
    public void start() {
        System.out.println("华为路由器开机");
    }

    @Override
    public void shutdown() {
        System.out.println("华为路由器关机");
    }

    @Override
    public void openWife() {
        System.out.println("华为路由器打开wife");
    }

    @Override
    public void setting() {
        System.out.println("华为路由器设置");
    }
}

public class HuaweiFactory implements IProductFactory{
    @Override
    public IphoneProduct iphoneProduct() {
        return new HuaweiIphone();
    }

    @Override
    public IRouterProduct irouterProduct() {
        return new HuaweiIRouter();
    }
}

public class Client {
    public static void main(String[] args) {
//        小米工厂
        System.out.println("-----------------小米产品-----------------");
        XiaomiFactory xiaomiFactory = new XiaomiFactory();
        IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct();
        iphoneProduct.callUp();
        iphoneProduct.sendSMS();

        IRouterProduct iRouterProduct = xiaomiFactory.irouterProduct();
        iRouterProduct.openWife();
        iRouterProduct.setting();

//        华为工厂
        System.out.println("-----------------华为产品-----------------");
        HuaweiFactory huaweiFactory = new HuaweiFactory();
        IphoneProduct iphoneProduct1 = huaweiFactory.iphoneProduct();
        iphoneProduct1.sendSMS();;
        iphoneProduct1.callUp();

        IRouterProduct iRouterProduct1 = huaweiFactory.irouterProduct();
        iRouterProduct1.setting();;
        iRouterProduct1.openWife();
    }
}

适用场景：
1.客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
2.强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
3.提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现

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

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