java设计模式（1）：简单工厂模式（Simple Factory）

中工厂模式又分为三类

1）简单工厂模式（Simple Factory）

2）工厂方法模式（Factory Method）

3）抽象工厂模式（Abstract Factory）

这三种模式从上到下逐步抽象，并且更具一般性。

GOF在《设计模式》一书中讲工厂模式分为两类：工厂方法模式（Factory Method）和抽象工厂模式（Abstract Factory），

将简单工厂模式（Simple Factory）看做工厂方法模式（Factory Method）的一种特例，两者归为一类。

 

下面我们来介绍下简单工厂模式（Simple Factory）

简单工厂模式又称作静态工厂方法模式。重命名上就可以看出这种模式一定很简单，它存在的目的很简单：定义一个用户创建对象的接口。

先看看它的组成

1）工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

2）抽象产品角色：它一般是由具体产品继承的父类或者实现的接口。在java中它往往由一个抽象类或者接口实现。

3）具体产品角色：工厂类所创建的对象就是此角色的实例。在java中它往往由一个具体类实现。

 

抽象产品角色（我们定义了一个打印机）

[java] view plaincopyprint?

1. public interface Printer  
2. {  
3.     public void out();  
4.       
5.     public void getData(String msg);  
6. }  

public interface Printer
{
public void out();

public void getData(String msg);
}

具体产品角色（我们定义两个产品，一个是普通打印机，一个是高速打印机）

[java] view plaincopyprint?

1. /** 
2.  * 普通打印机 
3.  */  
4. public class CommonPrinter implements Printer  
5. {  
6.     private  final int MAX_CACHE_LINE = 10;  
7.     private String[] printData = new String[MAX_CACHE_LINE];  
8.       
9.     private int dataNum = 0;  
10.   
11.     public void getData(String msg)  
12.     {  
13.         if(dataNum >= MAX_CACHE_LINE)  
14.         {  
15.             System.out.println("输出队列已满,添加失败");  
16.         }  
17.         else  
18.         {  
19.             printData[dataNum++] = msg;  
20.         }  
21.     }  
22.   
23.     public void out()  
24.     {  
25.         while(dataNum>0)  
26.         {  
27.             System.out.println("普通打印机打印: "+printData[0]);  
28.               
29.             System.arraycopy(printData,1,printData,0,--dataNum);  
30.         }  
31.     }  
32. }  
33.   
34.   
35. /** 
36.  * 高速打印机 
37.  */  
38. public class BetterPrinter implements Printer  
39. {  
40.     private  final int MAX_CACHE_LINE = 10;  
41.     private String[] printData = new String[MAX_CACHE_LINE * 2];  
42.       
43.     private int dataNum = 0;  
44.   
45.     public void getData(String msg)  
46.     {  
47.         if(dataNum >= MAX_CACHE_LINE * 2)  
48.         {  
49.             System.out.println("输出队列已满,添加失败");  
50.         }  
51.         else  
52.         {  
53.             printData[dataNum++] = msg;  
54.         }  
55.     }  
56.   
57.     public void out()  
58.     {  
59.         while(dataNum>0)  
60.         {  
61.             System.out.println("高速打印机打印: "+printData[0]);  
62.               
63.             System.arraycopy(printData,1,printData,0,--dataNum);  
64.         }  
65.     }  
66. }  

/**
 * 普通打印机
 */
public class CommonPrinter implements Printer
{
private  final int MAX_CACHE_LINE = 10;
private String[] printData = new String[MAX_CACHE_LINE];

private int dataNum = 0;

public void getData(String msg)
{
if(dataNum >= MAX_CACHE_LINE)
{
System.out.println("输出队列已满,添加失败");
}
else
{
printData[dataNum++] = msg;
}
}

public void out()
{
while(dataNum>0)
{
System.out.println("普通打印机打印: "+printData[0]);

System.arraycopy(printData,1,printData,0,--dataNum);
}
}
}


/**
 * 高速打印机
 */
public class BetterPrinter implements Printer
{
private  final int MAX_CACHE_LINE = 10;
private String[] printData = new String[MAX_CACHE_LINE * 2];

private int dataNum = 0;

public void getData(String msg)
{
if(dataNum >= MAX_CACHE_LINE * 2)
{
System.out.println("输出队列已满,添加失败");
}
else
{
printData[dataNum++] = msg;
}
}

public void out()
{
while(dataNum>0)
{
System.out.println("高速打印机打印: "+printData[0]);

System.arraycopy(printData,1,printData,0,--dataNum);
}
}
}

 

 最后是测试了，我们定义一台计算机，由它调用工厂去生产我们需要的打印机。需要什么类型的打印机，就给工厂传入对应的类型，由工厂返回我们需要的打印机。

[java] view plaincopyprint?

1. public class Computer  
2. {  
3.     private Printer out;  
4.   
5.     public Computer(Printer out)  
6.     {  
7.         this.out = out;  
8.     }  
9.     public void keyIn(String msg)  
10.     {  
11.         out.getData(msg);  
12.     }  
13.     public void print()  
14.     {  
15.         out.out();  
16.     }  
17.     public static void main(String[] args)  
18.     {  
19.         PrinterFactory of = new PrinterFactory();  
20.           
21.         Computer c = new Computer(of.getPrinter("common"));  
22.           
23.         c.keyIn("hello");  
24.         c.keyIn("world");  
25.           
26.         c.print();  
27.     }  
28. }  

public class Computer
{
private Printer out;

public Computer(Printer out)
{
this.out = out;
}
public void keyIn(String msg)
{
out.getData(msg);
}
public void print()
{
out.out();
}
public static void main(String[] args)
{
PrinterFactory of = new PrinterFactory();

Computer c = new Computer(of.getPrinter("common"));

c.keyIn("hello");
c.keyIn("world");

c.print();
}
}

打印结果：

普通打印机打印: hello
普通打印机打印: world

这便是简单工厂模式了，怎么样使用起来简单吧，那么它带来了什么好处呢？

首先使用了简单工厂模式后，我们的程序不在“有病”，更加符合现实中的情况，而且客户端避免除了直接创建产品对象的责任，而仅仅负责“消费”产品