抽象工厂模式

抽象工厂模式

定义

为创建一组相关或者互相依赖的对象提供一个接口，而且无须指定他们的具体类。抽象工厂模式是工厂方法模式的升级版本，在业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
这里“相关或者相互依赖”是重点，这组对象比如说是车的两侧门，每辆车都要左侧门和右侧门，同时这些车门是有很多型号的，所以根据左右侧门可以得到各自的产品线。

通用类图

抽象工厂通用类图.png

通用源代码类图

抽象工厂通用源码类图.png

通用源码

1. 抽象产品类

public abstract class AbstractProduct {
    // 公有方法
    public void sharedMethod() {}

    // 不同实现
    public abstract void doSomething();
}

2. 抽象产品类A

public abstract class AbstractProductA extends AbstractProduct {
    @Override
    public void sharedMethod() {
        // 共同的方法
    }
}

3. 产品实现类A1

public class ProductA1 extends AbstractProductA {
    @Override
    public void doSomething() {
        // 产品A的实现类A1
    }
}

4. 产品实现类A2

public class ProductA2 extends AbstractProductA {
    @Override
    public void doSomething() {
        // 产品A的实现类A2
    }
}

5. 抽象产品类B

public abstract class AbstractProductB extends AbstractProduct {
    @Override
    public void sharedMethod() {
        // 共同的方法
    }
}

6. 产品实现类B1

public class ProductB1 extends AbstractProductB {
    @Override
    public void doSomething() {
        // 产品A的实现类B1
    }
}

7. 产品实现类B2

public class ProductB2 extends AbstractProductB {
    @Override
    public void doSomething() {
        // 产品A的实现类B1
    }
}

8. 抽象工厂

public abstract class Creator {
    public abstract void createProductA();
    public abstract void createProductB();
}

9. 产品等级1的实现类

public class CreatorOne extends Creator {
    @Override
    public void createProductA() {
        // 生产A1
    }

    @Override
    public void createProductB() {
        // 生产B1
    }
}

10. 产品等级2的实现类

public class CreatorTwo extends Creator {
    @Override
    public void createProductA() {
        // 生产A2
    }

    @Override
    public void createProductB() {
        // 生产B2
    }
}

样例展示

这次样例我们建立在上一章工厂方法中的例子之上。现在召唤师峡谷已经有法师和射手了，但是法师射手也是有远程和贴脸之分的，所以这里的“远程和贴脸”就是一组相关的对象，可以按照这个来进行设计英雄，下面直接贴代码。

抽象工厂样例.png

// 抽象英雄
public abstract class Hero {
    public abstract void attack(); // 攻击方式
    public abstract void range(); // 范围，也就是说远程还是贴脸
}
// 远程型和贴脸型的英文是直接百度翻译的，翻译不正确的话不要在意这种细节 o(╯□╰)o


// 然后创建法师和射手的抽象类
public abstract class Mage extends Hero { // 法师类
    @Override
    public void attack() { // 都是法术伤害
        System.out.println("法术伤害");
    }
}
public abstract class Shooter extends Hero { // 射手类
    @Override
    public void attack() {
        System.out.println("物理伤害");
    }
}


接着是按照攻击范围进行实现，法师和射手都有长短手
// 法师
public class LongRangeMage extends Mage {
    @Override
    public void range() {
        System.out.println("远程");
    }
}
public class ShortRangeMage extends Mage {
    @Override
    public void range() {
        System.out.println("贴脸");
    }
}

// 射手
public class LongRangeShooter extends Shooter {
    @Override
    public void range() {
        System.out.println("远程");
    }
}
public class ShortRangeShooter extends Shooter {
    @Override
    public void range() {
        System.out.println("贴脸");
    }
}

// 最后是搭建抽象工厂，并且实现
public abstract class HeroFactory { // 抽象工厂
    public abstract Hero createMage();
    public abstract Hero createShooter();
}

public class LongRangeHeroFactory extends HeroFactory { // 远程型工厂

    @Override
    public Hero createMage() {
        return new LongRangeMage();
    }

    @Override
    public Hero createShooter() {
        return new LongRangeShooter();
    }
}

public class ShortRangeHeroFactory extends HeroFactory { // 贴脸型工厂

    @Override
    public Hero createMage() {
        return new ShortRangeMage();
    }

    @Override
    public Hero createShooter() {
        return new ShortRangeShooter();
    }
}

本文为《设计模式之禅》读后笔记总结