Creational Pattern学习之Simple Factory

Creational Pattern学习之Simple Factory

   Creational Pattern是对类的实例化过程的抽象化。一些系统在创建对象时，需要动态的决定怎么样创建对象，创建那些对象，以及如何组合和表示这些对象。Creational Pattern描述了怎么样构造和封装这些动态的决定。
    Creational Pattern分为类的创建模式和对象的创建模式两种。
    类的创建模式：     类的创建模式使用继承关系，把类的创建延迟到子类，从而封装了客户端将得到的哪些具体类的信息，并且隐 藏了这 类的实例是如何被创建和放到一起的。
    对象的创建模式： 对象的创建模式是把对象的创建过程动态的委派给另一个对象，从而动态地决定客户端将得到哪些具体的类的实例，以及这些类的实例是如何被创建和组合在一起的。
    Simple Factory是类的创建模式，又称为Static Factory Method模式，它是由一个工厂对象决定创造出哪一种产品类的实例。工厂模式负责将大量有共同接口的类实例化。工厂模式可以动态的决定哪一个类实例化，不必事先知道每次要实例化哪一个类。工厂模式有如下的几种形态:
● Simple Factory 模式：又叫Static Factory Method.
● Factory Method模式：又称多态工厂（Polymorphic Factory）模式。
● Abstract Factory模式：又称工具箱（Kit或ToolKit）模式。
简单工厂模式涉及到工厂角色，抽象产品角色以及具体产品角色等三个角色：
● 工厂类（Creator）角色：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，它往往由一个具体的java类实现。
● 抽象产品（Product）角色：担任这个角色的是由工厂方法模式所创建的对象的父类，或它们共同拥有的接口。抽象产品可以由一个Java接口或Java抽象类实现。
● 具体产品（Concrete Product）角色：工厂模式所创建的任何对象都是这个角色的实例，具体产品角色由一个具体的Java类实现。
demo:
 以农场为例子，农场公司专门向市场销售水果。农场得有专门的园丁来管理水果。
interface Fruti
{
 //水果的接口
 /**
 * 生长
 */
 void grow(); 
 
 /**
 * 收获
 */
 void harvest();
 
 /**
 * 种植
 */
 void plant();
}
具体的水果:苹果，葡萄，草莓
Apple.java:
class Apple implements Fruit
{
 private int treeAge;   //苹果的树龄
 
 /**
 * 生长
 */
 public void grow()
 {
  log("Apple is growing......");
 }
 
 /**
 * 收获
 */
 pubic void harvest()
 {
  log("Apple has been harvested.");
 }
 
 /**
 * 种植
 */
 public void plant()
 {
  log("Apple has been planted");
 }
 
 /**
 * 辅助方法
 */
 public static void log(String str)
 {
  System.out.println(str);
 }
 
 /**
 * 树龄的取值方法
 */
 public int getTreeAge()
 {
  return this.treeAge;
 }
 
 /**
 * 树龄的赋值方法
 */
 public void setTreeAge(int treeAge)
 {
  this.treeAge = treeAge;
 }
}

Grape.java
class Grape implements Fruit
{
 private boolean seedless;  //葡萄的籽
 
 /**
 * 生长
 */
 public void grow()
 {
  log("Grape is growing.....");
 }
 
 /**
 * 收获
 */
 public void harvest()
 {
  log("Grape has been harveted");
 }
 
 /**
 * 种植
 */
 public void plant()
 {
  log("Grape has been planted");
 }
 
 /**
 * 辅助方法
 */
 public static void log(String msg)
 {
  System.out.println(msg);
 }
 
 /**
 * 有无籽的取值方法
 */
 public boolean getSeedless()
 {
  return this.seedless;
 }
 
 /**
 * 有无籽的赋值方法
 */
 public void setSeedless(boolean seedless)
 {
  this.seedless = seedless;
 }
}

Strawberry.java
class Strawberry implements Fruit
{
 /**
 * 生长
 */
 public void grow()
 {
  log("Strawberry is growing.....");
 }
 
 /**
 * 收获
 */
 public void harvest()
 {
  log("Strawberry has been harvested");
 }
 
 /**
 * 种植
 */
 public void plant()
 {
  log("Strawberry has been planted");
 }
 
 /**
 * 辅助方法
 */
 public static void log(String msg)
 {
  System.out.println(msg);
 }
}

具体的园丁:
public class FruitGradener
{
 /**
 * 静态工厂方法
 */
 public static Fruti factory(String witch)throws BadFruitException
 {
  if(witch.equalsIgnoreCase("apple"))
  {
   return new Apple();
  }
  else if(withc.equalsIgnoreCase("Grape"))
  {
   return new Grape();
  }
  else if(witch.equalsIgnoreCase("Strawberry"))
  {
   return new Strawberry();
  }
  else
  {
   thow new BasFruitException("Bad fruit request");
  }
 }
}

抽象产品角色的主要目的就是给所有的具体产品提供一个共同的类型，在最简单的情况下可以简化为一个标识接口。如:
public interface Product
{
}

工厂类角色就是创建一个新的具体产品实例返回给调用者。如:
public class  Creator
{
   /**
   * 静态工厂方法
   */
    return new ConreteProduct();
}

具体的产品就是实际的对象了，如:
public class ConreteProduct implemnts Product
{
    public ConcreteProduct(){}
}

如果模式所产生的具体产品类彼此之间没有共同的商业逻辑，那么抽象产品可以由一个JAVA接口扮演，如果有共同的商务逻辑则应当使用抽象角色扮演。这样共同的逻辑都放到抽象类里去了，达到共享的目的。