java抽象工厂模式的实现实例

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是
指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，
使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据LSP原则，
任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型
与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽
象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。

当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？
比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应
于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体
工厂类只负责创建抽象产品的某一个具体子类的实例。

每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；
而抽象工厂模式针对的是多个产品等级结果。

下面是一个java抽象工厂的实现实例.
我们以交通工具(Vihicle),食品(Foot),武器(Weapon)为抽象产品类为例:
交通工具(Vihicle)
public abstract class Vihicle {
public abstract void run();
}
食品(Foot)
public abstract class Foot {
public abstract void printName();
}
武器(Weapon)
public abstract class Weapon {
public abstract void shoot();
}

这三种抽象产品类都有两种子类的实现:
交通工具(Vihicle)有实现类Car,Broom
public class Car extends Vihicle{
public void run(){
System.out.println("冒着烟奔跑中的Car...");
}
}

public class Broom extends Vihicle{
public void run(){
System.out.println("一路沙尘暴飞奔而来..");
}
}
食品(Foot)有实现类Mushroom,Apple
public class Mushroom extends Foot{
@Override
public void printName() {
System.out.println("Mushroom");
}
}

public class Apple extends Foot{
public void printName(){
System.out.println("Apple");
}
}
武器(Weapon)有实现类AK47,MagicStick
public class AK47 extends Weapon{
public void shoot(){
System.out.println("dadada.....");
}
}

public class MagicStick extends Weapon{
@Override
public void shoot() {
System.out.println("MagicStick fare fur...");
}
}

现在建立一个抽象工厂类的父类AbstractFactory,定义好生产产品的抽象方法,让它的子类去
实现,生成具体的需要的产品.

public abstract class AbstractFactory {
public abstract Vihicle createVihile();
public abstract Weapon createWeapon();
public abstract Foot createFoot();
}
所有工厂类都要继承这个父类.
建立第一个工厂类DefaultFactory它生成的具体的产品类为Apple,Car,AK47.
public class DefaultFactory extends AbstractFactory{
@Override
public Foot createFoot() {
return new Apple();
}
@Override
public Vihicle createVihile() {
return new Car();
}
@Override
public Weapon createWeapon() {
return new AK47();
}
}
建立第二个工厂类MagicFactory它生成的具体的产品类为MagicStick,Broom,Mushroom
public class MagicFactory extends AbstractFactory{
@Override
public Foot createFoot() {
return new Mushroom();
}
@Override
public Vihicle createVihile() {
return new Broom();
}
@Override
public Weapon createWeapon() {
return new MagicStick();
}
}
这个工厂序列就建立好了,也就是说这有两个工厂能生产两种系列的产品,两种组合.当如果
还有其它定单需要另外的组合时,我们又可以建立一个工厂类实现AbstractFactory. 当抽象
产品有第三种实现产品时,我们就可以建立这个类,继承相应的抽象产品类.建立符合需求的
工厂类来组合.下面是测试的类:

public class Test {
public static void main(String[] args) {
MagicFactory f=new MagicFactory();
Vihicle c=f.createVihile();
c.run();
Weapon w=f.createWeapon();
w.shoot();
Foot a=f.createFoot();
a.printName();
}
}
我们只需要用其它工厂类替换上面代码中红色部分的工厂类即可.