设计模式之工厂模式（2）

前一篇提到了静态工厂（也称为普通工厂），单例模式

这一篇来谈谈抽象工厂（面向抽象类编程，故名思意）。

我现在有一系列的产品 Car Ak47 Apple Computer...

简单起见就取前两个。。程序员就是爱偷懒。。莫怪。

小二，先来一个抽象类：Vehicle:

package cn.asto.abs;

public abstract class Vehicle {

    public abstract void move();
}

客官来了，一个实现Vehicle的类：

package cn.asto.abs;

public class Car extends Vehicle {

    @Override
    public void move() {
        System.out.println("Car is running");
    }

}

照样画葫芦 搞一对关于Ak47的，

package cn.asto.abs;

public abstract class  Weapon {

    public abstract void shoot();
}

package cn.asto.abs;

public class AK47 extends Weapon{

    @Override
    public void shoot() {
        System.out.println("Ak47 is shoot!");
        
    }

    
}

这一系列产品总得有人管理吧，主角登场即将登场，先定义一个抽象工厂：

package cn.asto.abs;

public abstract class AbstractFactory {

    public abstract Vehicle createVehcle();
    public abstract Weapon createWeapon();
    
}

 写到这里终于轮到工厂出马了：

DefaultFactory:

package cn.asto.abs;

public class DefaultFactory extends AbstractFactory{

    @Override
    public Vehicle createVehcle() {
        // TODO Auto-generated method stub
        return new Car();
    }

    @Override
    public Weapon createWeapon() {
        // TODO Auto-generated method stub
        return new AK47();
    }

}

Test:

package cn.asto.abs;

public class Test {

    public static void main(String args[]){
        AbstractFactory factory = new DefaultFactory();
        Vehicle car = factory.createVehcle();
        car.move();
        Weapon ak47 =factory.createWeapon();
        ak47.shoot();
    }
    
}

输出：

Car is running
Ak47 is shoot!

让我感慨一下，java的多态设计真的是牛的一逼啊！

现在这个DefaultFactory工厂就可以create一系列的bean了。

假如我现在想换一套bean,比如MaggicFactory,

先来两个实体类 分别实现Vehicle 和Weapon

package cn.asto.abs;

public class MagicCar extends Vehicle{

    @Override
    public void move() {
        System.out.println("MagicCar is runing");
        
    }

}

package cn.asto.abs;

public class MagicAK47 extends Weapon{

    @Override
    public void shoot() {
        System.out.println("MagicAk47 is shoot!");
        
    }

    
}

现在再来一个工厂类：

package cn.asto.abs;

public class MagicFactory extends AbstractFactory {

    @Override
    public Vehicle createVehcle() {
        
        return new MagicCar();
    }

    @Override
    public Weapon createWeapon() {
        
        return new MagicAK47();
    }

}

我在Test里面只要换一句话，就可以实现更换一系列的产品了，注意看下面的代码：

package cn.asto.abs;

public class Test {

    public static void main(String args[]){
        //AbstractFactory factory = new DefaultFactory();
        AbstractFactory factory = new MagicFactory();
        Vehicle car = factory.createVehcle();
        car.move();
        Weapon ak47 =factory.createWeapon();
        ak47.shoot();
    }
    
}

是吧，其实我只需要更改后面new的对象就可以。再次感谢java的多态！让我这么简单地就更换了一系列的产品。

come back to console:

MagicCar is runing
MagicAk47 is shoot!

---

现在抛开具体的实现，我想对比一下抽象工厂和静态工厂（普通工厂）的优缺点：

1. 静态工厂：当增加一系列产品的时候，就需要对应地写出一系列的Factory，类爆炸，但是在添加单个产品的时候，非常地方便
2. 抽象工厂：当增加一个产品的时候，比较麻烦，首先你要写一个抽象产品，然后实现它，接着你需要在抽象工厂类中新建立一个方法，用于create new Bean,接着你还要在所有的具体的工厂类中去实现这个方法，但是用于一系列产品的替换的时候，就非常方便

　　所以要我说吧，静态工厂适用于生产单系列的的产品，并且在后续的开发中，很少出现一系列的产品，而抽象工厂适用于一系列的产品，经常性要替换掉一系列的产品，最好还不存在单个产品的增删改查。

---

站在哲学的角度上看，事物是相对的，没有什么永远是对，是好的！

在不同的地点，不同的人，不同的时间，可能完全是另一个世界！ 好吧我承认我装B了，洗洗睡吧！