Java设计模式--构造型模式下抽象工厂模式

抽象工厂模式 Abstract Factory

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

抽象工厂模式 = 工厂方法模式 * n ，原有的工厂方法模式，只说提供一个方法来制造产品，而抽象工厂模式，可以提供 n 个工厂方法。

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

主要解决：主要解决接口选择的问题。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

如何解决：在一个产品族里面，定义多个产品。

关键代码：在一个工厂里聚合多个同类产品。

应用实例：工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OOP 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。

注意事项：产品族难扩展，产品等级易扩展。

抽象工厂案例：

/**
 * @author zxl
 * @description: 兵种
 * @date 2020/9/22 14:28
 */
public abstract class Unit {
    protected int attack;// 攻击力
    protected int defence;// 防御力
    protected int health;// 血量
    protected int x;// 横坐标
    protected int y;// 纵坐标

    public Unit(int attack,int defence,int health,int x,int y){
        this.attack = attack;
        this.defence = defence;
        this.health = health;
        this.x = x ;
        this.y = y;
    }

    public abstract void show();

    public abstract void attack();
}

/**
 * @author zxl
 * @description: 士兵
 * @date 2020/9/22 14:43
 */
public class Marine extends Unit{
    public Marine(int x, int y) {
        super(6, 5, 40, x, y);
    }

    @Override
    public void show() {
        System.out.println("士兵出现在坐标：[" + x + "," + y + "]");
    }

    @Override
    public void attack() {
        System.out.println("士兵用机关枪射击，攻击力：" + attack);
    }
}

/**
 * @author zxl
 * @description: 坦克
 * @date 2020/9/22 14:45
 */
public class Tank extends Unit{
    public Tank(int x, int y) {
        super(25, 100, 150, x, y);
    }

    @Override
    public void show() {
        System.out.println("坦克出现在坐标：[" + x + "," + y + "]");
    }

    @Override
    public void attack() {
        System.out.println("坦克用炮轰击，攻击力：" + attack);
    }
}

/**
 * @author zxl
 * @description: 巨型战舰
 * @date 2020/9/22 14:46
 */
public class BattleShip extends Unit {
    public BattleShip(int x, int y) {
        super(25, 200, 500, x, y);
    }

    @Override
    public void show() {
        System.out.println("战舰出现在坐标：[" + x + "," + y + "]");
    }

    @Override
    public void attack() {
        System.out.println("战舰用激光炮打击，攻击力：" + attack);
    }
}

/**
 * @author zxl
 * @description: 外星蟑螂兵
 * @date 2020/9/22 14:52
 */
public class Roach extends Unit{
    public Roach(int x, int y) {
        super(5, 2, 35, x, y);
    }

    @Override
    public void show() {
        System.out.println("蟑螂兵出现在坐标：[" + x + "," + y + "]");
    }

    @Override
    public void attack() {
        System.out.println("蟑螂兵用爪子挠，攻击力：" + attack);
    }
}

/**
 * @author zxl
 * @description: 外星毒液口水兵
 * @date 2020/9/22 14:54
 */
public class Spitter extends Unit{
    public Spitter(int x, int y) {
        super(40, 8, 80, x, y);
    }

    @Override
    public void show() {
        System.out.println("口水兵出现在坐标：[" + x + "," + y + "]");
    }

    @Override
    public void attack() {
        System.out.println("口水兵用毒液喷射，攻击力：" + attack);
    }
}

/**
 * @author zxl
 * @description: 外星猛犸巨兽
 * @date 2020/9/22 14:56
 */
public class Mammoth extends Unit{
    public Mammoth(int x, int y) {
        super(20, 100, 400, x, y);
    }

    @Override
    public void show() {
        System.out.println("猛犸巨兽兵出现在坐标：[" + x + "," + y + "]");
    }

    @Override
    public void attack() {
        System.out.println("猛犸巨兽用獠牙顶，攻击力：" + attack);
    }
}

public interface AbstractFactory {
    public Unit createLowClass();

    public Unit createMidClass();

    public Unit createHighClass();
}

public class HumanFactory implements AbstractFactory{

    private int x;
    private int y;

    public HumanFactory(int x,int y){
        this.x=x;
        this.y=y;
    }

    @Override
    public Unit createLowClass() {
        Unit unit = new Marine(x,y);
        System.out.println("制造海军陆战队员成功。");
        return unit;
    }

    @Override
    public Unit createMidClass() {
        Unit unit = new Tank(x,y);
        System.out.println("制造变形坦克成功。");
        return unit;
    }

    @Override
    public Unit createHighClass() {
        Unit unit = new BattleShip(x,y);
        System.out.println("制造巨型战舰成功。");
        return unit;
    }
}

public class AlienFactory implements AbstractFactory{
    private int x;
    private int y;

    public AlienFactory(int x,int y){
        this.x=x;
        this.y=y;
    }

    @Override
    public Unit createLowClass() {
        Unit unit = new Roach(x,y);
        System.out.println("制造蟑螂兵成功。");
        return unit;
    }

    @Override
    public Unit createMidClass() {
        Unit unit =new Spitter(x,y);
        System.out.println("制造毒液兵成功。");
        return unit;
    }

    @Override
    public Unit createHighClass() {
        Unit unit = new Mammoth(x,y);
        System.out.println("制造猛犸巨兽成功。");
        return unit;
    }
}

测试：

public class AbstractFactoryTest {
    public static void main(String[] args){
        AbstractFactory factory = new HumanFactory(10,20);
        Unit marine = factory.createLowClass();
        marine.show();

        Unit tank = factory.createMidClass();
        tank.show();

        Unit ship = factory.createHighClass();
        ship.show();

        factory = new AlienFactory(50,50);
        Unit roach = factory.createLowClass();
        roach.show();;

        Unit spitter = factory.createMidClass();
        spitter.show();

        Unit mammoth = factory.createHighClass();
        mammoth.show();

        marine.attack();
        roach.attack();
        tank.attack();
        spitter.attack();
        ship.attack();
        mammoth.attack();
    }
}