简单工厂模式实例学习（一）

文章参考了网上诸多大神的博客写的，仅作为学习和参考。有错误的地方希望能指出改进。

一、简单工厂模式

简单工厂模式最直接的目的就是为了解耦，把对象的创建和使用的过程分开。用工厂方法来代替new操作的一种模式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

需求：在没有引入工厂模式之前，假定我们需要组装一台电脑（这边以显示器和主机为例）。

显示器的属性包括：型号（三星（Samsung），戴尔（Dell））；长度（22英寸，24英寸）。 主机的属性包括：主板（联想（Lenovo），华硕（Asus））；cpu（AMD，Intel）。

定义两个实体类,通过getOwners方法返回产品信息。

显示器实体类：

package SimpleFactoryPattern.bean;

/**
 * 显示器
 * @author you
 *
 */
public class DisplayDevice {
	
	//产品型号
	private String productModel;
	
	//显示器长度
	private double size;
	
	/**
	 * 构造方法
	 * @param productModel 产品型号
	 * @param size 显示器长度
	 */
	public DisplayDevice(String productModel,double size) {
		// TODO Auto-generated constructor stub
		
		this.productModel = productModel;
		this.size = size;
		
	}
	
	public String getOwners()
	{
		return "显示器型号："+this.productModel+";长度:"+this.size+"英寸";
	}
	
}

主机实体类：

package SimpleFactoryPattern.bean;

/**
 * 主机
 * @author you
 *
 */
public class Computer {
	
	//主板型号
	private String mainBoardModel;
	
	//cpu型号
	private String cpuModel;
	
	/**
	 * 构造方法
	 * @param mainBoardModel 主板型号
	 * @param cpuModel cpu型号
	 */
	public Computer(String mainBoardModel,String cpuModel) {
		// TODO Auto-generated constructor stub
		this.mainBoardModel = mainBoardModel;
		this.cpuModel = cpuModel;
	}
	
	public String getOwners()
	{
		return "主机主板型号："+this.mainBoardModel+";cpu型号:"+this.cpuModel ;
	}

}

假定客户需要一台22英寸三星显示器，带有Intel CPU，华硕主板的主机，和一台24英寸戴尔显示器，带有AMD CPU，联想主板的主机。客户端代码：

package SimpleFactoryPattern.clientmain;

import SimpleFactoryPattern.bean.Computer;
import SimpleFactoryPattern.bean.DisplayDevice;

/**
 * 无模式客户端实现类
 * @author you
 *
 */
public class MakeComputerClient {

	public static void main(String[] args) {
		
		/* 假定客户需要一台22英寸三星显示器，带有Intel CPU，华硕主板的主机
		和一台24英寸戴尔显示器，带有AMD CPU，联想主板的主机。*/
		DisplayDevice displayDevice = new DisplayDevice("Samsung", 22);
		Computer computer = new Computer("Asus","Intel");
		
		DisplayDevice displayDevice2 = new DisplayDevice("Dell", 24);
		Computer computer2 = new Computer("Lenovo","AMD");
		
		System.out.println("客户得到第一台电脑："+displayDevice.getOwners()
				+";"+computer.getOwners());
		
		System.out.println("客户得到第二台电脑："+displayDevice2.getOwners()
				+";"+computer2.getOwners());

	}
}

运行结果：

 

引入简单工厂模式，新建一个工厂类，通过getOwners方法返回产品信息。：

package SimpleFactoryPattern.factory;

import SimpleFactoryPattern.bean.Computer;
import SimpleFactoryPattern.bean.DisplayDevice;

/**
 * 电脑工厂
 * @author you
 *
 */
public class ComputerFactory {

	//主机信息
	private static Computer computer;

	//显示器信息
	private static DisplayDevice displayDevice;

	/**
	 * 创建电脑
	 * @param type 创建电脑的类型
	 */
	public static String createComputer(int type)
	{
		switch (type) {
		case 1:
		{
			//22英寸三星显示器，带有Intel CPU，华硕主板的主机
			displayDevice = new DisplayDevice("Samsung", 22);
			computer = new Computer("Asus","Intel");
			return getOwners();
		}
		case 2:	
		{
			//一台24英寸戴尔显示器，带有AMD CPU，联想主板的主机。
			displayDevice = new DisplayDevice("Dell", 24);
			computer = new Computer("Lenovo","AMD");
			return getOwners();
		}
		default:

			return "";
		}
	}

	public static String getOwners()
	{
		return displayDevice.getOwners()+";"+computer.getOwners();
	}



}

此时客户端代码修改为：

package SimpleFactoryPattern.clientmain;

import SimpleFactoryPattern.factory.ComputerFactory;

/**
 * 简单工厂模式客户端实现类
 * @author you
 *
 */
public class SimpleFactoryClient {

	public static void main(String[] args) {
		
		/* 假定客户需要一台22英寸三星显示器，带有Intel CPU，华硕主板的主机
		和一台24英寸戴尔显示器，带有AMD CPU，联想主板的主机。*/
	
		System.out.println("客户得到第一台电脑："+ComputerFactory.createComputer(1));
		
		System.out.println("客户得到第二台电脑："+ComputerFactory.createComputer(2));

	}
}

运行结果:

 

优点：工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

 

缺点：由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。

当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

这些缺点在工厂方法模式中得到了一定的克服。