大白话抽象工厂模式

先说最难的 抽象工厂模式，
现在有一种情景： 你相对比一下ak47开枪的一瞬间，沙漠之鹰开枪得一瞬间，手弩开枪的一瞬间 哪个更爽

你需要 ak47 ak47的子弹 装弹过程 开枪瞬间
沙漠之鹰 沙漠之鹰子弹 装弹过程 开枪瞬间
手弩 手弩子弹 装弹过程 开枪瞬间

1. 你去了 ak47工厂拿到了 ak47 子弹，装弹教程，开枪说明书
2. 你去了 沙漠之鹰工厂拿到了 沙漠之鹰 子弹，装弹教程，开枪说明书
3. 你去了 手弩 工厂拿到了 手弩 子弹，装弹教程，开枪说明书

好像可以抽象一下 总感觉有点相似的地方

我抽象一下好了 搞个工厂 生产ak47 沙漠之鹰 手弩 和对应的子弹

首先 能想到 用工厂模式 路子是对的，但是怎么抽象 又无从下手，

简单点说
实现代码步骤
1 武器工厂 ak47 沙漠之鹰 手弩
2 子弹工厂 ak47子弹 沙漠之鹰 手弩子弹
3 装弹说明书工厂 ak47装弹说明书 沙漠之鹰装弹说明书 手弩装弹说明书
4 开枪说明书工厂 ak47开枪说明书 沙漠之鹰开枪说明书 手弩开枪说明书
5 我想要 1 2 4 我会装子弹 不要说明书了 我只要 AK47 沙漠之鹰的武器
第一步 武器工厂代码

/**
 * 武器工厂
 * 1 不直接生产武器
 * 2 负责生产各种武器的工厂
 * 3 生产一个工厂，让工厂去造武器
 */
 interface Arms {
    public void getArmsName();
}


/**
 * 专门生产AK47
 */
public class Ak47 implements Arms {
    @Override
    public void getArmsName() {
        System.out.println("我是AK47");
    }
}

/**
 * 专门生产沙漠之鹰
 */

public class DesertEagle implements Arms {
    @Override
    public void getArmsName() {
        System.out.println("我是沙漠之鹰");
    }
}

/**
 * 专门生产手弩
 */
public class Bowgun implements Arms {
    @Override
    public void getArmsName() {
        System.out.println("我是手弩");
    }
}

2 子弹工厂 代码

/**
 * 专门生产子弹制造工厂
 */

public interface Bullet {
    public void getBulletName();
}

/**
 * 专门生产AK47子弹工厂
 */

public class AK47Bullet implements Bullet {
    @Override
    public void getBulletName() {
        System.out.println("生产Ak47子弹");
    }
}


/**
 * 专门生产沙漠之鹰子弹
 */

public class DesertEagleBullet implements Bullet {
    @Override
    public void getBulletName() {
        System.out.println("生产沙漠之鹰子弹");
    }
}


/**
 * 专门生产手弩子弹制造工厂
 */

public class BowgunBullet implements Bullet {
    @Override
    public void getBulletName() {
        System.out.println("生产手弩弓箭");
    }
}

3装弹说明书工厂

/**
 * 生产装弹说明工厂
 */
public interface Chambering {
    public void getChamberingName();
}
/**
 * AK47装弹说明
 */
public class Ak47Chambering implements Chambering {
    @Override
    public void getChamberingName() {
        System.out.println("Ak47装弹说明");
    }
}
/**
 * 沙漠之鹰 装弹说明
 */
public class DesertEagleChambering implements Chambering {
    @Override
    public void getChamberingName() {
        System.out.println("沙漠之鹰装弹说明");
    }
}
/**
 * 手弩 装弹说明
*/
public class BowgunChambering implements Chambering {
    @Override
    public void getChamberingName() {
        System.out.println("手弩装弹说明");
    }
}

4 开枪``说明书工厂

/**
 * 生产开枪 说明书工厂
 */
public interface Shot {
    public void getShotName();
}
/**
 * AK47 开枪教程
*/
public class AK47Shot implements Shot {
    @Override
    public void getShotName() {
        System.out.println("ak47 开枪教程");
    }
}
/**
 * 沙漠之鹰 开枪教程
 */
public class DesertEagleShot implements Shot {
    @Override
    public void getShotName() {
        System.out.println("沙漠之鹰 开枪教程");
    }
}
/**
 * 手弩 开枪教程
 */
public class BowgunShot implements Shot {
    @Override
    public void getShotName() {
        System.out.println("手弩开枪教程");
    }
}

以上 都是很一般的操作 只是把关系搞清楚 抽象工厂精髓 在下边

5 我想要 1 2 4 我会装子弹 不要说明书了 我只要 AK47 沙漠之鹰的武器
特殊业务 特殊处理

分析一下
1 我要武器 开枪说明 子弹 不要装弹说明书 因为我会装弹
2 我要AK47 沙漠之鹰
3 比较那个开枪爽
开始写代码

/**
 * 5.1  抽象类 适用于拼装
 * 根据业务需求 搞定抽象类
 * 当前业务 只要 武器 开枪说明 子弹
 */
abstract class AK47AndDesertEagleFactory {
    abstract ArmsFactory getArms(String armsName );
    abstract BulletFactory getBullet(String bulletName);
    abstract ChamberingFactory getChambering(String chamberingName);
}
/**
 * 5.2 arms 下面有三个工厂 所以 armsFactory就可以得到工厂所有
 * 用五分钟 品味 ArmsFactory与Arms关系 
 * Arms 与 Ak47
 */
public class ArmsFactory extends AK47AndDesertEagleFactory {

    @Override
    Arms getArms(String armsName) {
        if("AK47".equals(armsName)){
            return new Ak47();
        }else if("Bowgun".equals(armsName)){
            return new Bowgun();
        }else if("DesertEagle".equals(armsName)){
            return new DesertEagle();
        }
        return null;
    }

    @Override
    Bullet getBullet(String bulletName) {
        if("AK47Bullet".equals(bulletName)){
            return new AK47Bullet();
        }else if("BowgunBullet".equals(bulletName)){
            return new BowgunBullet();
        }else if("DesertEagleBullet".equals(bulletName)){
            return new DesertEagleBullet();
        }
        return null;
    }

    @Override
    Chambering getChambering(String chamberingName) {
        if("AK47ChamberingName".equals(chamberingName)){
            return new Ak47Chambering();
        }else if("BowgunchamberingName".equals(chamberingName)){
            return new BowgunChambering();
        }else if("DesertEaglechamberingName".equals(chamberingName)){
            return new DesertEagleChambering();
        }
        return null;
    }