工厂方法模式

1.女娲造人例子

2.AbstractHumanFactory是一个抽象类， 定义了一个八卦炉具有的整体功能， HumanFactory为实现类， 完成具体的任务——创建人类； Human接口是人类的总称， 其三个实现类分别为三类人种；

3.人类总称

public interface Human {
    //每个人种的皮肤都有相应的颜色
    public void getColor();
    //人类会说话
   public void talk();
}

4.黑色人种

public class BlackHuman implements Human {
public void getColor(){
  System.out.println("黑色人种的皮肤颜色是黑色的！ ");
}
public void talk() {
   System.out.println("黑人会说话， 一般人听不懂。 ");
}
}

5.黄色人种

public class YellowHuman implements Human {
public void getColor(){
   System.out.println("黄色人种的皮肤颜色是黄色的！ ");
}
public void talk() {
   System.out.println("黄色人种会说话， 一般说的都是双字节。 ");
}
}

6.所有的人种定义完毕， 下一步就是定义一个八卦炉， 然后烧制人类。 我们想象一下， 女
娲最可能给八卦炉下达什么样的生产命令呢？ 应该是“给我生产出一个黄色人种
（ YellowHuman类） ”， 而不会是“给我生产一个会走、 会跑、 会说话、 皮肤是黄色的人种”，
因为这样的命令增加了交流的成本， 作为一个生产的管理者， 只要知道生产什么就可以了，
而不需要事物的具体信息。 通过分析， 我们发现八卦炉生产人类的方法输入参数类型应该是
Human接口的实现类， 这也解释了为什么类图上的AbstractHumanFactory抽象类中createHuman
方法的参数为Class类型

7.抽象人类创建工厂

public abstract class AbstractHumanFactory {
   public abstract <T extends Human> T createHuman(Class<T> c);
}

注意， 我们在这里采用了泛型（ Generic） ， 通过定义泛型对createHuman的输入参数产
生两层限制：
● 必须是Class类型；
● 必须是Human的实现类。
其中的"T"表示的是， 只要实现了Human接口的类都可以作为参数， 泛型是JDK 1.5中的
一个非常重要的新特性， 它减少了对象间的转换， 约束其输入参数类型， 对Collection集合下
的实现类都可以定义泛型。

8.目前女娲只有一个八卦炉， 其实现生产人类的方法

   人类创建工厂

 public class HumanFactory extends AbstractHumanFactory {
  public <T extends Human> T createHuman(Class<T> c){
        //定义一个生产的人种
        Human human=null;
try {
        //产生一个人种
       human = (T)Class.forName(c.getName()).newInstance();
} catch (Exception e) {
       System.out.println("人种生成错误！ ");
}
      return (T)human;
}
}

9.女娲类

public class NvWa {
public static void main(String[] args) {
    //声明阴阳八卦炉
AbstractHumanFactory YinYangLu = new HumanFactory();
    //女娲第一次造人， 火候不足， 于是白人产生了
    System.out.println("--造出的第一批人是白色人种--");
    Human whiteHuman = YinYangLu.createHuman(WhiteHuman.class);
    whiteHuman.getColor();
    whiteHuman.talk();
     //女娲第二次造人， 火候过足， 于是黑人产生了
    System.out.println("\n--造出的第二批人是黑色人种--");
    Human blackHuman = YinYangLu.createHuman(BlackHuman.class);
    blackHuman.getColor();
    blackHuman.talk();
    //第三次造人， 火候刚刚好， 于是黄色人种产生了
    System.out.println("\n--造出的第三批人是黄色人种--");
    Human yellowHuman = YinYangLu.createHuman(YellowHuman.class);
    yellowHuman.getColor();
    yellowHuman.talk();
}
}

2.工厂方法模式的定义

1.在工厂方法模式中， 抽象产品类Product负责定义产品的共性， 实现对事物最抽象的定义； Creator为抽象创建类， 也就是抽象工厂， 具体如何创建产品类是由具体的实现工厂ConcreteCreator完成的。

2.抽象产品类

 <pre name="code" class="java">public abstract class Product {
 //产品类的公共方法
public void method1(){
 //业务逻辑处理
}
 //抽象方法
public abstract void method2();
}

具体的产品类可以有多个， 都继承于抽象产品类

3.具体产品类

public class ConcreteProduct1 extends Product {
public void method2() {
//业务逻辑处理
}
}
public class ConcreteProduct2 extends Product {
public void method2() {
//业务逻辑处理
}
}

4.抽象工厂类负责定义产品对象的产生

   抽象工厂类

public abstract class Creator {
/*
* 创建一个产品对象， 其输入参数类型可以自行设置
* 通常为String、 Enum、 Class等， 当然也可以为空
*/
public abstract <T extends Product> T createProduct(Class<T> c);
}

5.具体如何产生一个产品的对象， 是由具体的工厂类实现的

   具体工厂类

public class ConcreteCreator extends Creator {
public <T extends Product> T createProduct(Class<T> c){
Product product=null;
try {
product = (Product)Class.forName(c.getName()).newInstance();
} 
catch (Exception e) {
//异常处理
}
return (T)product;
}
}

6.场景类

public class Client {
public static void main(String[] args) {
Creator creator = new ConcreteCreator();
Product product = creator.createProduct(ConcreteProduct1.class);
/*
* 继续业务处理
*/
}
}

3.简单工厂模式

1.简单工厂模式中的工厂类

public class HumanFactory {
public static <T extends Human> T createHuman(Class<T> c){
   //定义一个生产出的人种
   Human human=null;
try {
   //产生一个人种
   human = (Human)Class.forName(c.getName()).newInstance();
} catch (Exception e) {
   System.out.println("人种生成错误！ ");
}
   return (T)human;
}
}

2.简单工厂模式中的场景类

public class NvWa {
public static void main(String[] args) {
   //女娲第一次造人， 火候不足， 于是白色人种产生了
   System.out.println("--造出的第一批人是白色人种--");
   Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);
   whiteHuman.getColor();
   whiteHuman.talk();
   //女娲第二次造人， 火候过足， 于是黑色人种产生了
   System.out.println("\n--造出的第二批人是黑色人种--");
   Human blackHuman = HumanFactory.createHuman(BlackHuman.class);
   blackHuman.getColor();
   blackHuman.talk();
   //第三次造人， 火候刚刚好， 于是黄色人种产生了
   System.out.println("\n--造出的第三批人是黄色人种--");
   Human yellowHuman = HumanFactory.createHuman(YellowHuman.class);
   yellowHuman.getColor();
   yellowHuman.talk();
}
}