设计模式之简单工厂模式

今天学习了第一个模式：简单工厂模式
   工厂模式就象现实中的工厂、产品、客户三者之间的关系。工厂根据客户的需求利用原材料生产产品。举个简单工厂一般形式的例子
class FruitFactory//核心工厂类
{
 public static Fruit makeFruit(String fruitName)
 {
   if(fruitName.equals("Apple"))
    return  new Apple();
   else if(fruitName.equals("Orange"))
    return new Orange();
   else if(fruitName.equals("Grape"))
    return new Grape();
   else 
    throw new BadFruit();
 }    
}

interface Fruit//Fruit接口
{
 public void grow();
 public void harvest();
 public void howToEat();
}

class Apple implements Fruit//Apple类
{
 public void grow()
 {
  //具体实现
 }
 public void harvest()
 {
  //具体实现
 }
 public void howToEat()
 {
 //具体实现
 }
}
class Orange implements Fruit//Orange类
{
 public void grow()
 {
  //具体实现
 }
 public void harvest()
 {
  //具体实现
 }
 public void howToEat()
 {
 //具体实现
 }
}
class  Grape implements Fruit//Grape类
{
 public void grow()
 {
  //具体实现
 }
 public void harvest()
 {
  //具体实现
 }
 public void howToEat()
 {
 //具体实现
 }
}
客户端程序
class EnjoyingFruits
{
 pubic static void main(String []args)
 {
  Apple apple=(Apple)FruitFactory.makeFruit("Apple");
 }
}
例子中FruitFactory是该模式的核心类，只要给他一个水果的名字,他就给你制造你所需要的产品（当他能够生产时，否则抛出异常），
在现实生活中，客户向农场定购一种水果,只需要告诉农场主这种水果的名字，然后农场就生产出客户所需要的水果。
在实际应用中也有一些退化的形式：
例如可以将上述的工厂类的功能挪到Fruit中
如:
abstract class Fruit
{
 public void grow();
 public void harvest();
 public void howToEat();
 public static Fruit getFruitInstance(String fruitName)
 {
  if(fruitName.equals("Apple"))
    return  new Apple();
   else if(fruitName.equals("Orange"))
    return new Orange();
   else if(fruitName.equals("Grape"))
    return new Grape();
   else 
    throw new BadFruit();
 }
}
//
单件模式也使用简单工厂的类似方法，但不是简单工厂的简单的退化形式，他还需要设置一些特殊的要求：
将构造函数私有，用一个静态的引用保存产生的实例；然后声明一个类似工厂的静态方法。
如下：
public class Singleton
{
 private static Singleton st;
 private Singleton(){};
 public static Singleton getInstance()
 {
   if(st==null)
     st=new Singleton();
   return st;
 }
}
//
在简单工厂中也可以用getInstance类似的懒汉似的方式，使得一个产品可以重复使用，客户的每个请求，工厂总是将那个指定的对象
返回。
上述只是提及单件模式与之比较加深的简单工厂的理解。也希望读者能过在学习时将各种模式进行比较,得出他们之间的联系。
以后会详细讨论单件模式和多件模式。
从上面的例子可以看出工厂的实现方式与产品的类继承层次无关，只是简单的根据产品的名字产生之（但必须有一个公共的基类如Fruit）。
简单工厂的应用还是比较广的，如 java中DataFormat类.
简单工厂在产品种类比较固定的时候比较合适.在产品种类不固定时,每增加一种产品就要修改工厂类,这是其缺点。
//改进方式：利用java的RTTI机制可以根据类名来创建一个对象：即Class.forName(className).newInstace();来动态的创建对象
而不用ifelse语句判断，程序如下：
class Factory
{
   public static Fruit makeFruit(String className)throws Exception
   {
 return (Fruit)(Class.forName(className)).newInstance();
   }
}
interface Fruit//Fruit接口
{
 public void grow();
 public void harvest();
 public void howToEat();
}

class Apple implements Fruit//Apple类
{
 public void grow()
 {
  System.out.println("Apple grow()");
 }
 public void harvest()
 {
   System.out.println("Apple harvest()");
 }
 public void howToEat()
 {
   System.out.println("Apple howToEat()");
 }
}
class Orange implements Fruit//Orange类
{
 public void grow()
 {
    System.out.println("Orange grow()");
 }
 public void harvest()
 {
    System.out.println("Orange harvest()");
 }
 public void howToEat()
 {
   System.out.println("Orange howToEat()");
 }
}
class  Grape implements Fruit//Grape类
{
 public void grow()
 {
   System.out.println("Grape grow()");
 }
 public void harvest()
 {
    System.out.println("Grape harvest()");
 }
 public void howToEat()
 {
   System.out.println("Grape howToEat()");
 }
}
public class Test
{
  public static void main(String []args)
  {
  try
  {
  Apple a=(Apple)Factory.makeFruit("Apple");//利用工厂直接生产
  a.grow();
  }catch(Exception e)
  {
   e.printStackTrace();
  }
 }
}