前一篇提到了静态工厂（也称为普通工厂），单例模式
这一篇来谈谈抽象工厂（面向抽象类编程，故名思意）。
我现在有一系列的产品 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!
现在抛开具体的实现，我想对比一下抽象工厂和静态工厂（普通工厂）的优缺点：
- 静态工厂：当增加一系列产品的时候，就需要对应地写出一系列的Factory，类爆炸，但是在添加单个产品的时候，非常地方便
- 抽象工厂：当增加一个产品的时候，比较麻烦，首先你要写一个抽象产品，然后实现它，接着你需要在抽象工厂类中新建立一个方法，用于create new Bean,接着你还要在所有的具体的工厂类中去实现这个方法，但是用于一系列产品的替换的时候，就非常方便
所以要我说吧，静态工厂适用于生产单系列的的产品，并且在后续的开发中，很少出现一系列的产品，而抽象工厂适用于一系列的产品，经常性要替换掉一系列的产品，最好还不存在单个产品的增删改查。
站在哲学的角度上看，事物是相对的，没有什么永远是对，是好的！
在不同的地点，不同的人，不同的时间，可能完全是另一个世界！ 好吧我承认我装B了，洗洗睡吧！