抽象工厂的理解

定义：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类，围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

 

//手机产品接口
public interface IPhoneProduct {
    void callup();
    void sendSMS();
}

//路由器产品接口
public interface IRouterProduct {
    void openwifi();
    void setting();
}

public class XiaomiPhone implements IPhoneProduct {
    @Override
    public void callup() {
        System.out.println("小米手机打电话");
    }

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

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

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

public class HuaweiPhone implements IPhoneProduct{
    @Override
    public void callup() {
        System.out.println("华为手机打电话");
    }

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

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

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

//抽象产品工厂 超级工厂
public interface IProductFactory {
    //生成手机
    IPhoneProduct getPhoneProduct();
    //生产路由器
    IRouterProduct getRouterProduct();
}

public class XiaomiFactory implements IProductFactory {
    @Override
    public IPhoneProduct getPhoneProduct() {
        return new XiaomiPhone();
    }

    @Override
    public IRouterProduct getRouterProduct() {
        return new XiaomiRouter();
    }
}

public class HuaweiFactory implements IProductFactory {
    @Override
    public IPhoneProduct getPhoneProduct() {
        return new HuaweiPhone();
    }

    @Override
    public IRouterProduct getRouterProduct() {
        return new HuaweiRouter();
    }
}

public class Client {
    public static void main(String[] args) {
        System.out.println("-------------小米系列---------------");
        XiaomiFactory xiaomiFactory = new XiaomiFactory();

        IPhoneProduct iPhoneProduct = xiaomiFactory.getPhoneProduct();
        iPhoneProduct.callup();
        iPhoneProduct.sendSMS();

        IRouterProduct routerProduct = xiaomiFactory.getRouterProduct();
        routerProduct.openwifi();
        routerProduct.setting();
        System.out.println("-------------华为系列---------------");
        HuaweiFactory huaweiFactory = new HuaweiFactory();

        IPhoneProduct phoneProduct = huaweiFactory.getPhoneProduct();
        phoneProduct.sendSMS();
        phoneProduct.callup();

        IRouterProduct routerProduct1 = huaweiFactory.getRouterProduct();
        routerProduct1.setting();
        routerProduct1.openwifi();
    }

}

 总结：适用于 客户端（应用层)不依赖于产品类实例如何被创建、实现等细节。

强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码。

提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现

缺点也很明显，如果抽象工厂加生成类，将违背开闭原则，其他工厂的实现都得改动，增加产品族很容易增加产品难