工厂设计模式

                （1）简单工厂模式

                          1.核心

                            通过一个工厂类来创建对象，通常是将要创建的对象的类名传递进去即可

                          2.UML

                   

                          3.代码

                            本例模仿dota创建英雄，有一个专门创建英雄的工厂类，每次创建只要传入英雄名字即可。

                            英雄抽象类：

public interface Hero 
{
	public abstract void showName(); 
}

                           英雄1：Qop

public class Qop implements Hero 
{
	@Override
	public void showName() 
	{
		System.out.println("I am qop");
	}
}

                           英雄2：BM

public class BM implements Hero 
{
	@Override
	public void showName() 
	{
		System.out.println("I am bm");
	}
}

                           工厂类：

public class HeroFactory 
{
	public static Hero createHero(String name)
	{
		if("qop".equalsIgnoreCase(name))
			return new Qop();
		else if("bm".equalsIgnoreCase(name))
			return new BM();
		else
			return null;
	}
}

                           客户端类：

public class Client {

	public static void main(String[] args)
	{
		Hero hero = HeroFactory.createHero("qOp");
		if(hero != null)
			hero.showName();
	}

}

                          4.使用场景

                            以jdbc为例，第一步加载数据库连接驱动，forName（name）就根据name创建出是mysql还是oracle等的连接类。

                        

                          5.缺点

                            如果增加新的类型，那么就需要修改工厂类

                （2）工厂模式

                          1.核心

                            每一个产品都对应一个具体工厂，各个具体工厂都实现同一个工厂接口，这样增加一个产品就只用增加一个具体工厂即可。

                          2.UML

                          3.代码

                             英雄类接口：

public interface IHero 
{
	public abstract void showName();
}

                            英雄1：qop

public class Qop implements IHero 
{
	@Override
	public void showName() 
	{
		System.out.println("I am qop");
	}
}

                            英雄2：BM

public class BM implements IHero 
{
	@Override
	public void showName() 
	{
		System.out.println("I am bm");
	}
}

                            工厂类接口：

public interface IFactory 
{
	public abstract IHero getHero();
}

                            生产qop的工厂:

public class QopFactory implements IFactory 
{
	@Override
	public IHero getHero() 
	{
		return new Qop();
	}
}

                           生产bm的工厂

public class BmFactory implements IFactory 
{
	@Override
	public IHero getHero() 
	{
		return new BM();
	}
}

                          客户端：

public class Client 
{
	public static void main(String[] args) 
	{
		IFactory factory = null;

		//输入需要创建的英雄名字
		String name = "qop";
		
		//根据输入的英雄名字来创建英雄
		if("qop".equalsIgnoreCase(name))
			factory = new QopFactory();
		else if("bm".equalsIgnoreCase(name))
			factory = new BmFactory();
		
		if(factory != null)
		{
			IHero hero = factory.getHero();
			hero.showName();
		}
	}
}

                          4.优点

                             当需要增加一个新的类的时候，只需要增加一个工厂类，一个具体类即可。

                （3）抽象工厂模式

                          1.核心

                            每一个工厂生产同一个系列的产品，如有一个生产宝马汽车的工厂，生产多种型号的宝马，不同型号的宝马需要配置不同型号的空调，所以每一个具体工厂既生产这种型号的宝马，又生产这种汽车所配置的空调。

                          2.UML

                              

                          3.代码

                             车和空调的接口类：

public interface IBMW 
{
	public abstract void showName();
}

                             车的抽象类：

public abstract class BMW implements IBMW 
{
}

                             空调的抽象类：

public abstract class AirOfBMW implements IBMW 
{
}

                            宝马520车：

public class BMW520 extends BMW 
{
	@Override
	public void showName() 
	{
		System.out.println("I am bmw520");
	}
}

                          宝马521车：

public class BMW521 extends BMW 
{
	@Override
	public void showName() 
	{
		System.out.println("I am bmw521");
	}
}

                        宝马520的空调

public class Air520 extends AirOfBMW 
{
	@Override
	public void showName() 
	{
		System.out.println("I am air condition of BMW520");
	}
}

                      宝马521的空调

public class Air521 extends AirOfBMW 
{
	@Override
	public void showName() 
	{
		System.out.println("I am air condition of BMW521");
	}
}

                     生产宝马车和空调的工厂的接口：

public interface IFactory 
{
	public abstract BMW createCar();
	public abstract AirOfBMW createAir();
}

                  生产宝马520和他的配套空调的工厂

public class BMW520Factory implements IFactory
{
	@Override
	public BMW createCar() 
	{
		return new BMW520();
	}

	@Override
	public AirOfBMW createAir() 
	{
		return new Air520();
	}

}

                  生产宝马521和他的配套空调的工厂

public class BMW521Factory implements IFactory
{
	@Override
	public BMW createCar() 
	{
		return new BMW521();
	}

	@Override
	public AirOfBMW createAir() 
	{
		return new Air521();
	}

}

                客户端：

public class Client 
{
	public static void main(String[] args) 
	{
		String name = "BMW520";
		
		IFactory factory = null;
		if("BMW520".equalsIgnoreCase(name))
			factory = new BMW520Factory();
		else if("BMW521".equalsIgnoreCase(name))
			factory = new BMW521Factory();
		else
			factory = null;
		
		BMW bmw = null;
		AirOfBMW air = null;
		if(factory != null)
		{
			bmw = factory.createCar();
			air = factory.createAir();
		}
		
		if(bmw != null)
			bmw.showName();
		if(air != null)
			air.showName();
	}
}