JAVA设计模式示例-2 抽象工厂

2 抽象工厂

主要是满足当我们的工厂内，需要生产新的类型的产品时的问题，解决办法是引进新的生成线。将N个简单工厂，都通过为一个Factory Producer的类来创建。代码如下：

代码说明：实现一个游戏抽象工厂，具有生产英雄，和生成物品的两个简单工厂。这样我们就可以生产英雄和物品，这两种类型不同的产品了。

Step1 定义生成两种产品类型的抽象工厂

public interface GameFactory {
    public abstract Goods getGoods(String goodsName);
    public abstract Hero getHero(String heroName) ;
}

Step2 定义Hero英雄和Good物品这两种产品，每个产品又有具体的实现规格,如英雄-(PcNj,Timo),物品(Shoes,Sword)

public abstract  class Hero {
    /*英雄必须实现进行攻击的方法*/
    public abstract void attack();
};

public class PcNj extends Hero{

    @Override
    public void attack() {
        System.out.println("皮城女警正在用狙击枪进行攻击");
    }
}

public class Timo extends Hero{
    @Override
    public void attack() {
        System.out.println("提莫放的蘑菇对敌人进行了伤害");
    }
}

public abstract class Goods {
    public abstract void cost();
}

public class Shoes extends  Goods {
    @Override
    public void cost() {
        System.out.println("攻速鞋-需花费1550金");
    }
}

public class Sword  extends Goods{

    @Override
    public void cost() {
        System.out.println("大剑-需花费1550金");
    }
}

Step3 分别实现物品工厂和英雄工厂

public class GoodsFactory implements GameFactory{
    public  Goods getGoods(String heroName){
        Goods ret=null;
        switch (heroName)
        {
            case "shoes" :
                ret= new Shoes();
                break;
            case "sword":
                ret= new Sword();
                break;
            default:
                ret= new Sword();
                break;
        }
        return  ret;
    }

    @Override
    public Hero getHero(String heroName) {
        return null;
    }
}

public class HeroFactory implements  GameFactory {
    @Override
    public Goods getGoods(String goodsName) {
        return null;
    }

    public  Hero getHero(String heroName){
        Hero ret=null;
        switch (heroName)
        {
            case "pcnj" :
                ret= new PcNj();
                break;
            case "timo":
                ret= new Timo();
                break;
            default:
                ret= new Timo();
                break;
        }
        return  ret;
    }
}

Step4 实现工厂的建造类

public class FacotryProducer {
    public static GameFactory getGameFactory(String factoryName){
        GameFactory ret=null;
        switch (factoryName)
        {
            case "goods_factory" :
                ret= new GoodsFactory();
                break;
            case "hero_factory":
                ret= new HeroFactory();
                break;
            default:
                ret= new HeroFactory();
                break;
        }
        return  ret;
    }

Step5 客户端使用

 public static void test()
    {
        GameFactory goodsFactory=FacotryProducer.getGameFactory("goods_factory");
        GameFactory heroFactory=FacotryProducer.getGameFactory("hero_factory");
        Goods shoes=goodsFactory.getGoods("shoes");
        Goods sword=goodsFactory.getGoods("sword");
        Hero pcnj=heroFactory.getHero("pcnj");
        Hero timo=heroFactory.getHero("timo");
        shoes.cost();
        sword.cost();
        pcnj.attack();
        pcnj.attack();
    }

---

攻速鞋-需花费1550金
大剑-需花费1550金
皮城女警正在用狙击枪进行攻击
皮城女警正在用狙击枪进行攻击

Process finished with exit code 0

使用场景

抽象工厂适用于需要生产多种不同类型产品的场景。其是在简单工厂的基础上，对其进行了封装，实质上可以称为工厂的工厂。