设计模式系列之「工厂方法模式」

掘金地址：https://juejin.im/post/5a3229fbf265da431523ee15

“玛尼玛尼哄~~~”，一个手持螺旋丸的鸣人出现了。

“哦哈哟锅炸一马屎~~~”，一个仙人模式的鸣人出现了。

“死密码撒~~~”，使用变身术的鸣人出现了。

“卡通，阿里噶哆~~~”，多重影分身术的鸣人出现了。

……

《火影》甜蜜the End了，小Y既是感慨又怀念啊，想当年小Y也是有过疯狂追剧的年少经历，也像其他人一样被鸣人层出不穷的吊炸天的技能弄得热血澎湃,真的是满满的回忆杀。为了怀念逝去的青春，小Y要用代码的形式制造出不同模式和技能的鸣人，Action。

一、制造不同的鸣人

1.扫描分析不同的鸣人

①螺旋丸的鸣人
咒语：玛尼玛尼哄~~~
能力：形成手掌般大小的查克拉球。
②仙人模式的鸣人
咒语：哦哈哟锅炸一马屎~~~
能力：可以利用自身周围的自然能量，使攻击范围更广。
③多重影分身术的鸣人
咒语：卡通，阿里噶哆~~~
能力：一次分出多个影分身。

首先是需要一个专门生产鸣人的工厂，生产具有不同能力的三种鸣人，三种不同的鸣人都归属为鸣人，只是咒语和能力不同，在代码上来讲都是同一接口下的不同实现类，分析到这里，就可以得出这次要讲的设计模式-工厂方法模式。

2.图说鸣人

[图片上传失败…(image-6413fb-1514132301169)]

3.代码实现

①MingRen接口是对鸣人的总称

public interface MingRen {
    //鸣人使用不同能力的咒语
    void getSpell();
    //能力的介绍
    void getAbility();
}

②仙人模式的鸣人

public class MingRenOfFairy implements MingRen {
    @Override
    public void getSpell() {
        System.out.println("哦哈哟锅炸一马屎~~~");
    }

    @Override
    public void getAbility() {
        System.out.println("可以利用自身周围的自然能量，使攻击范围更广。");
    }
}

③螺旋丸的鸣人

public class MingRenOfSpiral implements MingRen {
    @Override
    public void getSpell() {
        System.out.println("玛尼玛尼哄~~~");
    }

    @Override
    public void getAbility() {
        System.out.println("形成手掌般大小的查克拉球。");
    }
}

④多重影分身术的鸣人

public class MingRenOfSeparate implements MingRen {
    @Override
    public void getSpell() {
        System.out.println("卡通，阿里噶哆~~~");
    }

    @Override
    public void getAbility() {
        System.out.println("一次分出多个影分身。");
    }
}

⑤抽象鸣人工厂

public abstract class AbstractMingRenFactory {
    public abstract <T extends MingRen> T createMingRen(Class<T> c);
}

⑥鸣人制造工厂

public class MingRenFactory extends AbstractMingRenFactory {
    //定义一个要生产的鸣人
    private MingRen mingRen;
    @Override
    public <T extends MingRen> T createMingRen(Class<T> c) {
        try {
            //生产鸣人
            mingRen= (MingRen) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) mingRen;
    }
}

⑦Client实现生产鸣人

public class Client {

    public static void main(String []args){
        //声明一个鸣人制造工厂
        AbstractMingRenFactory mingRenFactory=new MingRenFactory();
        //制造一个仙人模式的鸣人
        MingRenOfFairy mingRenOfFairy=mingRenFactory.createMingRen(MingRenOfFairy.class);
        mingRenOfFairy.getAbility();
        mingRenOfFairy.getAbility();
        //制造一个螺旋丸的鸣人
        MingRenOfSpiral mingRenOfSpiral=mingRenFactory.createMingRen(MingRenOfSpiral.class);
        mingRenOfSpiral.getSpell();
        mingRenOfFairy.getAbility();
        //制造一个多重分身术的鸣人
        MingRenOfSeparate mingRenOfSeparate=mingRenFactory.createMingRen(MingRenOfSeparate.class);
        mingRenOfSeparate.getSpell();
        mingRenOfSeparate.getAbility();
    }
}

、

⑧输出结果

//仙人模式的鸣人
哦哈哟锅炸一马屎~~~  
可以利用自身周围的自然能量，使攻击范围更广。
//螺旋丸的鸣人
玛尼玛尼哄~~~   
形成手掌般大小的查克拉球。  
//多重分身术的鸣人
卡通，阿里噶哆~~~   
一次分出多个影分身。

二、基本概念

1.定义

定义一个用于创建对象的接口，让子接口决定实例化哪一个类。

2.角色介绍

通用工厂方法UML

Product抽象产品类
定义产品共性，实现对事物最抽象的定义。
Creator抽象创建类
抽象创建类，也就是抽象工厂。
ConcreteCreator
具体如何创建产品类是由ConcreteCreator完成的。
ConcreteProduct
Product的具体实现。

3.理解

由上面制造鸣人的例子可以看出，抽象鸣人工厂采用了泛型，这样的好处就是限制了createMingRen输入参数必须是Class类型而且必须实现MingRen接口，其中“T”表示只要实现了MingRen接口的类都可以作为参数。

4.应用场景

工厂方法是new一个对象的替代品，当有在需要生成对象的地方可以考虑。
需要灵活的可以扩展的框架是可以考虑。
工厂模式是一种典型的解耦模式，迪米特法则在工厂模式中表现的尤为明显。假如调用者自己组装产品需要增加依赖关系时，可以考虑使用工厂模式。

三、工厂方法模式的扩展

1.工厂方法模式实现单例

①单例模式

public class Singleton {
    //私有化，不允许通过new产生一个对象
    private static Singleton singleton=new Singleton();
    private Singleton() {
    }
    public static Singleton getSingleton(){
        return singleton;
    }   
}

②工厂方法模式实现单例模式

//具体单例类
public class Singleton{
    //需要私有化
    private Singleton() {
    }
    public void doSomething(){
    }
}

//使用工厂方法模式进行创建单例
public class SingletonFactory {

    private static Singleton singleton;
    static {
        Class c1 = null;
        try {
            c1 = Class.forName(Singleton.class.getName());
            //获得无参构造
            Constructor constructor = c1.getDeclaredConstructor();
            //产生一个实例对象
            constructor.setAccessible(true);
            singleton = (Singleton) constructor.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }

    public static Singleton getSingleton(){
        return singleton;
    }

}

上述代码主要是通过反射方式创建的。

2.简单的工厂模式

public class MingRenFactory{

    public static <T extends MingRen> T createMingRen(Class<T> c) {
        MingRen mingRen = null;
        try {
            //生产鸣人
            mingRen= (MingRen) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
        e.printStackTrace();
        }
        return (T) mingRen;
    }
}

简单工厂模式没有抽象的工厂接口，在MingRenFactory定义了一个静态方法，因此这也叫做静态工厂模式，但是简单工厂模式的缺点就是扩展比较困难，不符合开闭原则，抛开这点来说，简单工厂模式还是十分实用的。

四、工厂方法模式优缺点

1.优点

良好的封装性，结构清晰，调用者只需要关心接口。
有非常好的扩展性，需要构建另外一种模式的鸣人，只需要新建一个模式类就可以了。
解耦性强，符合迪米特原则、依赖倒置原则、里氏替换原则、开闭原则。

2.缺点

由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度。
在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加。

五、总结

工厂方法模式是一个使用频率比较高的模式，要理解透才能更好使用。

Android技术交流吧