简单工厂模式与迪迦奥特曼

[bitfishxyz]

简单工厂

我们知道迪迦奥特曼有三种形态

• 红色形态：力量比较强，速度比较慢，适合和怪兽硬钢
• 蓝色形态：力量比较弱，速度比较快 ，一般用于追击怪兽
• 红蓝平衡形态：力量和速度比较均衡，是主形态

而对于一般人来说，他们不需要也没能力掌握奥特曼的形态，这件事情交给大古\迪迦就行了。大古根据怪兽的参数，召唤出正确的形态就行了。

应用到软件工程中，就是我们的简单工厂模式了。用户给出正确参数，简单工厂就可以创建合适的对象。

假设这是我们的奥特曼的相关的类

abstract class AbstractATM{
    int power;
    int speed;
    public void fight(){
        System.out.println("猫吃鱼，狗吃肉，奥特曼爱打小怪兽");
    }
}
class RedATM extends AbstractATM{
    public RedATM() {
        power = 70;
        speed = 30;
    }
}
class BlueATM extends AbstractATM{
    public BlueATM() {
        power = 30;
        speed = 70;
    }
}
class BalanceATM extends AbstractATM{
    public BalanceATM() {
        power = 50;
        speed = 50;
    }
}

可以看到，我们首先定义了一个抽象类，然后它有三个子类。不同的形态奥特曼技能点分配不通。

然后我们写下测试代码

class Monster{
    public int power;
    public int speed;

    public Monster(int power, int speed) {
        this.power = power;
        this.speed = speed;
    }
}


public class Test {
    public static void main(String[] args) {
        Monster monster = new Monster(30, 20);

        AbstractATM ATM;
        if (monster.power > 40){
            ATM = new RedATM();
        }else if (monster.speed > 40){
            ATM = new BlueATM();
        }else {
            ATM = new BalanceATM();
        }
        ATM.fight();
    }
}

我们的客户端，根据怪兽的特点，来召唤合适形态的奥特曼。
但是上面的实现有两个缺点：

1. 不符合最少依赖原则
   我们的客户端需要同时知道四个类，才能完成任务

2. 不利于代码复用
   上述创建ATM的代码可能在多个地方被用到

所以就有了我们的简单工厂模式。

class AtmFactory{
    public static AbstractATM getATM(Monster monster){
        AbstractATM ATM;
        if (monster.power > 40){
            ATM = new RedATM();
        }else if (monster.speed > 40){
            ATM = new BlueATM();
        }else {
            ATM = new BalanceATM();
        }
        return ATM;
    }
}

public class Test {
    public static void main(String[] args) {
        Monster monster = new Monster(30, 20);
        AbstractATM atm = AtmFactory.getATM(monster);
        atm.fight();
    }
}

在上面的实现中，我们的客户端Test类不再需要了解奥特曼的几种形态，大大降低了代码的耦合，神光棒一按就完事了！！