（三）抽象工厂模式

一，抽象工厂的出现

由于简单工厂不能应对“不同系列对象”的变化。比如有不同风格的场景—对应不同
风格的道路，房屋、地道、、、、。

二、 抽象工厂的具体实现

例如：绝味鸭脖想在江西、南昌和上海开分店，但是由于当地人的口味不同，在南昌
的所有绝味的东西会做的比较辣一些，而上海不喜欢吃辣的，所以上海不会做成像南昌
那么的辣，这导致南昌绝味工厂和上海绝味工厂生产所有绝味产品不同，也就是某个
具体工厂负责一系列产品的口味不同。

/**
 * 下面以绝味鸭脖连锁店为例子，演示抽象工厂模式
 * 因为每个地方喜欢的口味不同，有些地方喜欢辣点的，有的地方不喜欢吃辣
 * <p>
 * 客户端调用.
 */
public class Client {
    public static void main(String[] args) {
        // 上海工厂制作上海的鸭脖和鸭架
        AbstractFactory shangHaiFactory = new ShangHaiFactory();
        shangHaiFactory.createYaBo().print();
        shangHaiFactory.createYaJia().print();

        //南昌工厂制作的鸭脖和鸭架
        AbstractFactory  nanChangFactory = new NanChangFactory();
        nanChangFactory.createYaBo().print();
        nanChangFactory.createYaJia().print();
    }
}


/**
 * 抽象工厂，提供不同地方鸭架和鸭脖的接口.
 */
public abstract class AbstractFactory {
    public abstract YaBo createYaBo();
    public abstract YaJia createYaJia();
}


/**
 *南昌绝味工厂制作南昌的鸭脖和鸭架.
 */
public class NanChangFactory extends AbstractFactory {
    @Override
    public YaBo createYaBo() {
        return new NanChangYaBo();
    }

    @Override
    public YaJia createYaJia() {
        return new NanChangYaJia();
    }
}

/**
 * 上海绝味工厂，负责制作上海的鸭脖和鸭架.
 */
public class ShangHaiFactory extends AbstractFactory{
    //制作上海鸭脖
    @Override
    public YaBo createYaBo() {
        return new ShangHaiYaBo();
    }
    //制作上海鸭架
    @Override
    public YaJia createYaJia() {
        return new ShangHaiYaJia();
    }
}

/**
 * 鸭脖抽象类，供每个地方实现类继承
 */
public abstract class YaBo {
    //打印鸭脖的输出信息
    protected abstract void print();
}



/**
 * 鸭架抽象类，供每个地方的鸭架类继承.
 */
public abstract class YaJia {
    //打印方法用于输出信息
    protected abstract void print();
}


/**
 * 南昌鸭脖，因为南昌喜欢吃辣，所以制作的鸭脖比上海制作的鸭脖辣.
 */
public class NanChangYaBo extends YaBo {
    @Override
    protected void print() {
        System.out.println("南昌的鸭脖");
    }
}


/**
 * 南昌鸭架.
 */
public class NanChangYaJia extends YaJia {
    @Override
    protected void print() {
        System.out.println("南昌鸭架");
    }
}

/**
 * 上海的鸭脖，没有南昌鸭脖做的辣.
 */
public class ShangHaiYaBo extends YaBo {
    @Override
    protected void print() {
        System.out.println("上海的鸭脖");
    }
}


/**
 * 上海的鸭架.
 */
public class ShangHaiYaJia extends YaJia {
    @Override
    protected void print() {
        System.out.println("上海的鸭架");
    }
}

三、抽象工厂模式的定义和类图

抽象工厂模式：提供一个创建产品的接口来负责创建相关或依赖的对象，而不具体明
确指定具体类

1，抽象工厂应对需求变更

看完上面抽象工厂的实现之后，如果 “绝味”公司又想在湖南开一家分店怎么办呢？ 因为湖南人喜欢吃麻辣的，
下面就具体看看应用了抽象工厂模式的系统是如何应对这种需求的。

/**
 * 如果绝味又想开一家湖南的分店时，因为湖南喜欢吃麻的
 * 所以这是有需要有一家湖南的工厂专门制作.
 */
public class HuNanFactory extends AbstractFactory {
    @Override
    public YaBo createYaBo() {
        return null;
    }

    @Override
    public YaJia createYaJia() {
        return null;
    }
}


/**
 * 湖南鸭脖.
 */
public class HuNanYaBo extends YaJia {
    @Override
    protected void print() {
        System.out.println("湖南鸭脖");
    }
}


/**
 * 湖南的鸭架.
 */
public class HuNanYaJia extends YaJia {
    @Override
    protected void print() {
        System.out.println("湖南的鸭架");
    }
}

四、抽象工厂的优缺点

优点：抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建
封装起来，可以减少客户端与具体产品类之间的依赖，从而降低系统耦合度，这样有
利于后期的维护和扩展。

缺点：抽象工厂很难支持新品种的变化。这是因为抽象工厂中的接口已经确定可以被
创建的产品集合，如果需要添加新产品，此时就必须修改抽象工厂的接口，这样就违
背了“开放-封闭”原则。