设计模式学习之抽象工厂模式

设计模式之抽象工厂模式

不可以增加产品，可以增加产品族！

抽象工厂模式的优点之为什么要使用抽象工厂模式？

首先抽象工厂模式是围绕一个超级工厂创建其他的工厂。定义了一个接口用于创建相关或有依赖关系的对象簇，而无需明确指定具体类。

将选择实现类，创建对象统一管理和控制，从而将调用者跟我们的实现类解耦。

主要解决什么问题?主要解决接口选择的问题。

抽象工厂模式的实现方式

​ 第一步：编写手机和路由器接口

public interface PhoneProduct {  //手机接口
    void open();
    void shutdown();
    void phone();
    void sendMsg();
}

//----------------------------------------------------------
public interface RouterProduct {  //路由器接口

    void open();
    void shutdown();
    void phone();
    void setttig();
}

​ 第二步：编写手机和路由器接口的实现类

public class HuaweiPhone implements PhoneProduct{  //华为手机
    @Override
    public void open() {
        System.out.println("华为开机");
    }

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

    @Override
    public void phone() {
        System.out.println("华为打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("华为发信息");
    }
}

public class HuaweiRouter implements RouterProduct{  //华为路由器
    @Override
    public void open() {
        System.out.println("华为路由器打开");
    }

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

    @Override
    public void phone() {
        System.out.println("华为路由器11111");
    }

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

//==================================================================================
public class XiaomiPhone implements PhoneProduct {  //小米手机
    @Override
    public void open() {
        System.out.println("小米开机");
    }

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

    @Override
    public void phone() {
        System.out.println("小米打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("小米发短信");
    }
}

public class XiaomiRouter implements RouterProduct{	//小米路由器
    @Override
    public void open() {
        System.out.println("小米路由器打开");
    }

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

    @Override
    public void phone() {
        System.out.println("小米路由器11111");
    }

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

​ 第三步：定义一个产品的工厂（创建相关或有依赖关系的对象簇，而无需明确指定具体类。）

public interface ProductFactory {

    PhoneProduct phoneProduct();  //手机产品

    RouterProduct routerProduct(); //路由产品
}

​ 第四步：华为和小米工厂实现这个产品工厂定义自己的手机产品和路由产品

public class HuaweiFactory implements ProductFactory{ //华为工厂
    @Override
    public PhoneProduct phoneProduct() {
        return new HuaweiPhone();
    }

    @Override
    public RouterProduct routerProduct() {
        return new HuaweiRouter();
    }
}
//=============================================================================
public class XiaomiFactory implements ProductFactory{ //小米工厂
    @Override
    public PhoneProduct phoneProduct() {
        return new XiaomiPhone();
    }

    @Override
    public RouterProduct routerProduct() {
        return new XiaomiRouter();
    }
}

​ 第五步：测试相关公司的产品

public class Client {
    public static void main(String[] args) {
        //华为手机和路由器
        PhoneProduct phoneProduct1 = new HuaweiFactory().phoneProduct();
        RouterProduct routerProduct1 = new HuaweiFactory().routerProduct();
        phoneProduct1.open();
        phoneProduct1.phone();
        phoneProduct1.sendMsg();
        phoneProduct1.shutdown();
        System.out.println("-------------------------------------------------");


        //小米手机和路由器
        PhoneProduct phoneProduct = new XiaomiFactory().phoneProduct();
        RouterProduct routerProduct = new XiaomiFactory().routerProduct();
        System.out.println(phoneProduct);
        System.out.println(routerProduct);
        phoneProduct.shutdown();
        phoneProduct.sendMsg();
        phoneProduct.phone();
        phoneProduct.open();
    }
}

抽象工厂模式的应用场景

• （应用层）不依赖于产品类实例如何被创建、实现等细节。
• 提供一个产品类的库，所有的产品以相同的接口出现，从而使得客户端不依赖于具体的实现。

抽象工厂模式的优缺点？

优点：

• 具体产品在应用层隔离，无需关心创建细节
• 将一系列产品统一到一起创建
• 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：

• 创建新的产品会比较麻烦 (要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码)
• 增加了系统的抽象性和理解难度