Java设计模式—Factory 买货篇

今天老婆让我去市场买一些水果，具体买什么自己定（哈，老婆放放权了！）。来到市场，我发现主要有一些水果：苹果（Apple），葡萄（Grape）和鸭梨（Pear）。 
到底买什么好呢？我一阵思量。俗话说："饭后一只烟，赛过活神仙。饭后吃苹果，西施见我躲。"为了老婆的漂亮，我决定买苹果。 
好，言归正传，开始买吧！ 

主要有以下三种Factory模式： 
Simple Factory模式 
专门定义一个类来负责创建其它类的实例，被创建的实例通常都具有共同的父类。 
Factory Method模式 
将对象的创建交由父类中定义的一个标准方法来完成，而不是其构造函数，究竟应该创建何种对象由具体的子类负责决定。 
Abstract Factory模式 
提供一个共同的接口来创建相互关联的多个对象。 

一、Simple Factory模式： 
1、  在这里，我们先定义水果（Fruit）接口： 
public interface Fruit { 
  void plant();  //水果是被种植的 
  void enableEat();  //水果能吃 
} 
2、  苹果（Apple）是对水果（Fruit）接口的实现： 
public class Apple implements Fruit{ 
  public void plant(){ 
    System.out.println("种苹果!"); 
  } 
  public void enableEat(){ 
    System.out.println("苹果好吃!"); 
  } 
} 
3、  葡萄（Grape）是对水果（Fruit）接口的实现： 
public class Grape implements Fruit{ 
  public void plant(){ 
    System.out.println("种葡萄!"); 
  } 
  public void enableEat(){ 
    System.out.println("葡萄好吃!"); 
  } 
} 
4、  鸭梨（Pear）是对水果（Fruit）接口的实现： 
public class Pear implements Fruit{ 
  public void plant(){ 
    System.out.println("种鸭梨!"); 
  } 
  public void enableEat(){ 
    System.out.println("鸭梨好吃!"); 
  } 
} 
5、定义买水果（BuyFruit）这一过程类： 
public class BuyFruit { 
  /** 
  * 简单工厂方法 
  */ 
  public static Fruit buyFruit(String which){ 
    if (which.equalsIgnoreCase("apple")) {  //如果是苹果，则返回苹果实例 
      return new Apple(); 
    } 
    else if (which.equalsIgnoreCase("pear")){  //如果是鸭梨，则返回鸭梨实例 
      return new Strawberry(); 
    } 
    else if (which.equalsIgnoreCase("grape")) { //如果是葡萄，则返回葡萄实例 
      return new Grape(); 
    } 
    else{ 
      return null; 
    } 
  } 
} 
6、  编写测试类： 
public class FruitTest { 
  public static void  main(String args[]){ 
    BuyFruit buy = new BuyFruit();   //开始买水果这个过程 
    buy.buyFruit("apple").enableEat(); //调用苹果的enableEat()方法 
  } 
} 
7、  说明： 
A：我要购买苹果，只需向工厂角色（BuyFruit）请求即可。而工厂角色在接到请求后，会自行判断创建和提供哪一个产品。 
B：但是对于工厂角色（BuyFruit）来说，增加新的产品（比如说增加草莓）就是一个痛苦的过程。工厂角色必须知道每一种产品，如何创建它们，以及何时向客户端提供它们。换言之，接纳新的产品意味着修改这个工厂。 
C：因此Simple Factory模式的开放性比较差。 
有什么办法可以解决这个问题吗？那就需要Factory Method模式来为我们服务了。 
二、Factory Method模式： 
1、同样，我们先定义水果（Fruit）接口： 
public interface Fruit { 
  void plant();  //水果是被种植的 
  void enableEat();  //水果能吃 
} 
2、苹果（Apple）是对水果（Fruit）接口的实现： 
public class Apple implements Fruit{ 
  public void plant(){ 
    System.out.println("种苹果!"); 
  } 
  public void enableEat(){ 
    System.out.println("苹果好吃!"); 
  } 
} 
3、葡萄（Grape）是对水果（Fruit）接口的实现： 
public class Grape implements Fruit{ 
  public void plant(){ 
    System.out.println("种葡萄!"); 
  } 
  public void enableEat(){ 
    System.out.println("葡萄好吃!"); 
  } 
} 
4、鸭梨（Pear）是对水果（Fruit）接口的实现： 
public class Pear implements Fruit{ 
  public void plant(){ 
    System.out.println("种鸭梨!"); 
  } 
  public void enableEat(){ 
    System.out.println("鸭梨好吃!"); 
  } 
} 
5、在这里我们将买水果（BuyFruit）定义为接口类： 
public interface BuyFruit{ 
  /** 
  * 工厂方法 
  */ 
  public Fruit buyFruit();   //定义买水果这一过程 
} 
6、买苹果是（BuyApple）对买水果（BuyFruit）这个接口的实现 
public class BuyApple implements BuyFruit{ 
  public Fruit buyFruit(){ 
    return new Apple();  //返回苹果实例 
} 
} 
7、买鸭梨是（BuyPear）对买水果（BuyFruit）这个接口的实现 
public class BuyPear implements BuyFruit{ 
  public Fruit BuyPear (){ 
    return new Pear();  //返回鸭梨实例 
} 
} 
8、买葡萄是（BuyGrape）对买水果（BuyFruit）这个接口的实现 
public class BuyGrape implements BuyFruit{ 
  public Fruit BuyGrape (){ 
    return new Grape ();  //返回葡萄实例 
} 
} 
9、编写测试类： 
public class FruitTest { 
  public static void  main(String args[]){ 
    BuyApple buy = new BuyApple(); //开始买水果这个过程 
    buy.buyFruit().enableEat();      //调用苹果的enableEat()方法 
  } 
} 
10、说明： 
A：工厂方法模式和简单工厂模式在结构上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。工厂方法模式可以允许很多具体工厂类从抽象工厂类中将创建行为继承下来，从而可以成为多个简单工厂模式的综合，进而推广了简单工厂模式。 
B：工厂方法模式退化后可以变得很像简单工厂模式。设想如果非常确定一个系统只需要一个具体工厂类，那么就不妨把抽象工厂类合并到具体的工厂类中去。由于反正只有一个具体工厂类，所以不妨将工厂方法改成为静态方法，这时候就得到了简单工厂模式。C：如果需要加入一个新的水果，那么只需要加入一个新的水果类以及它所对应的工厂类。没有必要修改客户端，也没有必要修改抽象工厂角色或者其他已有的具体工厂角色。对于增加新的水果类而言，这个系统完全支持"开-闭"原则。 
D：对Factory Method模式而言，它只是针对一种类别（如本例中的水果类Fruit），但如果我们还想买肉，那就不行了，这是就必须要Factory Method模式帮忙了。 
三、Abstract Factory模式 
1、同样，我们先定义水果（Fruit）接口： 
public interface Fruit { 
  void plant();  //水果是被种植的 
  void enableEat();  //水果能吃 
} 
2、苹果（Apple）是对水果（Fruit）接口的实现： 
public class Apple implements Fruit{ 
  public void plant(){ 
    System.out.println("种苹果!"); 
  } 
  public void enableEat(){ 
    System.out.println("苹果好吃!"); 
  } 
} 
3、葡萄（Grape）是对水果（Fruit）接口的实现： 
public class Grape implements Fruit{ 
  public void plant(){ 
    System.out.println("种葡萄!"); 
  } 
  public void enableEat(){ 
    System.out.println("葡萄好吃!"); 
  } 
} 
4、鸭梨（Pear）是对水果（Fruit）接口的实现： 
public class Pear implements Fruit{ 
  public void plant(){ 
    System.out.println("种鸭梨!"); 
  } 
  public void enableEat(){ 
    System.out.println("鸭梨好吃!"); 
  } 
} 
5、  定义肉（Meat）接口： 
public interface Meat { 
  void feed();  //肉是喂养的 
  void enableEat();  //肉能吃 
} 
6、  猪肉（BigMeat）是对肉（Meat）接口的实现： 
public class BigMeat implements Meat{ 
  public void feed(){ 
    System.out.println("养猪!"); 
  } 
  public void enableEat(){ 
    System.out.println("猪肉好吃!"); 
  } 
} 
7、  牛肉（CowMeat）是对肉（Meat）接口的实现： 
public class CowMeat implements Meat { 
  public void feed(){ 
    System.out.println("养牛!"); 
  } 
  public void enableEat(){ 
    System.out.println("牛肉好吃!"); 
  } 
} 
8、  我们可以定义买货人（Buyer）接口： 
public interface Buyer { 
  /** 
   * 买水果工厂方法 
   */ 
  public Fruit buyFruit(Fruit whichFruit); 
  /** 
   * 买肉的工厂方法 
   */ 
  public Meat buyMeat(Meat whichMeat); 
} 
9、  我（MyBuyer）是对买货人（Buyer）接口的实现： 
public class MyBuyer implements Buyer{ 
  /** 
   * 买水果工厂方法 
   */ 
  public Fruit buyFruit(Fruit whichFruit){ 
     return whichFruit; 
  } 
  /** 
   * 买肉的工厂方法 
   */ 
  public Meat buyMeat(Meat whichMeat){ 
     return whichMeat; 
  } 
} 
10、编写测试类： 
public class MyBuyerAbstractTest { 
  public static void  main(String args[]){ 
    Fruit apple = new Apple();   //苹果实例 
    Meat big = new BigMeat();  //猪肉实例 
    MyBuyer my = new MyBuyer();  //我是买者的实例 
    my.buyFruit(apple).enableEat();  //我买苹果 
    my.buyMeat(big).enableEat();    //我买猪肉 
  } 
} 
11、说明： 
A：抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。 
B：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。 
C：抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品（Fruit）等级结构；而抽象工厂模式则需要面对多个产品等级结构(Fruit、Meat)。