设计模式-工厂方法

1.概念
《设计模式》一书中对于工厂方法模式是这样定义的：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。


2.简单工厂模式
先简单说下简单工厂模式，简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。它又称为静态工厂方法模式。缺点是违反了开闭原则。

Java代码  
//生产产品的工厂类    
public class ProductFactory{ 　　   
  public static Product generateProduct(int which){    
  //这个方法是static的　　   
    if (which==1) 　　　　   
      return new ProductA(); 　　   
    else if (which==2) 　　　　   
      return new ProductB(); 　　   
  }    
}    
//抽象产品    
public interface Product { ..... }    
//具体产品A    
public ProductA implement Product {    
  ProductA () {}    
}    
//具体产品B    
public ProductB implement Product {    
  ProductB () {}    
}    
//调用工厂方法    
public Client {    
  public method1() {    
    ProductFactory.generateProduct(1);    
  }    
}    

 

 

Java代码 
interface a{}    
class b implements a{};    
class c implements a{};    
工厂类    
public class factory{    
  public static a createa(string name){    
    class cls=class.forname(name);   
    object obj=cls.getinstance();    
    return (a)obj;    
  }    
}    
//创建实例时    
a　b=factory.createa("b");    
a c=factory.createa("c");   

3.工厂方法
简单工厂模式，如果有新的产品生产，那么就要修改工程类一适应新的需求。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

抽象工厂（Creator）角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。 　　
具体工厂（Concrete Creator）角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。　　
抽象产品（Product）角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。　　
具体产品（Concrete Product）角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

Java代码 
//产品 Plant接口    
public interface Plant { }    
//具体产品PlantA，PlantB    
public class PlantA implements Plant { 　   
  public PlantA () { 　　   
    System.out.println("create PlantA !"); 　   
  } 　   
  public void doSomething() { 　　   
    System.out.println(" PlantA do something ..."); 　   
  }    
}    
public class PlantB implements Plant { 　   
  public PlantB () { 　　   
    System.out.println("create PlantB !"); 　   
  } 　   
  public void doSomething() { 　　   
    System.out.println(" PlantB do something ..."); 　   
  }    
}    
// 抽象工厂方法    
public interface AbstractFactory { 　   
  public Plant createPlant();    
}    
//具体工厂方法    
public class FactoryA implements AbstractFactory { 　   
  public Plant createPlant() { 　　   
    return new PlantA(); 　   
  }    
}    
public class FactoryB implements AbstractFactory { 　   
  public Plant createPlant() { 　　   
    return new PlantB(); 　   
  }    
}    
//调用工厂方法    
public Client {    
  public method1() {   
    AbstractFactory instanceA = new FactoryA();    
    instanceA.createPlant();   
    AbstractFactory instanceB = new FactoryB();    
    instanceB.createPlant();   
  }    
}  

why? 为什么要使用工厂方法呢？我们需要产品的时候，完全可以用new生产产品啊？因为我们要针对接口编程，使用了工厂方法，对于客户client来说，就可以简单的获得产品而不需要清楚如何生产产品，那是工厂类负责的。以上代码说明了工厂结合多态的用法。可以看出可以通过工厂方法返回的对象类型是一个抽象的类型AbstractFactory，而实际的对象是具体的一个子类FactoryA。这样调用者不必关心对象创建的细节，而且增加了程序的可扩展性。如上面的例子里如果在加入一个新的子类FactoryC时：class FactoryC implements AbstractFactory{};，调用时只需要：AbstractFactory c=new FactoryC();。如果把子类的名称放在配置文件里就可以轻松的实现子类的“可配置”了，这样就符合面向对象设计原则中的"开－闭"原则。

4.简单工厂和工厂方法的区别
(1)、工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。
(2)、当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了"开放－封闭"原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。