设计模式：浅析 抽象工厂、工厂方法、简单(静态)工厂 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 ");
      }
}


//工厂类角色
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(); 
  } 
}

    抽象工厂方法从纵向上看，差点儿没有可扩展性。假如我们想添加一个产品C，也就是说产品家族由原来的2个变为3个，程序将会有非常大的变动。抽象工厂中就须要添加一个方法。

这严重违背了开闭原则。而且抽象类是不喜欢被改动的。

    可是从横向上来看。却对扩展性有了非常好的支持，假设我们添加一个产品等级3，我们仅仅须要在写一个Create3就能够了，这里又符合了开闭原则。有多少个产品等级就应该有多少个实现工厂类。

每添加一个产品等级就对应的添加一个实现工厂类，这里的扩展性又非常自然的体现出来了。

应用场景

工厂方法：

在下面情况下，适用于工厂方法模式：

(1) 当一个类不知道它所必须创建的对象的类的时候。

(2) 当一个类希望由它的子类来指定它所创建的对象的时候。

(3) 当类将创建对象的职责托付给多个帮助子类中的某一个。而且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

抽象工厂：

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

(2) 这个系统有多于一个的产品族，而系统仅仅消费当中某一产品族。

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

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

转载请注明出处：http://blog.csdn.net/df1012890048/article/details/38672341