工厂模式

工厂模式细分有三种，分别为：简单工厂模式、工厂方法模式、抽象工厂模式。现单个的讲，最后再讲这三个的区别。

这篇文章主要通过一个农场的实例来讲解，这也是《java与模式》书中的例子，只不过我对一些部分进行了简化，一些部分进行了扩充，以帮助理解。

例子如下：

有一个农场公司，专门向市场销售各类水果。有如下水果：

● 葡萄（grape）

● 草莓（strawberry）

● 苹果（apple）

源码如下：http://download.csdn.net/detail/chenyiming_1990/7100743

简单工厂模式：

这个比较简单，写一下源代码。源代码中给出了必须的注释。代码比书上的要简单一些，排版也好看一些，只是为了让新手更好的理解。

//Fruit.java:
public interface Fruit
{
	/**
	* 水果与其它植物相比有一些专门的属性，以便与农场的
	* 其它植物区分开。这里的水果假设它必须具备的方法：
	* 生长grow()、收获harvest()、种植plant()
	*/
	void grow();
	void harvest();
	void plant();
}

//下面是Apple类的函数Apple.java:
public class Apple implements Fruit
{
	/** 
	* 苹果是水果类的一种，因此它必须实现水果接口的所有方法。即
	* grow()、harvest()、plant()三个函数。另外，由于苹果是多年生植物，
	* 所以多出一个treeAge性质，描述苹果的树龄。
	*/
	
	private int treeAge;
	
	public void grow() { //苹果的生长函数代码 }
	public void harvest() { //苹果的收获函数代码 }
	public void plant() { //苹果的种植函数代码 }
	
	public int getTreeAge() { return treeAge; }
	public void setTreeAge(int treeAge) { this.treeAge = treeAge; }
}

//下面是Grape类的函数Grape.java:
public class Grape implements Fruit
{
	/** 
	* 葡萄是水果类的一种，因此它必须实现水果接口的所有方法。即
	* grow()、harvest()、plant()三个函数。另外，由于葡萄分为有籽和无籽
	* 两种，因此多出一个seedless性质，描述葡萄有籽还是无籽。
	*/
	private boolean seedless;
	
	public void grow() { //葡萄的生长函数代码 }
	public void harvest() { //葡萄的收获函数代码 }
	public void plant() { //葡萄的种植函数代码 }
	
	public boolean getSeedless() { return seedless; }
	public void setSeedless(boolean seedless) { this.seedless = seedless; }

}

//下面是Strawberry类的函数Strawberry.java:
public class Strawberry implements Fruit
{
	/** 
	* 草莓是水果类的一种，因此它必须实现水果接口的所有方法。即
	* grow()、harvest()、plant()三个函数。另外，这里假设草莓分为大棚草莓和一般
	* 草莓（即没有棚的草莓）。因此草莓比一般水果多出一个性质coteless，描述草莓
	* 是大棚草莓还是没有大棚的草莓
	*/
	
	private boolean coteless;
	public void grow() { //草莓的生长函数代码 }
	public void harvest() { //草莓的收获函数代码 }
	public void plant() { //草莓的种植函数代码 }
	public boolean getCoteless() { return coteless; }
	public void setCoteless(boolean coteless) { this. coteless = coteless; }

}

/**
	农场的园丁也是系统的一部分，自然要有一个合适的类来代表，我们用FruitGardener类
	来表示。FruitGardener类会根据客户端的要求，创建出不同的水果对象，比如苹果（apple）,
	葡萄（grape）或草莓（strawberry）的实例。代码如下所示：
*/
//FruitGardener.java:
public class FruitGardener
{
	/**
	* 通过下面的表态工厂方法，可以根据客户的需要，创建出不同的水果对象
	* 如果提供的参数是“apple”则通过“return new Apple()”创建出苹果实例
	* 如果是提供的参数是“grape”则创建葡萄实例，这正是简单工厂方法之精髓
	*/
	public static Fruit factory(String which) throws BadFruitException
	{
		if (which.equalsIgnoreCase("apple")) { return new Apple(); }
		else if (which.equalsIgnoreCase("strawberry")) { return new Strawberry(); }
		else if (which.equalsIgnoreCase("grape")) { return new Grape(); }
		else { throw new BadFruitException("Bad fruit request"); }
	}
}

简单工厂方法的优点是当在系统中引入新产品时不必修改客户端，但需要个修改工厂类，将必要的逻辑加入到工厂类中。工厂方法模式就克服了以上缺点，下面谈谈工厂

方法模式。

工厂方法模式:

由于水果接口以及grape类、strawberry类、apple类的代码都和上面的一样，所以下面相关的源码去掉了注释。

//Fruit.java:
public interface Fruit
{
	void grow();
	void harvest();
	void plant();
}

//Apple.java:
public class Apple implements Fruit
{
	private int treeAge;
	public void grow() { //苹果的生长函数代码 }
	public void harvest() { //苹果的收获函数代码 }
	public void plant() { //苹果的种植函数代码 }
	public int getTreeAge() { return treeAge; }
	public void setTreeAge(int treeAge) { this.treeAge = treeAge; }
}

//Grape.java:
public class Grape implements Fruit
{
	private boolean seedless;
	
	public void grow() { //葡萄的生长函数代码 }
	public void harvest() { //葡萄的收获函数代码 }
	public void plant() { //葡萄的种植函数代码 }
	
	public boolean getSeedless() { return seedless; }
	public void setSeedless(boolean seedless) { this.seedless = seedless; }
}

//Strawberry.java:
public class Strawberry implements Fruit
{
	private boolean coteless;
	public void grow() { //草莓的生长函数代码 }
	public void harvest() { //草莓的收获函数代码 }
	public void plant() { //草莓的种植函数代码 }
	public boolean getCoteless() { return coteless; }
	public void setCoteless(boolean coteless) { this. coteless = coteless; }

}

/*
	下面的源码就是工厂方法模式的重点了，在简单工厂模式中，将这里将FruitGardener定
	义为一个类，即园丁要管理园里的所有水果，如果园丁哪天病了，水果都不能管理了。
	在工厂方法模式中将FruitGardener定义为一个接口，而将管理水果的角色划分得更细，
	比如有
	“葡萄园丁”、“草莓园丁”、“苹果园丁”等等。具体角色实现FruitGardener接口的工厂
	方法。源码如下所示：
*/
	
//接口FruitGardener的源码：
public interface FruitGardener
{
	Fruit factory();
}

//苹果园丁类AppleGardener.java的源码：
public class AppleGardener implements FruitGardener
{
	public Fruit factory() { return new Apple(); }
}

//葡萄园丁类GrapeGardener.java的源码：
public class GrapeGardener implements FruitGardener
{
	public Fruit factory() { return new Grape(); }
}

//草莓园丁类StrawberryGardener.java的源码：
public class StrawberryGardener implements FruitGardener
{
	public Fruit factory() { return new Strawberry(); }
}

由以上源码可以看出，使用工厂方法模式保持了简单工厂模式的优点，克服了其缺点。当在系统中引入新产品时，既不必修改客户端，又不必修改具体工厂角色。可以较好
的对系统进行扩展。

抽象工厂模式：

现在工厂再次大发展，要引进塑料大棚技术，在大棚里种植热带（Tropical）和亚热带的水果和蔬菜（Veggie）。其中水果分为TropicalFruit和NorthernFruit，蔬菜分为TropicalVeggie和NorthernVeggie。园丁包括TropicalGardener和NorthernGardener。也就是说，TropicalGardener专门管理TropicalFruit和TropicalGardener，NorthernGardener专门管理NorthernFruit和NorthernVeggie。

抽象工厂模式在这个例子中的源码如下所示：

//Fruit.java:
public interface Fruit { }

//NorthernFruit.java:
public class NorthernFruit implements Fruit
{
	private String name;
	public NorthernFruit(String name) { }
	public String getName() { return name; }
	public void setName(String name) { this.name = name; }
}

//TropicalFruit.java:
public class TropicalFruit implements Fruit
{
	private String name;
	public TropicalFruit(String name) { }
	public String getName() { return name; }
	public void setName(String name) { this.name = name; }
}

//Veggie.java:
public interface Veggie { }

//TropicalVeggie.java:
public class TropicalVeggie implements Veggie
{
	private String name;
	public TropicalVeggie(String name) { }
	public String getName() { return name; }
	public void setName(String name) { this.name = name; }
}

//NorthernVeggie.java:
public class NorthernVeggie implements Veggie
{
	private String name;
	public NorthernVeggie(String name) { }
	public String getName() { return name; }
	public void setName(String name) { this.name = name; }
}

//Gardener.java:
public interface Gardener
{
	Fruit createFruit(String name);
	Veggie createVeggie(String name);
}

//TropicalGardener.java:
public class TropicalGardener implements Gardener
{
	public Fruit createFruit(String name) { return new TropicalFruit(name); }
	public Veggie createVeggie(String name) { return new TropicalVeggie(name); }
}

//NorthernGardener.java:
public class NorthernGardener implements Gardener
{
	public Fruit createFruit(String name) { return new NorthernFruit(name); }
	public Veggie createVeggie(String name) { return new NorthernVeggie(name); }
}

/*
 	为了简单起见，这里只讲一下增加新产品（族）时该系统如何扩展（关于产品族相关
	知识，请看此书的相关章节，不过不懂产品族也没有关系，这里写得很简单，肯定能
	看懂）。比如现在要增加南方水果（SouthFruit）和南方蔬菜（SouthVeggie）。那
	么只要增加如下代码即可很容易的扩展：
*/

//SouthFruit.java:
public class SouthFruit implements Fruit
{
	private String name;
	public SouthFruit (String name) { }
	public String getName() { return name; }
	public void setName(String name) { this.name = name; }
}

//SouthVeggie.java:
public class SouthVeggie implements Veggie
{
	private String name;
	public SouthVeggie (String name) { }
	public String getName() { return name; }
	public void setName(String name) { this.name = name; }
}

//SouthGardener.java:
public class SouthGardener implements Gardener
{
	public Fruit createFruit(String name) { return new SouthFruit(name); }
	public Veggie createVeggie(String name) { return new SouthVeggie(name); }
}