设计模式（二）——工厂模式

         今天来说一个很基础的设计模式——工厂设计模式。其实工厂设计模式可以细分为三种类似的设计模式：

1）简单工厂模式（SimpleFactory）：简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。

2）工厂方法模式（FactoryMethod）：又称为多形性工厂，有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。

3）抽象工厂模式（AbstractFactory）：又称为工具箱，产生产品族，但不利于产生新的产品；        这三种模式从上到下逐步抽象，并且更具一般性。抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。

         下面列出这三种设计模式的类图，从总体上来把个关：

（1）      简单工厂模式：

（2）      工厂方法模式：

 

（3）      抽象工厂模式：

 

还是惯例，贴上实例代码帮助理解：

（1）      简单工厂模式：

 所有的产品类都要实现同一个产品接口：

package com.xdccl.zwj.SimpleFactoryDesignPatterns;

public interface Product {

}

具体的产品类：

package com.xdccl.zwj.SimpleFactoryDesignPatterns;

public class Computer implements Product {
	public Computer(){
		System.out.println("生产了电脑！");
	}
}

package com.xdccl.zwj.SimpleFactoryDesignPatterns;

public class MobilePhone implements Product {
	public MobilePhone(){
		System.out.println("生产了手机！");
	}
}

简单工厂类：

package com.xdccl.zwj.SimpleFactoryDesignPatterns;

public class SimpleFactory {
	public static Product factory(String productName) throws Exception{
		if("Computer".equals(productName))
			return new Computer() ;
		else if("MobilePhone".equals(productName))
			return new MobilePhone() ;
		else
			throw new Exception("你所需要生产的产品不存在！") ;
	}
}

客户端：

package com.xdccl.zwj.SimpleFactoryDesignPatterns;

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			SimpleFactory.factory("Computer") ;
			SimpleFactory.factory("MobilePhone") ;
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

如果执行以上代码，那么可以得到的结果应该是：

生产了电脑！
生产了手机！

这也就说明相应的简单工厂可以生产对应对象的实例。

（2）      工厂方法模式：

  在该方法中，将工厂和产品分别抽象出来，这样的好处是，一旦一个工厂出问题，也不会影响到其他工厂的生产。

工厂接口：

package com.xdccl.zwj.FactoryMethodDesignPatterns;

public interface Factory {
	//工厂接口
	/**
	 * 用来生产的方法，不同的工厂应该具有不同的生产产品
	 * @return	返回生产的产品对象
	 */
	public Product create() ;
}

工厂类，具体的生产工厂：

package com.xdccl.zwj.FactoryMethodDesignPatterns;

public class ComputerFactory implements Factory{

	@Override
	public Product create() {
		return new Computer();
	}

}

package com.xdccl.zwj.FactoryMethodDesignPatterns;

public class MobilePhoneFactory implements Factory {

	@Override
	public Product create() {
		return new MobilePhone();
	}

}

产品接口：

package com.xdccl.zwj.FactoryMethodDesignPatterns;

public interface Product {
	//产品接口
}

产品类：

package com.xdccl.zwj.FactoryMethodDesignPatterns;

public class Computer implements Product {
	public Computer(){
		System.out.println("一个新电脑！");
	}
}

package com.xdccl.zwj.FactoryMethodDesignPatterns;

public class MobilePhone implements Product {
	public MobilePhone(){
		System.out.println("一个新手机!");
	}
}

客户端：

package com.xdccl.zwj.FactoryMethodDesignPatterns;

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new ComputerFactory().create() ;			//生产一个电脑
		new MobilePhoneFactory().create() ;			//生产一个手机
	}

}

如果上面的代码运行顺利，那么就可以得到下面的结果：

一个新电脑！
一个新手机!
（3）      抽象工厂模式：

  抽象工厂模式是将产品分类，工厂也进行分类，这样的好处就是可以选择性调用。

具体类产品接口：

package com.xdccl.zwj.AbstractFactoryDesignPatterns;

public interface Computer {
	//电脑产品的接口
}

package com.xdccl.zwj.AbstractFactoryDesignPatterns;

public interface MobilePhone {
	//手机产品的接口
}

分类后的产品：

package com.xdccl.zwj.AbstractFactoryDesignPatterns;

public class ComputerA implements Computer {
	public ComputerA(){
		System.out.println("电脑A产品");
	}
}
package com.xdccl.zwj.AbstractFactoryDesignPatterns;

public class ComputerB implements Computer {
	public ComputerB(){
		System.out.println("电脑B产品");
	}
}

package com.xdccl.zwj.AbstractFactoryDesignPatterns;

public class MobilePhoneA implements MobilePhone {
	public MobilePhoneA(){
		System.out.println("手机A产品");
	}
}
package com.xdccl.zwj.AbstractFactoryDesignPatterns;

public class MobilePhoneB implements MobilePhone {
	public MobilePhoneB(){
		System.out.println("手机B产品");
	}
}

工厂类：

package com.xdccl.zwj.AbstractFactoryDesignPatterns;

public interface Factory {
	public Computer createComputer() ;
	public MobilePhone createMobilePhone() ;
}

具体的工厂进行分类：

package com.xdccl.zwj.AbstractFactoryDesignPatterns;

public class FactoryA implements Factory {

	@Override
	public Computer createComputer() {
		return new ComputerA();
	}

	@Override
	public MobilePhone createMobilePhone() {
		return new MobilePhoneA();
	}

}

package com.xdccl.zwj.AbstractFactoryDesignPatterns;

public class FactoryB implements Factory {

	@Override
	public Computer createComputer() {
		return new ComputerB();
	}

	@Override
	public MobilePhone createMobilePhone() {
		return new MobilePhoneB();
	}

}

客户端：

package com.xdccl.zwj.AbstractFactoryDesignPatterns;

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//生产A产品
		Factory fa = new FactoryA() ;
		fa.createComputer() ;
		fa.createMobilePhone() ;
		//生产B产品
		Factory fb = new FactoryB() ;
		fb.createComputer() ;
		fb.createMobilePhone() ;
	}

}

如果如上所述，结果应该是：

电脑A产品
手机A产品
电脑B产品
手机B产品

好了，这些就是工厂模式了，总结完毕，好长好累啊~~