设计模式-工厂模式

1、简单工厂

简单工厂模式（静态工厂模式）是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建哪一种产品类的实例，同时简单工厂也是工厂模式中最简单，也是最实用的模式

• 简单工厂模式定义了一个创建对象的类，由这个类来封装实例化对象的行为
• 在开发中，当我们会用到大量的创建某类对象的时候，就会用到工厂模式
• 在需要生成复杂对象的地方，都建议使用工厂模式；如果是简单对象，一个new即可。因为工厂模式会引入一个工厂类，增加系统的复杂度

public interface Player {
    /**
     * 射击
     */
    public void shoot();
    /**
     * 移动
     */
    public void move();
}

public class CounterStrike implements Player{
    @Override
    public void shoot() {
        System.out.println("反恐精英正在射击！");
    }

    @Override
    public void move() {
        System.out.println("反恐精英正在移动！");
    }
}

public class Terrorist implements Player{
    @Override
    public void shoot() {
        System.out.println("恐怖分子正在射击！");
    }

    @Override
    public void move() {
        System.out.println("恐怖分子正在移动！");
    }
}

public class PlayerFactory {

    public Player getPlayer(String side) {
        if (side == null) {
            return null;
        }
        else if (side.equalsIgnoreCase("ct")) {
            return new CounterStrike();
        }
        else if (side.equalsIgnoreCase("t")) {
            return new Terrorist();
        }
        return null;
    }
}

编码测试（玩儿一下）：

public class Test {
    public static void main(String[] args) {

        PlayerFactory factory = new PlayerFactory();
        List<Player> list = new ArrayList<>();


        while(true) {
            // 满足十人自动开局
            if(list.size() == 10) {
                break;
            }
            // 接受参数
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入你的阵营: ");
            String side = scanner.nextLine();

            // 产生玩家
            Player player = factory.getPlayer(side);
            // 如果输入参数有错误，应该有控制
            if(player == null) {
                System.out.println("输入参数有误");
                continue;
            }
            list.add(player);
            System.out.println("一个" + side + "诞生了");
            System.out.println("当前人数" + list.size());
            System.out.println("----------------");
        }

    }
}

2、抽象工厂

抽象工厂是工厂的工厂，也是一种创建型模式

• 在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象

抽象产品：

public interface HeroABC{
    /**
     * 是英雄就要战斗
     */
    public void fight();
}

public interface RealHero {

    /**
     * 真正的英雄应该是强大的，一招制敌的
     */
    public void onePunch();
}

具体产品：

public class Qiyu implements RealHero{
    @Override
    public void onePunch() {
        System.out.println("我是个光头，但是我战斗只需要一拳！");
    }
}

public class Jienosi implements HeroABC{
    @Override
    public void fight() {
        System.out.println("我是杰诺斯，我不是光头，但是我每次战斗都很吃力！");
    }
}

public class SexyPrimer implements HeroABC{
    @Override
    public void fight() {
        System.out.println("我是性感QF，我每次战斗都爱爆衣！");
    }
}

抽象工厂：

public abstract class AbstractFactory {
    public abstract HeroABC getHeroABC(String heroABC);
    public abstract RealHero getRealHero(String realHero);
}

具体工厂：

public class HeroABCFactory extends AbstractFactory{

    @Override
    public HeroABC getHeroABC(String heroABC) {
        if (heroABC == null) {
            return null;
        }
        else if(heroABC.equalsIgnoreCase("SexyPrimer")) {
            return new SexyPrimer();
        }
        else if(heroABC.equalsIgnoreCase("Jienosi")) {
            return new Jienosi();
        }
        return null;
    }

    @Override
    public RealHero getRealHero(String realHero) {
        return null;
    }
}

public class RealHeroFactory extends AbstractFactory{

    @Override
    public HeroABC getHeroABC(String heroABC) {
        return null;
    }

    @Override
    public RealHero getRealHero(String realHero) {
        if (realHero == null) {
            return null;
        }
        else if (realHero.equalsIgnoreCase("Qiyu")){
            return new Qiyu();
        }
        return null;
    }
}

抽象工厂的提供者：

public class FactoryProducer {
    public static AbstractFactory getAbstractFactory(String choice){
        if(choice.equalsIgnoreCase("realhero")) {
            return new RealHeroFactory();
        }
        else if(choice != null) {
            return new HeroABCFactory();
        }
        return null;
    }
}

编码测试：

public class Test {
    public static void main(String[] args) {
        // 真正的英雄的诞生
        AbstractFactory realHeroFactory = FactoryProducer.getAbstractFactory("realHero");
        RealHero realHero = realHeroFactory.getRealHero("qiYu");
        realHero.onePunch();

        // 其他英雄的诞生
        AbstractFactory heroFactory = FactoryProducer.getAbstractFactory("hero");
        HeroABC jieNoSi = heroFactory.getHeroABC("jieNoSi");
        HeroABC sexPrimer = heroFactory.getHeroABC("SexyPrimer");
        jieNoSi.fight();
        sexPrimer.fight();
    }
}

通过使用抽象工厂模式，可以将客户端与具体产品的创建过程解耦，使得客户端可以通过工厂接口来创建一族产品