抽象工厂模式

介绍

抽象工厂模式Abstract Factory,提供了一个创建一系列相关或互相依赖对象的接口,而无需指定它们具体的类;

结构图

Demo

假设我们在打cs的时候需要买枪,而子弹是不通用的,但我们不知道什么武器的对应什么子弹,
理想情况下是在不同的商店直接买到对应的武器和子弹

接口

//武器接口
public interface IGun {
    void shot(IBullet bullet);
}

//子弹接口
public interface IBullet {
    String getBulletName();
}

//武器工厂
public interface IWeaponFactory {
    IGun createGun();
    IBullet createBullet();
}

AK47

//武器与子弹相耦合
public class AK47 implements IGun {
    @Override
    public void shot(IBullet bullet) {
        Log.d("meee","使用AK47发射"+bullet.getBulletName());
    }
}

//武器与子弹相耦合
public class AK47Bullet implements IBullet {
    @Override
    public String getBulletName() {
        return "AK47子弹";
    }
}

//AK47的工厂类
public class AK47Factory implements IWeaponFactory {
    @Override
    public IGun createGun() {
        return new AK47();
    }

    @Override
    public IBullet createBullet() {
        return new AK47Bullet();
    }
}

M4A1

//M4A1也是一样的
public class M4A1 implements IGun {
    @Override
    public void shot(IBullet bullet) {
        Log.d("meee","使用M4A1发射"+bullet.getBulletName());
    }
}

public class M4A1Bullet implements IBullet {
    @Override
    public String getBulletName() {
        return "M4A1子弹";
    }
}

public class M4A1Factory implements IWeaponFactory {
    @Override
    public IGun createGun() {
        return new M4A1();
    }

    @Override
    public IBullet createBullet() {
        return new M4A1Bullet();
    }
}

客户端

//只需要更换工厂即可同时更换武器和子弹,不需要知道子弹和武器的对应关系
//        AK47Factory factory = new AK47Factory();
        M4A1Factory factory = new M4A1Factory();
        IBullet bullet = factory.createBullet();
        IGun gun = factory.createGun();
        gun.shot(bullet);

抽象工厂模式的优缺点

优点:
1.便于交换产品的系列,工厂只需要在一个应用中出现一次,这就使得改变一个应用的具体工厂非常容易,只需要改变工厂即可使用不同的产品配置.
2.让具体的创建过程和客户端分离,客户端是通过他们的接口来操纵实例,产品的具体名称也被具体工厂的实现分离,不会出现在客户端代码中;

缺点:
仍然在使用时需要多次创建特定的工厂对象,更改时也需要多次更改

使用简单工厂对抽象工厂进行改进

//把判断的职责交给封装类
public class Factory {
    public static final int AK47_FACTORY = 0x01;
    public static final int M4A1_FACTORY = 0x02;

    public static IWeaponFactory create(int factoryType) {
        switch (factoryType) {
            case AK47_FACTORY:
                return new AK47Factory();
            case M4A1_FACTORY:
                return new M4A1Factory();
            default:
                throw new RuntimeException("找不到啊..");
        }
    }
}

        //只需要更改传入的参数即可实现武器和子弹的更换
        IWeaponFactory factory = Factory.create(Factory.M4A1_FACTORY);
        IBullet bullet = factory.createBullet();
        IGun gun = factory.createGun();
        gun.shot(bullet);

更为简洁的简单工厂,剔除IFactory 具体Factory类

//把生产枪和子弹的职责都上放到简单工厂中,通过一个变量来控制
public class SimpleFactory {
    public static final int AK47_FACTORY = 0x01;
    public static final int M4A1_FACTORY = 0x02;

    private static int mflag;

    public static void init(int flag) {
        mflag = flag;
    }

    public static IGun createGun() {
        switch (mflag) {
            case AK47_FACTORY:
                return new AK47();
            case M4A1_FACTORY:
                return new M4A1();
            default:
                return null;
        }
    }

    public static IBullet createBullet() {
        switch (mflag) {
            case AK47_FACTORY:
                return new AK47Bullet();
            case M4A1_FACTORY:
                return new M4A1Bullet();
            default:
                return null;
        }
    }
}

        //只需要更改配置即可更换枪的种类
        SimpleFactory.init(SimpleFactory.M4A1_FACTORY);
        IBullet bullet = SimpleFactory.createBullet();
        IGun gun = SimpleFactory.createGun();
        gun.shot(bullet);