上面的类图声明了两个抽象类，生成Weapon的抽象工厂类，然后要生产具体的Weapon的之类工厂去实现，还有一个Weapon抽象类，并且定义了一个attack()的抽象方法，子类去继承Weapon类，并且同时实现attack()方法。

在客户端进行使用的时候只要WeaponFactory factory=new XXXFactory() 这里可以new一个具体的实现类即可。。

     看下代码实现:

  ①：Weapon接口类和对应的实现类

package com.jiangqq.dp.simplefactory; //武器的接口类 public interface Weapon {     //同时里面声明一个需要子类实现的方法     public void attack(); }  package com.jiangqq.dp.simplefactory; //具体的轰炸机类 public class Bomber implements Weapon {    @Override  public void attack() {      // TODO Auto-generated method stub      System.out.println("轰炸机发射×××.....");  } }   package com.jiangqq.dp.simplefactory; //具体的机枪的类 public class Gun implements Weapon {  @Override  public void attack() {      // TODO Auto-generated method stub      System.out.println("机枪发射×××....");    } } 

②:WeaponFactory工厂和具体的创建对象工厂实现类:

package com.jiangqq.dp.simplefactory; //武器的创建接口类 public interface WeaponFactory {    public Weapon create(); }   package com.jiangqq.dp.simplefactory; //机枪的具体实现类 public class GunFactory implements WeaponFactory {     //创建一个具体的机枪对象   @Override  public Weapon create() {        return new Gun();   } }  package com.jiangqq.dp.simplefactory; //轰炸机的具体实现类 public class BomberFactory implements WeaponFactory {    //创建一个具体的轰炸机对象  @Override  public Weapon create() {        return new Bomber();    } } 

③：下面是Client测试方法:

package com.jiangqq.dp.simplefactory;  /**=================================  * 简单工厂模式测试客户端  * @author jiangqq  * @time 2012/3/15 20:57  * ====================================  */ public class ClientTest {   public static void main(String[] args) {        //声明一个可以生成机枪对象的工厂       WeaponFactory factory1 = new GunFactory();         //创建出对象的Weapon,--->Gun       Weapon weapon1=factory1.create();      //调用具体方法...         weapon1.attack();       WeaponFactory factory2 = new BomberFactory();      Weapon weapon2=factory2.create();      weapon2.attack();   } } 

运行效果如下:

        

      

       使用接口，工厂方法，我们可以很好的去把类中相同的实现方法抽取能接口，这样我们就可以进行面向接口编程，并且在工厂实现类中进行对象的实例化，有效减了少在Client端调用的时候公开化的new实例化对象........

       但是如果我们要一次性的生成一系列的产品的时候，如果还是使用工厂方法模式的话，那就在客户端实例化的对象将会一次性成倍增加，这就需要用到抽象工厂模式了。

      

     （二）接着我们来看看另一种工厂模式---抽象工厂模式，同样先看一下类图：

     

     直接看这张图有点复杂：简单的解释一下:上面有三个抽象类分别是

 ①:抽象工厂类（AbstractFactory）:并且其中声明了两个创建具体对象的方法,让它的实现类继承并且实现，其中实现它的FirstFactory和SecondFactory是具体工厂生成出来的产品，且可以生成出一系列的对象如：Apple,Bomber...

 ②:下面两个为Fruits,Weapon抽象类，并且具体子类去实现，可以实例化具体的对象,

 先看如客户端测试的代码

package com.jiangqq.dp.abstractfactory; /*  * ==========================================   * 抽象工厂模式测试客户端  * @author jiangqq  * @time 2012/3/15/ 21:28 =============================================  */ public class ClientTest {    public static void main(String[] args) {        System.out.println("第一个工厂================================");      //生成一个具体的产品         AbstractFactory factory1 = new FirstFactory();         //得到weapon      Weapon weapon1 = factory1.createWeapon();      //得到fruits      Fruits fruits1 = factory1.createFruits();      //根据生成的对象调用具体的方法        weapon1.attack();       fruits1.eat();      System.out.println("第二个工厂================================");      AbstractFactory factory2 = new SecondFactory();        Weapon weapon2 = factory2.createWeapon();      Fruits fruits2 = factory2.createFruits();      weapon2.attack();       fruits2.eat();  } } 

工厂类:

package com.jiangqq.dp.abstractfactory; //工厂抽象类 public abstract class AbstractFactory {    //定义创建武器类，让继承它的具体工厂类具体去实现    public abstract Weapon createWeapon();  //定义创建水果类，让继承它的具体工厂类具体去实现    public abstract Fruits createFruits(); }    package com.jiangqq.dp.abstractfactory; //具体生产对象类 public class FirstFactory extends AbstractFactory {   //生产出机枪     @Override  public Weapon createWeapon() {      return new Gun();   }   //生成出香蕉     @Override  public Fruits createFruits() {      return new Banana();    } }    package com.jiangqq.dp.abstractfactory; //具体生产对象类 public class SecondFactory extends AbstractFactory {   // 生产出轰炸机   @Override  public Weapon createWeapon() {      return new Bomber();    }   // 生产出苹果    @Override  public Fruits createFruits() {      return new Apple();     } } 

Fruits类:

package com.jiangqq.dp.abstractfactory; //水果抽象类 public abstract class Fruits {    //声明的水果的方法，具体让子类去实现  public abstract void eat(); }    package com.jiangqq.dp.abstractfactory; //苹果具体类 public class Apple extends Fruits {    //实现苹果的方法   @Override  public void eat() {         System.out.println("吃这苹果.....");  } }  package com.jiangqq.dp.abstractfactory; //香蕉具体类 public class Banana extends Fruits { //实现香蕉的方法     @Override  public void eat() {     System.out.println("吃着香蕉.....");  } }  

Weapon类:

package com.jiangqq.dp.abstractfactory; //武器抽象类 public abstract class Weapon {    //声明武器的方法，具体让子类去实现     public abstract void attack(); }  package com.jiangqq.dp.abstractfactory; //机枪的具体类 public class Gun extends Weapon{ //实现机枪的方法   public void attack() {      // TODO Auto-generated method stub      System.out.println("机枪发射×××....");    } }   package com.jiangqq.dp.abstractfactory; //轰炸机的具体实现类 public class Bomber extends Weapon {  //实现轰炸机的方法  @Override  public void attack() {      // TODO Auto-generated method stub      System.out.println("轰炸机发射×××.....");  } } 

虽然使用抽象工厂模式，在我们需要一次性实例化一系列的产品的时候，方便很多，但是如果需要增加新的产品的时候，那么类的数量也会成倍的增加，所以说使用工厂方法或者抽象工厂都会有利有弊的，决定于具体场合我们去实现;

最后一个是简单工厂模式，但是简单工厂模式不是严格意义上的设计模式，所以这里也没有具体列出来....