工厂模式（Factory）

1、工厂模式介绍：

工厂模式实现了建立者和调用者的分离

工厂模式分类：

1.简单工厂模式

2.工厂方法模式：定义一个用于建立对象的接口，让子类决定实例化哪个类，工厂方法使一个类的实例化延迟到其子类

​3.抽象工厂模式：提供一个建立一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

面向对象设计的基本原则：

OCP（开闭原则，Open-Closed Principle）：

        一个软件的实体应当对扩展开放，对修改关闭。也就是说若是你要对一个已存在的系统作扩展的时候尽可能要新增长类，而不是在原有的基础上修改。

DIP（依赖倒转原则，Dependence Inversion Principle）

       针对接口编程，不要针对实现编程。

LoD（迪米特法则，Law Of Demeter）

       只与你直接的朋友通讯，而避免和陌生人通讯。一个类尽可能少的依赖其余类

 

2、工厂模式代码实现

未使用工厂模式的状况

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

//汽车接口 public  interface  Car {      void  run(); } //奥迪 public  class  Audi  implements  Car {       @Override      public  void  run() {          System.out.println( "奥迪在跑" );      } } //比亚迪 public  class  Byd  implements  Car {      @Override      public  void  run() {          System.out.println( "比亚迪在跑。" );      } } //汽车测试类 public  class  TestCar { //调用者      public  static  void  main(String[] args) {          Car c1 =  new  Byd();          Car c2 =  new  Audi();              c1.run();          c2.run();          //未使用工厂模式的时候，调用者会依赖不少类。违反了开闭原则      } }

一、简单工厂模式：虽然能经过工厂来建立对象，可是违反了开闭原则。一旦增长功能须要在原有基础上修改代码。

使用了简单工厂模式后：能够建立一个工厂类，该类中提供一个建立汽车的工厂（方法）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

//汽车工厂 public class CarFactory {      /**       * 建立汽车       * @param type       * @return       */      public static Car createCar(String type){          //该方法还会有问题，假如之后有不少汽车都须要工厂来建立。则又得修改源代码，违反了OCP开闭原则          if ( "audi" .equals(type)) {              return new Audi();          } else if ( "byd" .equals(type)) {              return new Byd();          } else {              return null ;          }      } } //测试简单工厂方法 public class TestSimpleFactoryCar { //调用者      public static void main(String[] args) {          //建立汽车          Car audi = CarFactory.createCar( "audi" ); //建立者          Car byd = CarFactory.createCar( "byd" );          audi.run();          byd.run();      } }

二、工厂方法模式：将工厂类调整为工厂接口，须要什么类型的工厂就使用该类实现该工厂，建立相应的产品。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

//工厂接口 public interface CarFactory {      //建立汽车方法      Car createCar(); } //建立比亚迪汽车的工厂 public class BydFactory implements CarFactory{      @Override      public Car createCar() {          return new Byd();      } } //建立奥迪的工厂 public class AudiFactory implements CarFactory {      @Override      public Car createCar() {          return new Audi();      } }   //测试工厂方法 public class TestFactoryMethod {      public static void main(String[] args) {          /**           * 工厂方法模式好处在于，之后若是再增长一辆车。只需再实现CarFactory接口便可。避免了OCP开闭原则           * 不用在原来的代码上修改，只需新增类便可。           * 例如:增长一辆奔驰，增长一个奔驰工厂BenzFactory便可。更好扩展           */          Car audi = new AudiFactory().createCar();          Car byd = new BydFactory().createCar();          audi.run();          byd.run();      } }

三、抽象工厂模式：抽象工厂模式用来生产不一样产品族的所有产品，对于只增长产品某一部分则不适用。抽象工厂模式是工厂模式的一种升级版本。

在有多个业务品种，业务分类时，抽象工厂能产品不一样类别的一个所有产品。例如：生产汽车，抽象工厂模式能够生产高端汽车所有配件来组成一个高端汽车，

低端汽车所有配件来组成要给低端的汽车，可是不能产生一个高端的发动机和一个低端的座椅来组成一个中等的汽车。这样会混乱。

代码实现：

首先使用一个接口来定义一个发动机，使用具体的类来定义发动机的好坏（具体实现）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

/**   * 发动机接口   */ public interface Engine {      void run();      void start(); } //好的发动机 class LuxuryEngine implements Engine{      @Override      public void run() {          System.out.println( "好发动机转的快" );      }      @Override      public void start() {          System.out.println( "启动快，自动启停" );      } } //差的发动机 class LowEngine implements Engine{      @Override      public void run() {          System.out.println( "转的慢" );      }      @Override      public void start() {          System.out.println( "启动慢" );      } }

定义一个汽车总工厂，用来生产各类类型的汽车。全部的汽车都须要依赖此工厂来生产汽车。

1 2 3 4 5 6 7 8

/**   *  汽车总工厂，能够建立轮胎，座椅，发动机   */ public interface CarFactory {      Engine createEngine(); //建立发动机      Seat createSeat(); //建立座椅      Tyre createTyre(); //建立轮胎 }

而后根据生产的不一样产品，类建立具体的实现来生产汽车。例如：专门生产高端的汽车，专门生产低端的汽车。均可以用针对CarFactory具体的实现来建立。

高端汽车制造工厂，全部汽车的生产必须依赖汽车总工厂

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

/**   *  高端汽车制造工厂   */ public class LuxuryCarFactory implements CarFactory{      @Override      public Engine createEngine() {          return new LuxuryEngine();      }      @Override      public Seat createSeat() {          return new LuxurySeat();      }      @Override      public Tyre createTyre() {          return new LuxuryTyre();      } }

低端汽车制造工厂，全部汽车的生产必须依赖汽车总工厂

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

/**   *  低端汽车制造工厂   */ public class LowCarFactory implements CarFactory{      @Override      public Engine createEngine() {          return new LowEngine();      }      @Override      public Seat createSeat() {          return new LowSeat();      }      @Override      public Tyre createTyre() {          return new LowTyre();      } }

具体生产汽车的时候就能够根据须要来建立具体的汽车了。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public static void main(String[] args) {      //想要好车      CarFactory factory = new LuxuryCarFactory();      Engine engine = factory.createEngine(); //建立高端发动机      engine.run();      engine.start();            //想要差一点的车      CarFactory factory2 = new LowCarFactory();      Engine e2= factory2.createEngine();      Seat s2 = factory2.createSeat();      Tyre t2 = factory2.createTyre();      e2.run();      e2.start();      //之后想要中等车的话能够增长相应中等配件的接口 }

以上就是一个针对产品族的工厂，用来生产一个产品，而不是一个配件。假如之后想生产一个中端汽车产品。就能够增长相应的类，实现汽车总工厂CarFactory

来生产。

 

3、工厂模式要点

简单工厂模式（静态工厂模式）

   虽然某种程度不符合面向对象规则（不符合开闭原则，每次新增内容都须要在原有代码上修改），可是实际使用最多。

工厂方法模式

   不修改已有类的前提下，经过增长新类来实现扩展。

抽象工厂模式

    不能够增长产品中某一个配件，能够增长一个具体的产品族。

 

4、应用场景

JDK中的Calendar的getInstance方法

JDBC中Connection对象的获取getConnection

Hibernate中SessionFactory建立Session

spring中的IOC容器建立管理bean对象的时候也是工厂模式

XML解析时的DocumentBuilderFactory建立解析器对象

反射中Class对象的newInstance方法。

 

 

 Java23种设计模式学习笔记【目录总贴】

参考资料：

　　大话设计模式(带目录完整版).pdf

　　HEAD_FIRST设计模式（中文版）.pdf

　　尚学堂_高淇_java300集最全视频教程_【GOF23设计模式】