java常用设计模式-工厂模式的实现

葡萄（grape）或草莓（strawberry）的实例代码如下所示：
FruitGardener.java:
/**
*通过下面的表态工厂方法，可以根据客户的需要，创建出不同的水果对象
*如果提供的参数是apple则通过return new Apple()创建出苹果实例
*如果是提供的参数是grape则创建葡萄实例，这正是简单工厂方法之精髓
Fruit.java:
/**
*水果与其它植物相比有一些专门的属性，以便与农场的
*其它植物区分开这里的水果假设它必须具备的方法：
*生长grow()收获harvest()种植plant()
*/
public interface Fruit
{
void grow();
void harvest();
void plant();
当在系统中引入新产品时，既不必修改客户端，又不必修改具体工厂角色可以较好
的对系统进行扩展
/*------------------------------------3、抽象工厂模式：------------------------------------*/
现在工厂再次大发展，要引进塑料大棚技术，在大棚里种植热带（Tropical）和亚热带的
public void harvest() { //葡萄的收获函数代码}
public void plant() { //葡萄的种植函数代码}
public boolean getSeedless() { return seedless; }
public void setSeedless(boolean seedless) { this.seedless = seedless; }
public void setTreeAge(int treeAge) { this.treeAge = treeAge; }
}
Grape.java:
public class Grape implements Fruit
{
private boolean seedless;
public void grow() { //葡萄的生长函数代码}
*/
public class Apple implements Fruit
{
private int treeAge;
public void grow() { //苹果的生长函数代码}
public void harvest() { //苹果的收获函数代码}
public void plant() { //苹果的种植函数代码}
{
public Fruit factory() { return new Apple(); }
}
葡萄园丁类GrapeGardener.java的源码：
public class GrapeGardener implements FruitGardener
{
public Fruit factory() { return new Grape(); }
}
}
简单工厂方法的优点是当在系统中引入新产品时不必修改客户端，但需要个修改工厂
类，将必要的逻辑加入到工厂类中工厂方法模式就克服了以上缺点，下面谈谈工厂
方法模式
/*------------------------------------------2、工厂方法模式-------------------------------*/
{
private int treeAge;
public void grow() { //苹果的生长函数代码}
public void harvest() { //苹果的收获函数代码}
public void plant() { //苹果的种植函数代码}
public int getTreeAge() { return treeAge; }
方法源码如下所示：
接口FruitGardener的源码：
public interface FruitGardener
{
Fruit factory();
}
苹果园丁类AppleGardener.java的源码：
public class AppleGardener implements FruitGardener
else if (which.equalsIgnoreCase("strawberry")) { return new Strawberry(); }
else if (which.equalsIgnoreCase("grape")) { return new Grape(); }
else { throw new BadFruitException("Bad fruit request"); }
工厂模式细分有三种，分别为：简单工厂模式、工厂方法模式和抽象工厂模式。
（现单个的讲，最后再讲这三个的区别）
这篇文章主要通过一个农场的实例来讲解，这也是java与模式书中的例子，只不过我对一些部分进行了简化，一些部分进行了扩充，以帮助理解例子如下：
有一个农场公司，专门向市场销售各类水果有如下水果：
葡萄（grape）
public void plant() { //草莓的种植函数代码}
public boolean getCoteless() { return coteless; }
public void setCoteless(boolean coteless) { this. coteless = coteless; }
}
Strawberry.java:
public class Strawberry implements Fruit
{
private boolean coteless;
public void grow() { //草莓的生长函数代码}
public void harvest() { //草莓的收获函数代码}
public void setCoteless(boolean coteless) { this. coteless = coteless; }
}
农场的园丁也是系统的一部分，自然要有一个合适的类来代表，我们用FruitGardener类
来表示FruitGardener类会根据客户端的要求，创建出不同的水果对象，比如苹果（apple）,
/**
*葡萄是水果类的一种，因此它必须实现水果接口的所有方法即
* grow()harvest()plant()三个函数另外，由于葡萄分为有籽和无籽
*两种，因此多出一个seedless性质，描述葡萄有籽还是无籽
*/
public class Grape implements Fruit
{
private boolean seedless;
{
private boolean coteless;
public void grow() { //草莓的生长函数代码}
public void harvest() { //草莓的收获函数代码}
public void plant() { //草莓的种植函数代码}
public boolean getCoteless() { return coteless; }
{
private String name;
public NorthernFruit(String name) { }
public String getName() { return name; }
*/
public class FruitGardener
{
public static Fruit factory(String which) throws BadFruitException
{
if (which.equalsIgnoreCase("apple")) { return new Apple(); }
}
草莓园丁类StrawberryGardener.java的源码：
public class StrawberryGardener implements FruitGardener
{
public Fruit factory() { return new Strawberry(); }
}
由以上源码可以看出，使用工厂方法模式保持了简单工厂模式的优点，克服了其缺点
水果和蔬菜（Veggie）其中水果分为TropicalFruit和NorthernFruit，蔬菜分为TropicalVeggie
和NorthernVeggie园丁包括TropicalGardener和NorthernGardener也就是说，
TropicalGardener专门管理TropicalFruit和TropicalGardener，NorthernGardener专门
public void grow() { //葡萄的生长函数代码}
public void harvest() { //葡萄的收获函数代码}
public void plant() { //葡萄的种植函数代码}
public boolean getSeedless() {
return seedless;
}
}
*下面的源码就是工厂方法模式的重点了，在简单工厂模式中，将这里将FruitGardener定
义为一个类，即园丁要管理园里的所有水果，如果园丁哪天病了，水果都不能管理了
在工厂方法模式中将FruitGardener定义为一个接口，而将管理水果的角色划分得更细，
比如有
葡萄园丁草莓园丁苹果园丁等等具体角色实现FruitGardener接口的工厂
public int getTreeAge() { return treeAge; }