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

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

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

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

......

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

一、制造不同的鸣人

1.扫描分析不同的鸣人

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

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

2.图说鸣人

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.角色介绍

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.缺点

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

五、总结

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