//抽象产品角色

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 ");

      }

}

//工厂类角色

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 interface Product

{

}

public interface Creator

{

       public Product factory();

}

public class ConcreteProduct1 implements Product

{

       public ConcreteProduct1()

       {

              System.out.println("ConcreteProduct1被创建");

       }

}

public class ConcreteProduct2 implements Product

{

       public ConcreteProduct2()

       {

              System.out.println("ConcreteProduct2被创建");

       }

}

public class ConcreteCreator1 implements Creator

{

       public Product factory()

       {

              return new ConcreteProduct1();

       }

}

public class ConcreteCreator2 implements Creator

{

       public Product factory()

       {

              return new ConcreteProduct2();

       }

}

public class Client

{

       private static Creator creator1, creator2;

       private static Product prod1, prod2;

       public static void main(String[] args)

       {

              creator1 = new ConcreteCreator1();

              prod1 = creator1.factory();

              System.out.println("----------------------------");

              creator2 = new ConcreteCreator2();

              prod2 = creator2.factory();

       }

}

抽象工厂：多个抽象产品类，派生出多个详细产品类；一个抽象工厂类，派生出多个详细工厂类。每一个详细工厂类可创建多个详细产品类的实例。

即提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们的详细的类。“一对多”的关系。

长处：

1、抽象工厂模式隔离了详细类的生产，使得客户并不须要知道什么被创建。

2、当一个产品族中的多个对象被设计成一起工作时，它能保证client始终仅仅使用同一个产品族中的对象。

3、添加新的详细工厂和产品族非常方便。无须改动已有系统，符合“开闭原则”。

缺点：

添加新的产品等级结构非常复杂，须要改动抽象工厂和全部的详细工厂类，对“开闭原则”的支持呈现倾斜性。

适用环境：

1、一个系统不应当依赖于产品类实例怎样被创建、组合和表达的细节。这对于全部类型的工厂模式都是重要的。

2、系统中有多于一个的产品族，而每次仅仅使用当中某一产品族。

3、属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。

4、系统提供一个产品类的库。全部的产品以相同的接口出现，从而使client不依赖于详细实现。

抽象工厂：

//定义不同的产品之间的一定具备的标准，用interface实现

//当中的method()方法可看作提取出不同产品的共性。如手机都有相似的功能

interface IProductA{

  public void method();

} 

interface IProductB{

  public void method();

} 

//实现了产品标准实现的一系列详细产品

//因为已经设计好A1由厂商1生产。故下面输出代码有“厂商x”

class ProductA1 implements IProductA{

  public void method() {

    System.out.println("厂商1    生产ProductA1 ...");

  }

} 

class ProductA2 implements IProductA{

  public void method() {

    System.out.println("厂商2    生产ProductA2 ...");

  }

} 

class ProductB1 implements IProductB{

  public void method() {

    System.out.println("厂商1    生产ProductB1 ...");

  }

} 

class ProductB2 implements IProductB{

  public void method() {

    System.out.println("厂商2    生产ProductB2 ...");

  }

} 

//每一种牌子的产品生产工厂，即不同的厂商负责自己牌子产品的生产

abstract class Factory1{

  abstract IProductA getProductA1();

  abstract IProductB getProductB1();

} 

abstract class Factory2{

  abstract IProductA getProductA2();

  abstract IProductB getProductB2();

} 

//详细的工厂用来生产相关的产品

class ConcreteFactory1 extends Factory1{

  public IProductA getProductA1() {

    return new ProductA1();

  }

  public IProductB getProductB1() {

    return new ProductB1();

  }

} 

class ConcreteFactoryB extends Factory2{

  public IProductA getProductA2() {

    return new ProductA2();

  }

  public IProductB getProductB2() {

    return new ProductB2();

  }

} 

//測试类

public class Client {

  public static void main(String[] args) {

    //厂商1负责生产产品A1、B1

    Factory1 factory1 = new ConcreteFactory1();

    IProductA productA1 = factory1.getProductA1();

    IProductB productB1 = factory1.getProductB1(); 

    productA1.method();

    productB1.method(); 

    //厂商2负责生产产品A2、B2

    Factory2 factory2 = new ConcreteFactoryB();

    IProductA productA2 = factory2.getProductA2();

    IProductB productB2 = factory2.getProductB2(); 

    productA2.method();

    productB2.method();

  }

}