JAVA_工厂模式(经典)

看了这么多关于工厂模式的讲解，还是觉得这篇文章讲的好理解，贴出来和大家分享分享。
一、引子
             话说十年前，有一个暴发户，他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪，还雇了司机为他开车。不过，暴发户坐车时总是怪怪的：上Benz 车后跟司机说“开奔驰车！”，坐上Bmw后他说“开宝马车！”，坐上Audi说“开奥迪车！”。你一定说：这人有病！直接说开车不就行了？！
             而当把这个暴发户的行为放到我们程序设计中来时，会发现这是一个普遍存在的现象。幸运的是，这种有病的现象在OO（面向对象）语言中可以避免了。下面就以Java语言为基础来引入我们本文的主题：工厂模式。

二、分类
            工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

工厂模式在《Java与模式》中分为三类：
1）简单工厂模式（Simple Factory）

2）工厂方法模式（Factory Method）

3）抽象工厂模式（Abstract Factory）
             这三种模式从上到下逐步抽象，并且更具一般性。
             GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

两者皆可，在本文使用《Java与模式》的分类方法。下面来看看这些工厂模式是怎么来“治病”的。

三、简单工厂模式(****************************讲解的非常好***********************)

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。
       先来看看它的组成：

         1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

         2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

         3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
那么简单工厂模式怎么来使用呢？我们就以简单工厂模式来改造暴发户坐车的方式——现在暴发户只需要坐在车里对司机说句：“开车”就可以了。

代码： //抽象产品角色
public interface Car{
      public void drive();
}

//具体产品角色
public class Benz implements Car{
      public void drive() {
         System.out.println("Driving Benz ");
      }
}

public class Bmw implements Car{
      public void drive() {
       System.out.println("Driving Bmw ");
      }
}
。。。（奥迪我就不写了:P）

//工厂类角色
public class Driver{
            //工厂方法.注意 返回类型为抽象产品角色
             public static Car driverCar(String s)throws Exception{
                   //判断逻辑，返回具体的产品角色给Client
                   if(s.equalsIgnoreCase("Benz"))
                        return new Benz();
                   else if(s.equalsIgnoreCase("Bmw"))
                            return new Bmw();
                                 ......   
                           else throw new Exception();
             。。。

//欢迎暴发户出场......
public class Magnate{
             public static void main(String[] args){
                        try{
                              //告诉司机我今天坐奔驰                    
                                  Car car = Driver.driverCar("benz");
                              //下命令：开车                           
                                  car.drive();
                        。。。


         将本程序空缺的其他信息填充完整后即可运行。如果你将所有的类放在一个文件中，请不要忘记只能有一个类被声明为public。本程序在jdk1.4 下运行通过。
这便是简单工厂模式了。怎么样，使用起来很简单吧？那么它带来了什么好处呢？
            首先，使用了简单工厂模式后，我们的程序不在“有病”，更加符合现实中的情况；而且客户端免除了直接创建产品对象的责任，而仅仅负责“消费”产品（正如暴发户所为）。

            下面我们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当暴发户增加了一辆车的时候，只要符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说，它是符合开闭原则的；但是工厂部分好像不太理想，因为每增加一辆车，都要在工厂类中增加相应的业务逻辑或者判断逻辑，这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类（在我们的例子中是为司机师傅），我们称它为全能类或者上帝类。
             我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员:(
            于是工厂方法模式作为救世主出现了。

四、工厂方法模式
             工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

你应该大致猜出了工厂方法模式的结构，来看下它的组成：

       1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

       2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

       3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

       4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
       工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活起来——当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则的！

       我们还是老规矩，使用一个完整的例子来看看工厂模式各个角色之间是如何来协调的。话说暴发户生意越做越大，自己的爱车也越来越多。这可苦了那位司机师傅了，什么车它都要记得，维护，都要经过他来使用！于是暴发户同情他说：看你跟我这么多年的份上，以后你不用这么辛苦了，我给你分配几个人手，你只管管好他们就行了！于是，工厂方法模式的管理出现了。代码如下：

代码：

//抽象产品角色，具体产品角色与简单工厂模式类似，只是变得复杂了些，这里略。
//抽象工厂角色
public interface Driver{
       public Car driverCar();
}
public class BenzDriver implements Driver{
         public Car driverCar(){
                return new Benz();
         }
}
public class BmwDriver implements Driver{
         public Car driverCar(){
            return new Bmw();
         }
}

//应该和具体产品形成对应关系...
//有请暴发户先生
public class Magnate{
          public static void main(String[] args){
                     try{
                        Driver driver = new BenzDriver();
                        Car car = driver.driverCar();
                        car.drive();
                     }
             ……
}


可以看出工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。

五、小结

工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口。那我们是否一定要在代码中遍布工厂呢？大可不必。也许在下面情况下你可以考虑使用工厂方法模式：

      1)当客户程序不需要知道要使用对象的创建过程。

      2)客户程序使用的对象存在变动的可能，或者根本就不知道使用哪一个具体的对象。

简单工厂模式与工厂方法模式真正的避免了代码的改动了？没有。在简单工厂模式中，新产品的加入要修改工厂角色中的判断语句；而在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就象上面的例子一样）。而且产品对象创建条件的改变必然会引起工厂角色的修改。
       面对这种情况，Java的反射机制与配置文件的巧妙结合突破了限制——这在Spring中完美的体现了出来。
六、抽象工厂模式

           先来认识下什么是产品族： 位于不同产品等级结构中，功能相关联的产品组成的家族。还是让我们用一个例子来形象地说明一下吧。
回到抽象工厂模式的话题上。
可以说，抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。
抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象

而且使用抽象工厂模式还要满足一下条件：
     1)系统中有多个产品族，而系统一次只可能消费其中一族产品。
     2)同属于同一个产品族的产品以其使用。
来看看抽象工厂模式的各个角色（和工厂方法的如出一辙）：
     1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

     2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。

     3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

     4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
看过了前两个模式，对这个模式各个角色之间的协调情况应该心里有个数了，我就不举具体的例子了。只是一定要注意满足使用抽象工厂模式的条件哦。
//
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。 

************************************************
工厂模式：主要用来实例化有共同接口的类，工厂模式可以动态决定应该实例化那一个类。
工厂模式的形态
工厂模式主要用一下几种形态：
1：简单工厂（Simple Factory）。
2：工厂方法（Factory Method）。
3：抽象工厂（Abstract Factory）。

简单工厂（Simple Factory）
又叫静态工厂，是工厂模式三中状态中结构最为简单的。主要有一个静态方法，用来接受参数，并根据参数来决定返回实现同一接口的不同类的实例。我们来看一个具体的例子：
假设一家工厂，几生产洗衣机，有生产冰箱，还有空调等等..
我们先为所有产品定义一个共同的产品接口
Java代码

   1. public interface Product{}  

public interface Product{}


接着我们让这个工厂的所有产品都必须实现此接口
Java代码

   1. public class Washer implements Product{  
   2.    public Washer(){  
   3.        System.out.println("洗衣机被制造了");  
   4.    }  
   5. }  
   6.   
   7. public class Icebox implements Product{  
   8.    public Icebox(){  
   9.        System.out.println("冰箱被制造了");  
  10.    }  
  11. }  
  12.   
  13. public class AirCondition implements Product{  
  14.    public Icebox(){  
  15.        System.out.println("空调被制造了");  
  16.    }  
  17. }  

public class Washer implements Product{
   public Washer(){
       System.out.println("洗衣机被制造了");
   }
}

public class Icebox implements Product{
   public Icebox(){
       System.out.println("冰箱被制造了");
   }
}

public class AirCondition implements Product{
   public Icebox(){
       System.out.println("空调被制造了");
   }
}


接下来我们来写一个工厂类，有它来负责生产以上的产品
Java代码

   1. public class SimpleFactory {  
   2.       
   3.     public static Product factory(String productName) throws Exception{  
   4.         if(productName.equals("Washer")){  
   5.             return new Washer();  
   6.         }else if(productName.equals("Icebox")){  
   7.             return new Icebox();  
   8.         }else if(productName.equals("AirCondition")){  
   9.             return new AirCondition();  
  10.         }else{  
  11.             throw new Exception("没有该产品");  
  12.         }  
  13.     }  
  14. }  

public class SimpleFactory {
    
    public static Product factory(String productName) throws Exception{
        if(productName.equals("Washer")){
            return new Washer();
        }else if(productName.equals("Icebox")){
            return new Icebox();
        }else if(productName.equals("AirCondition")){
            return new AirCondition();
        }else{
            throw new Exception("没有该产品");
        }
    }
}


好了，有了这个工厂类，我们就可以开始下定单了，SimpleFactory将根据不同的定单类决定生产什么产品。
Java代码

   1. public static void main(String[] args) {  
   2.     try {  
   3.               SimpleFactory.factory("Washer");  
   4.               SimpleFactory.factory("Icebox");  
   5.               SimpleFactory.factory("AirCondition");  
   6.             } catch (Exception e) {  
   7.         e.printStackTrace();  
   8.     }  
   9. }  

public static void main(String[] args) {
    try {
              SimpleFactory.factory("Washer");
              SimpleFactory.factory("Icebox");
              SimpleFactory.factory("AirCondition");
            } catch (Exception e) {
        e.printStackTrace();
    }
}


由上面的代码可以看出，简单工厂的核心就是一个SimpleFactory类，他拥有必要的逻辑判断能力和所有产品的创建权利，我们只需要向把定单给他，就能得到我们想要的产品
**************************************************************************
学习笔记之工厂模式-简单工厂
关键字: 简单工厂
     工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。工厂模式有以下几种形态：

     ? 简单工厂（Simple Factory）模式
     ? 工厂方法（Factory Method）模式
     ? 抽象工厂（Abstract Factory）模式

Simple Factory模式根据提供给它的数据，返回几个可能类中的一个类的实例。通常它返回的类都有一个公共的父类和公共的方法。
package org.jzkangta.factorydemo02;



Java代码

   1. interface Car{  
   2.     public void run();  
   3.     public void stop();  
   4. }  
   5.   
   6. class Benz implements Car{  
   7.     public void run(){  
   8.         System.out.println("Benz开始启动了。。。。。");  
   9.     }  
  10.     public void stop(){  
  11.         System.out.println("Benz停车了。。。。。");  
  12.     }  
  13. }  
  14.   
  15. class Ford implements Car{  
  16.     public void run(){  
  17.         System.out.println("Ford开始启动了。。。");  
  18.     }  
  19.     public void stop(){  
  20.         System.out.println("Ford停车了。。。。");  
  21.     }  
  22. }  
  23.   
  24. class Factory{  
  25.     public static Car getCarInstance(String type){  
  26.         Car c=null;  
  27.         if("Benz".equals(type)){  
  28.             c=new Benz();  
  29.         }  
  30.         if("Ford".equals(type)){  
  31.             c=new Ford();  
  32.         }  
  33.         return c;  
  34.     }  
  35. }  
  36. public class FactoryDemo02 {  
  37.   
  38.     public static void main(String[] args) {  
  39.         Car c=Factory.getCarInstance("jzkangta");  
  40.         if(c!=null){  
  41.             c.run();  
  42.             c.stop();  
  43.         }else{  
  44.             System.out.println("造不了这种汽车。。。");  
  45.         }  
  46.           
  47.   
  48.     }  
  49.   
  50. }  

interface Car{
    public void run();
    public void stop();
}

class Benz implements Car{
    public void run(){
        System.out.println("Benz开始启动了。。。。。");
    }
    public void stop(){
        System.out.println("Benz停车了。。。。。");
    }
}

class Ford implements Car{
    public void run(){
        System.out.println("Ford开始启动了。。。");
    }
    public void stop(){
        System.out.println("Ford停车了。。。。");
    }
}

class Factory{
    public static Car getCarInstance(String type){
        Car c=null;
        if("Benz".equals(type)){
            c=new Benz();
        }
        if("Ford".equals(type)){
            c=new Ford();
        }
        return c;
    }
}
public class FactoryDemo02 {

    public static void main(String[] args) {
        Car c=Factory.getCarInstance("jzkangta");
        if(c!=null){
            c.run();
            c.stop();
        }else{
            System.out.println("造不了这种汽车。。。");
        }
        

    }

}



下面这种用到了发射机制，更加灵活！

Java代码

   1. package org.jzkangta.factorydemo03;  
   2.   
   3. interface Car{  
   4.     public void run();  
   5.     public void stop();  
   6. }  
   7.   
   8. class Benz implements Car{  
   9.     public void run(){  
  10.         System.out.println("Benz开始启动了。。。。。");  
  11.     }  
  12.     public void stop(){  
  13.         System.out.println("Benz停车了。。。。。");  
  14.     }  
  15. }  
  16.   
  17. class Ford implements Car{  
  18.     public void run(){  
  19.         System.out.println("Ford开始启动了。。。");  
  20.     }  
  21.     public void stop(){  
  22.         System.out.println("Ford停车了。。。。");  
  23.     }  
  24. }  
  25.   
  26. class Toyota implements Car{  
  27.     public void run(){  
  28.         System.out.println("Toyota开始启动了。。。");  
  29.     }  
  30.     public void stop(){  
  31.         System.out.println("Toyota停车了。。。。");  
  32.     }  
  33. }  
  34.   
  35. class Factory{  
  36.     public static Car getCarInstance(String type){  
  37.         Car c=null;  
  38.         try {  
  39.             c=(Car)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();  
  40.         } catch (InstantiationException e) {              
  41.             e.printStackTrace();  
  42.         } catch (IllegalAccessException e) {          
  43.             e.printStackTrace();  
  44.         } catch (ClassNotFoundException e) {              
  45.             e.printStackTrace();  
  46.         }  
  47.       
  48.         return c;  
  49.     }  
  50. }  
  51. public class FactoryDemo03 {  
  52.   
  53.     public static void main(String[] args) {  
  54.         Car c=Factory.getCarInstance("Toyota");  
  55.         if(c!=null){  
  56.             c.run();  
  57.             c.stop();  
  58.         }else{  
  59.             System.out.println("造不了这种汽车。。。");  
  60.         }  
  61.           
  62.   
  63.     }  
  64.   
  65. }  
学习笔记之工厂模式-工厂方法
关键字: 工厂方法
工厂方法（FactoryMethod）模式是类的创建模式，其用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。
在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不接触哪一个产品类被实例化这种细节。这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。

Java代码

   1. package org.jzkangta.factorydemo02;  
   2.   
   3. interface Car{  
   4.     public void start();  
   5.     public void stop();  
   6. }  
   7.   
   8. class Benz implements Car{  
   9.     public void start(){  
  10.         System.out.println("Benz开动了。。。。");  
  11.     }  
  12.     public void stop(){  
  13.         System.out.println("Benz停车了。。。");  
  14.     }  
  15. }  
  16.   
  17. class Ford implements Car{  
  18.     public void start(){  
  19.         System.out.println("Ford开动了。。。。");  
  20.     }  
  21.     public void stop(){  
  22.         System.out.println("Ford停车了。。。");  
  23.     }  
  24. }  
  25.   
  26. class BigBus implements Car{  
  27.     public void start(){  
  28.         System.out.println("大巴开车了。。。。");  
  29.     }  
  30.     public void stop(){  
  31.         System.out.println("大巴停车了。。。。");  
  32.     }  
  33. }  
  34.   
  35. class MiniBus implements Car{  
  36.     public void start(){  
  37.         System.out.println("小巴开车了。。。。");  
  38.     }  
  39.     public void stop(){  
  40.         System.out.println("小巴停车了。。。。");  
  41.     }  
  42. }  
  43.   
  44. interface AbstractFactory{  
  45.       
  46. }  
  47. class CarFactory implements AbstractFactory{  
  48.     public Car getCar(String type){  
  49.         Car c=null;  
  50.         try {  
  51.             c=(Car)Class.forName("org.jzkangta.factorydemo02."+type).newInstance();  
  52.         } catch (InstantiationException e) {  
  53.             e.printStackTrace();  
  54.         } catch (IllegalAccessException e) {  
  55.             e.printStackTrace();  
  56.         } catch (ClassNotFoundException e) {              
  57.             e.printStackTrace();  
  58.         }  
  59.         return c;  
  60.     }  
  61.       
  62. }  
  63.   
  64. class BusFactory implements AbstractFactory{  
  65.     public Car getBus(String type){  
  66.         Car c=null;  
  67.         try {  
  68.             c=(Car)Class.forName("org.jzkangta.factorydemo02."+type).newInstance();  
  69.         } catch (InstantiationException e) {  
  70.             e.printStackTrace();  
  71.         } catch (IllegalAccessException e) {  
  72.             e.printStackTrace();  
  73.         } catch (ClassNotFoundException e) {  
  74.             e.printStackTrace();  
  75.         }  
  76.         return c;  
  77.     }  
  78.       
  79. }  
  80.   
  81. public class Factorydemo02 {  
  82.   
  83.       
  84.     public static void main(String[] args) {  
  85.         //CarFactory cf=new CarFactory();  
  86.         BusFactory bf=new BusFactory();  
  87.         Car c=null;  
  88.         //c=cf.getCar("Benz");  
  89.         c=bf.getBus("BigBus");  
  90.         c.start();  
  91.         c.stop();  
  92.     }  
  93.   
  94. }  
 学习笔记之工厂模式-抽象工厂
关键字: 抽象工厂
抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。包含以下角色：

抽象工厂（Abstract Factory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。
具体工厂（Concrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。
抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。
具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。


Java代码

   1. package org.jzkangta.factorydemo03;  
   2.   
   3. interface Person{  
   4.     public void eat();  
   5.     public void talk();  
   6. }  
   7. //男人  
   8. class Man implements Person{  
   9.     public void eat(){  
  10.         System.out.println("男人再吃东西。。。。");  
  11.     }  
  12.     public void talk(){  
  13.         System.out.println("男人在说话。。。。");  
  14.     }  
  15. }  
  16. //女人  
  17. class Woman implements Person{  
  18.     public void eat(){  
  19.         System.out.println("女人再吃东西。。。。");  
  20.     }  
  21.     public void talk(){  
  22.         System.out.println("女人在说话。。。。");  
  23.     }  
  24. }  
  25.   
  26. interface Animal{  
  27.     public void eat();  
  28.     public void sleep();  
  29. }  
  30. //公牛  
  31. class Bull implements Animal{  
  32.     public void eat(){  
  33.         System.out.println("Bull再吃东西。。。。。");  
  34.     }  
  35.     public void sleep(){  
  36.         System.out.println("Bull睡觉了。。。。");  
  37.     }  
  38. }  
  39. //母牛  
  40. class Cow implements Animal{  
  41.     public void eat(){  
  42.         System.out.println("Cow再吃东西。。。。。");  
  43.     }  
  44.     public void sleep(){  
  45.         System.out.println("Cow睡觉了。。。。");  
  46.     }  
  47. }  
  48. //NWFactory-->女娲  
  49. interface NWFactory{  
  50.     public Person getPerson(String type);  
  51.     public Animal getAnimal(String type);  
  52. }  
  53. //阳绳-->用来造男人和雄性动物（Bull）  
  54. class YangSheng implements NWFactory{  
  55.     Man m=null;  
  56.     Bull b=null;  
  57.     public Man getPerson(String type){  
  58.         try {  
  59.             m=(Man)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();  
  60.         } catch (Exception e) {  
  61.             e.printStackTrace();  
  62.         }  
  63.         return m;  
  64.     }  
  65.     public Bull getAnimal(String type){  
  66.         try {  
  67.             b=(Bull)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();  
  68.         } catch (Exception e) {  
  69.             e.printStackTrace();  
  70.         }  
  71.         return b;  
  72.     }  
  73. }  
  74. //阴绳-->用来造女人和雌性动物（Cow）  
  75. class YinSheng implements NWFactory{  
  76.     Woman w=null;  
  77.     Cow c=null;  
  78.     public Woman getPerson(String type){  
  79.         try {  
  80.             w=(Woman)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();  
  81.         } catch (Exception e) {  
  82.             e.printStackTrace();  
  83.         }  
  84.         return w;  
  85.     }  
  86.     public Cow getAnimal(String type){  
  87.         try {  
  88.             c=(Cow)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();  
  89.         } catch (Exception e) {  
  90.             e.printStackTrace();  
  91.         }  
  92.         return c;  
  93.     }  
  94. }  
  95.   
  96. public class FactoryDemo03 {  
  97.   
  98.     public static void main(String[] args) {  
  99.         //实例化一个阳绳,ys  
 100.         YangSheng ys=new YangSheng();  
 101.         //实例化一个阴绳,ys1  
 102.         YinSheng ys1=new YinSheng();  
 103.         //造男人和女人,p1是男人,p2是女人  
 104.         Person p1=ys.getPerson("Man");  
 105.         Person p2=ys1.getPerson("Woman");  
 106.         //造动物，a1是公牛（Bull），a2是母牛（Cow）  
 107.         Animal a1=ys.getAnimal("Bull");  
 108.         Animal a2=ys1.getAnimal("Cow");  
 109.         a1.eat();  
 110.         a1.sleep();  
 111.         a2.eat();  
 112.         a2.sleep();  
 113.         p1.eat();  
 114.         p1.talk();  
 115.         p2.eat();  
 116.         p2.talk();  
 117.   
 118.     }  
 119.   
 120. }  
**********************************************************