文章参考了网上诸多大神的博客写的，仅作为学习和参考。有错误的地方希望能指出改进。
一、
简单工厂模式
简单工厂模式最直接的目的就是为了解耦，把对象的创建和使用的过程分开。
用工厂方法
来
代替
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));
}
}
运行结果
:
优点：
工厂类是整个模式的关键
.
包含了必要的逻辑判断
,
根据外界给定的信息
,
决定究竟应该创建哪个具体类的对象
.
通过使用工厂类
,
外界可以从直接创建具体产品对象的尴尬局面摆脱出来
,
仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个
软件体系结构
的优化。
缺点：
由于工厂类集中了所有实例的创建逻辑，违反了
高内聚
责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；
这些缺点在
工厂方法模式
中得到了一定的克服。