设计模式之工厂模式（简单工厂、工厂方法、抽象工厂）

写在前面：本文是个人在学习设计模式时的所思所想，汇总了其他博主及自己的感悟思考，可能存在出入，请大家理性食用~~

工厂模式

在工厂模式中，父类决定实例的生成方式，但并不决定所要生成的具体的类，具体的处理全部交给子类负责。这样就可以将生成实例的框架和实际负责生成实例的类解耦。

核心：

实例化对象不使用new，用工厂方法创建对象。
使用工厂统一管理对象的创建，将调用者跟实现类解耦。

1.1. 简单工厂模式

简单工厂模式又叫静态工厂方法模式（因为工厂类定义了一个静态方法）

简单工厂模式的角色包括三个：

抽象产品角色
具体产品角色
工厂类角色

抽象产品角色：

public interface Weapon{
    //所有的武器都有攻击行为
    public void attack();
}

具体产品角色：

//坦克（具体产品角色)
public class Tank implements Weapon{
    @Override
    public void attack() {
        System.out.println("坦克开炮！");
    }
}

// 战斗机（具体产品角色)
public class Fighter implements Weapon{
    @Override
    public void attack() {
        System.out.println("战斗机投下原子弹！");
    }
}

//匕首（具体产品角色）
public class Dagger implements Weapon{
    @Override
    public void attack() {
        System.out.println("砍他丫的！");
    }
}

工厂类角色：

//工厂类角色
public class WeaponFactory {
    /**
     * 根据不同的武器类型生产武器
     * @param weaponType 武器类型
     * @return 武器对象
     */
    public static Weapon get(String weaponType){
        if (weaponType == null || weaponType.trim().length() == 0) {
            return null;
        }
        Weapon weapon = null;
        if ("TANK".equals(weaponType)) {
            weapon = new Tank();
        } else if ("FIGHTER".equals(weaponType)) {
            weapon = new Fighter();
        } else if ("DAGGER".equals(weaponType)) {
            weapon = new Dagger();
        } else {
            throw new RuntimeException("不支持该武器！");
        }
        return weapon;
    }
}

测试类：

public class Client {
    public static void main(String[] args) {
        Weapon weapon1 = WeaponFactory.get("TANK");
        weapon1.attack();

        Weapon weapon2 = WeaponFactory.get("FIGHTER");
        weapon2.attack();

        Weapon weapon3 = WeaponFactory.get("DAGGER");
        weapon3.attack();
    }
}

优点：实例化具体对象不需要关系具体细节，直接根据参数从工厂索要即可，初步实现了责任的分离。客户端只负责“消费”，工厂负责“生产”。生产和消费分离。

缺点：

- 工厂类集中负责所有的创造逻辑，不能出问题，一旦出问题，整个系统瘫痪。
- 不符合OCP开闭原则，在进行系统拓展时，需要修改工厂类。

1.2. 工厂方法模式

工厂方法模式既保留了简单工厂的优点，同时又解决了简单工厂的缺点。

工厂方法模式的角色包括四个：

抽象工厂角色
具体工厂角色
抽象产品角色
具体产品角色

抽象产品角色：

//武器类（抽象产品角色）
public abstract class Weapon {
    //所有武器都有攻击行为
    public abstract void attack();
}

具体产品角色：

//具体产品角色
public class Gun extends Weapon{
    @Override
    public void attack() {
        System.out.println("开枪射击！");
    }
}

//具体产品角色
public class Fighter extends Weapon{
    @Override
    public void attack() {
        System.out.println("战斗机发射核弹！");
    }
}

抽象工厂角色：

//武器工厂接口(抽象工厂角色)
public interface WeaponFactory {
    Weapon get();
}

具体工厂角色：

public class GunFactory implements WeaponFactory{
    @Override
    public Weapon get() {
        return new Gun();
    }
}

public class FighterFactory implements WeaponFactory{
    @Override
    public Weapon get() {
        return new Fighter();
    }
}

客户端程序：

public class Client {
    public static void main(String[] args) {
        //实例化不同的工厂
        WeaponFactory factory = new GunFactory();
        Weapon weapon = factory.get();
        weapon.attack();

        WeaponFactory factory1 = new FighterFactory();
        Weapon weapon1 = factory1.get();
        weapon1.attack();
    }
}

如果想扩展一个新的产品，只要新增一个产品类，再新增一个该产品对应的工厂即可，例如新增：匕首

public class Dagger extends Weapon{
    @Override
    public void attack() {
        System.out.println("砍丫的！");
    }
}

public class DaggerFactory implements WeaponFactory{
    @Override
    public Weapon get() {
        return new Dagger();
    }
}

客户端程序：

public class Client {
    public static void main(String[] args) {
        //实例化不同的工厂
        WeaponFactory factory = new GunFactory();
        Weapon weapon = factory.get();
        weapon.attack();

        WeaponFactory factory1 = new FighterFactory();
        Weapon weapon1 = factory1.get();
        weapon1.attack();

        WeaponFactory factory2 = new DaggerFactory();
        Weapon weapon2 = factory2.get();
        weapon2.attack();
    }
}

因此可以看出在进行功能拓展时，不需要修改之前的源码，显然工厂方法模式更符合OCP原则。

优点：