设计模式之三种工厂模式

工厂模式，简而言之，就是产对象的（获得实例化对象）。但是生产过程中厂内分工生产吗？厂间合作生产吗？不同情况，生产方案也不同。全面的来说，有三种工厂模式。

1。简单工厂模式：就一个工厂（类），生产同一接口下的产品（产品也就是该接口的不同实现类，可以不唯一）。关键点：一个工厂类，同一接口（一定要理解）

举个例子：工厂A生产鞋帮，鞋垫，鞋舌。其中就只有A一家厂商，同时鞋带、鞋垫、鞋舌都是基于厂家对鞋子生产加工的设计接口。

代码如下：

工厂类：

public class SimpleFactory {
	// 方案1
	// public IDesign produceXieBang() {
	// return new XieBang();
	// }
	//
	// public IDesign produceXieDian() {
	// return new XieDian();
	// }
	//
	// public IDesign produceXieShe() {
	// return new XieShe();
	// }

	// 方案2
	public static IDesign produce(Class c) {
		IDesign process = null;
		try {
			process = (IDesign) Class.forName(c.getName()).newInstance();
			return process;
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return process;
	}
}

同一接口：

package _5thAnd6th_Fatory;

public interface IDesign {
	void produce();
}

三个部件分别实现接口：

public class XieBang implements IDesign {

	@Override
	public void produce() {
		System.out.println("生产鞋帮");
	}

}

public class XieDian implements IDesign {

	@Override
	public void produce() {
		System.out.println("生产鞋垫");
	}

}

public class XieShe implements IDesign {

	@Override
	public void produce() {
		System.out.println("生产鞋舌");
	}

}

在看看下面的类图体会下：

2。工厂方法模式：在简单工厂模式的基础上，工厂方法模式就又抽象出了了一个工厂接口，在该接口下可以实现不同的工厂类，单独拿出其中一个工厂类来看，此时就是简单工厂模式。说白了，就是多了几个工厂来生产同一接口下的产品。关键点：一个工厂接口，多个工厂类，同一接口（一定要理解）

继续上面的例子：这时厂家B也参与了进来，同样负责鞋帮、鞋垫、鞋舌的生产，但显然这三部分依旧基于厂家对鞋子生产加工的设计接口（现在假设A,B厂无差别，使用同一接口）。

代码如下：

工厂类接口：

public interface AbstractFactoryMethod {
	IDesign produce(Class c);
}

对应的两个接口实现工厂：

public class FactoryMethod01 implements AbstractFactoryMethod {

	@Override
	public IDesign produce(Class c) {
		IDesign process = null;
		try {
			process = (IDesign) Class.forName(c.getName()).newInstance();
			return process;
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return process;
	}
}
//FactoryMethod02类同上

其余三个产品实现同简单模式，这里就不重复了。

下面是简化类图。

3。抽象工厂模式：前两种模式都是生产一个接口下的产品，但在抽象工厂模式中是生产多个接口下的不同产品，不同产品交由不同的工厂来做，因此原来的每个工厂都需要分裂成多个工厂来接手不同的产品。关键点：一个工厂接口，多个工厂类实现；多个产品接口；产品接口数等于工厂实现类数。

再继续上面的例子：以上的两个例子都是基于那三部分的生产规格大小不变的基础上的，因此忽略了鞋帮、鞋垫、鞋舌自身的实现接口细节。倘若现在要考虑生产的大小。那么，A厂为了避免生产混乱，于是乎三个部分可分别定义一个接口，大、小两种类别都实现接口，一个生产大规格，一个生产小规格。同时可以将厂子分成了两部分，一部分负责生产大规格，另一部分生产小规格。

代码如下：

三个产品按大小分别定义出一个接口，并实现。

public interface IXieBang {
	void size();
}

public class SmallXieBang implements IXieBang {

	@Override
	public void size() {
		System.out.println("生产小鞋帮");
	}

}

public class BigXieBang implements IXieBang {

	@Override
	public void size() {
		System.out.println("生产大鞋帮");
	}

}

其余两个同上，均按大、小分别实现新定义的接口。

一个工厂接口：

public interface AbstractFactory {
	IXieBang produceXieBang();
	IXieShe produceXieShe();
	IXieDian produceXieDian();
}

按规格分别实现该工厂接口：

public class BigFactory implements AbstractFactory {

	@Override
	public IXieBang produceXieBang() {
		return new BigXieBang();
	}

	@Override
	public IXieDian produceXieDian() {
		return null;//定义同XieBang，此处为了节省版面，故省略，不实现了
	}

	@Override
	public IXieShe produceXieShe() {
		return null;
	}

}

public class SmallFatory implements AbstractFactory {

	@Override
	public IXieBang produceXieBang() {
		return new SmallXieBang();
	}

	@Override
	public IXieDian produceXieDian() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public IXieShe produceXieShe() {
		// TODO Auto-generated method stub
		return null;
	}

}

通俗的来说。工厂被分成两个，一个只生产大件（大件鞋帮，大件鞋舌，大件鞋垫），另一个只生产小件（小件鞋帮，小件鞋舌，小件鞋垫）。但是，大件鞋帮和小件鞋帮都是鞋帮，他们实现了同一接口。如下面的简化类图，