Factory模式

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。
一、简单工厂模式（Simple Factory）
建立一个工厂（一个函数或一个类方法）来制造新的对象。
简单工厂模式的组成：

     1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品     2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。              3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在Java中由一个具体类实现。 

产品类：

abstract class Product{      public Product(){      }  }  public class Product_1 extends Product {      public Product_1() {          System.out.println("制造-->产品1");      }  }  public class Product_2 extends Product{      public Product_2(){          System.out.println("制造-->产品2");      }  }  

工厂类：

public class Factory {      public Product createProduct(int type) {          switch (type) {          case 1:              return new Product_1();          case 2:              return new Product_2();          default:              break;          }          return null;      }  }  

客户类：

Public class Customer{    public static void main(String[] args){        Factory factory = new Factory();        Product product_1 = factory.create(1);        Product product_2 = factory.create(2);    }}

简单工厂模式又称静态工厂方法模式。它存在的目的很简单：定义一个用于创建对象的接口。
从开闭原则（对扩展开放；对修改封闭）上来分析:
对产品部分来说，它是符合开闭原则的；但是工厂部分好像不太理想，因为每增加一种新型车，都要在工厂类中增加相应的创建业务逻辑（createProduct(int type)方法需要新增case），这显然是违背开闭原则的。

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

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

产品类：

abstract class Product{      public Product(){      }  }  public class Product_1 extends Product {      public Product_1() {          System.out.println("制造-->产品1");      }  }  public class Product_2 extends Product{      public Product_2(){          System.out.println("制造-->产品2");      }  }  

工厂类：

public interface Factory {     Product createProduct();} public class Product_1Factory() implements Factory{    @Override      public Product_1 createProduct() {        return new Product_1();      }  }public class Product_2Factory() implements Factory{    @Override      public Product_2 createProduct() {        return new Product_2();      }  }

客户类：

public class Customer(){    public static void main(String[] args){        Product_1Factory product_1Factory = new Product_1Factory();        Product_1 product_1 = product_1Factory.createProduct();        Product_2Factory product_2Factory = new Product_2Factory();        Product_2 product_2 = product_2Factory.createProduct();    }}

当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的！
工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。

三、抽象工厂模式（Abstract Factory）
当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。
抽象产品模式组成：

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

产品类：

//第一类组件public abstract class Component_1{ }  //第一类组件A型号  public class Component_1A extends Component {      public Component_1A() {          System.out.println("制造-->第一类组件A型号");      }  }  //第一类组件B型号public class Component_1B extends Component{      public Component_1B(){          System.out.println("制造-->第一类组件B型号");      }  } //第二类组件public abstract Component_2{ }  //第二类组件A型号  public class Component_2A extends Component {      public Component_2A() {          System.out.println("制造-->第二类组件A型号");      }  }  //第二类组件B型号public class Component_2B extends Component{      public Component_2B(){          System.out.println("制造-->第二类组件B型号");      }  } 

工厂类：

//创建工厂的接口public interface Factory {     //创建第一类组件   Component_1 createComponent_1();   //创建第二类组件   Component_2 createComponent_2();} //为产品一生产组件，由第一类组件A和第二类组件B构成public class Product_1Factory() implements Factory{    @Override      public Component_1 createComponent_1() {        return new Component_1A();      }       public Component_2 createComponent_2() {        return new Component_2B();      } }//为产品二生产组件，由第一类组件B和第二类组件B构成public class Product_2Factory() implements Factory{    @Override      public Component_1 createComponent_1() {        return new Component_1B();      }       public Component_2 createComponent_2() {        return new Component_2B();      } }

客户类：

public class Customer{    public static void main(String[] args){        Product_1Factory product_1 = new Product_1Factory();        product_1.createComponent_1();        product_1.createComponent_2();        Product_2Factory product_2 = new Product_1Factory();        product_2.createComponent_1();        product_2.createComponent_2();    }}