设计模式-工厂模式

工厂模式:
what(是什么)
属于创建对象模式,它提供了一种创建对象的最佳方式.
why(为什么用它)
在工厂模式中我们床架 对象时不会对客户端暴露创建
逻辑,并且是通过使用一个共同的接口来指向新创建的对象.

应用实例:
1 当需要一辆汽车时,可以直接从工厂里面提货,而不用去管
这辆汽车时怎么来的,以及这个汽车的具体实现.
2 Hibernate换数据库只需要换方言和驱动就可以了.

优点:1 一个调用者想要创建一个对象,只要知道其名称就可以了.
2 扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以了.
3 屏蔽产品的具体实现,调用者只关心产品的接口
缺点:1 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

how(怎么用它)
工厂模式可以分为三类：
1）简单工厂模式（Simple Factory）
建立一个工厂（一个函数或一个类方法）来制造新的对象。

public class BMW320 {      public BMW320(){          System.out.println("制造-->BMW320");      }  }    public class BMW523 {      public BMW523(){          System.out.println("制造-->BMW523");      }  }   public class Customer {      public static void main(String[] args) {          BMW320 bmw320 = new BMW320();          BMW523 bmw523 = new BMW523();      }  } 

客户需要知道怎么去创建一款车,客户和车就紧密耦合在一起了.为了降低耦合,就出现了工厂类,把创建宝马的操作细节都放到了工厂里面去,客户直接使用工厂的创建工厂方法,传入想要的宝马车型号就行了,而不必去知道创建的细节.这就是工业革命了：简单工厂模式
产品类:

abstract class BMW {      public BMW(){      }  }  public class BMW320 extends BMW {      public BMW320() {          System.out.println("制造-->BMW320");      }  }  public class BMW523 extends BMW{      public BMW523(){          System.out.println("制造-->BMW523");      }  }  

工厂类:

public class Factory {      public BMW createBMW(int type) {          switch (type) {          case 320:              return new BMW320();          case 523:              return new BMW523();          default:              break;          }          return null;      }  }  

客户类:

public class Customer {      public static void main(String[] args) {          Factory factory = new Factory();          BMW bmw320 = factory.createBMW(320);          BMW bmw523 = factory.createBMW(523);      }  }  

2）工厂方法模式（Factory Method）
厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的！
产品类:

abstract class BMW {      public BMW(){       }  }  public class BMW320 extends BMW {      public BMW320() {          System.out.println("制造-->BMW320");      }  }  public class BMW523 extends BMW{      public BMW523(){          System.out.println("制造-->BMW523");      }  } 

创建工厂类:

interface FactoryBMW {      BMW createBMW();  }  public class FactoryBMW320 implements FactoryBMW{      @Override      public BMW320 createBMW() {          return new BMW320();      }  }  public class FactoryBMW523 implements FactoryBMW {      @Override      public BMW523 createBMW() {          return new BMW523();      }  }  

客户类:

public class Customer {      public static void main(String[] args) {          FactoryBMW320 factoryBMW320 = new FactoryBMW320();          BMW320 bmw320 = factoryBMW320.createBMW();          FactoryBMW523 factoryBMW523 = new FactoryBMW523();          BMW523 bmw523 = factoryBMW523.createBMW();      }  }  

3）抽象工厂模式（Abstract Factory）
随着客户的要求越来越高，宝马车需要不同配置的空调和发动机等配件。于是这个工厂开始生产空调和发动机，用来组装汽车。这时候工厂有两个系列的产品:空调和发动机。宝马320系列配置A型号空调和A型号发动机，宝马230系列配置B型号空调和B型号发动机。
概念：
抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。比如宝马320系列使用空调型号A和发动机型号A，而宝马230系列使用空调型号B和发动机型号B，那么使用抽象工厂模式，在为320系列生产相关配件时，就无需制定配件的型号，它会自动根据车型生产对应的配件型号A。
当每个抽象产品都有多于一个的具体子类的时候（空调有型号A和B两种，发动机也有型号A和B两种），工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品（产品空调有两个具体产品空调A和空调B）。抽象工厂模式提供两个具体工厂角色（宝马320系列工厂和宝马230系列工厂），分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

产品类:

public interface Engine {    }    public class EngineA extends Engine{        public EngineA(){            System.out.println("制造-->EngineA");        }    }    public class EngineBextends Engine{        public EngineB(){            System.out.println("制造-->EngineB");        }    }    //空调以及型号    public interface Aircondition {    }    public class AirconditionA extends Aircondition{        public AirconditionA(){            System.out.println("制造-->AirconditionA");        }    }    public class AirconditionB extends Aircondition{        public AirconditionB(){            System.out.println("制造-->AirconditionB");        }    }   创建工厂类://创建工厂的接口    public interface AbstractFactory {        //制造发动机      public Engine createEngine();      //制造空调       public Aircondition createAircondition();   }    //为宝马320系列生产配件    public class FactoryBMW320 implements AbstractFactory{        @Override        public Engine createEngine() {              return new EngineA();        }        @Override        public Aircondition createAircondition() {            return new AirconditionA();        }    }    //宝马523系列  public class FactoryBMW523 implements AbstractFactory {         @Override        public Engine createEngine() {              return new EngineB();        }        @Override        public Aircondition createAircondition() {            return new AirconditionB();        }    }   

客户:

public class Customer {        public static void main(String[] args){            //生产宝马320系列配件          FactoryBMW320 factoryBMW320 = new FactoryBMW320();            factoryBMW320.createEngine();          factoryBMW320.createAircondition();          //生产宝马523系列配件            FactoryBMW523 factoryBMW523 = new FactoryBMW523();            factoryBMW320.createEngine();          factoryBMW320.createAircondition();      }    }  

总结：
无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。
所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。