设计模式——工厂模式

1.简介
工厂模式有很多种不同的类型，主要有以下四种；

• the factory method pattern,（工厂方法）
• the abstract factory pattern,（抽象工厂）
• the static factory method,（静态工厂）
• the simple factory (also called factory).（简单工厂）
  使用模式是为了方便开发，但是会使代码难于理解，因此：
  1.独立开发的时候不需要使用。
  2.对于不会改变很多的小项目，也可以避免了。
  3.对于涉及使用相同代码的多个开发人员的中大型项目，会很有用。

public class SimpleClass {   private final Integer arg1;   private final Integer arg2;   SimpleClass(Integer arg1, Integer arg2) {      this.arg1 = arg1;      this.arg2 = arg2;   }   public Integer getArg1(){      return arg1;   }   public Integer getArg2(){      return args;   }}...public class BusinessClassXYZ {   public static void someFunction(){      SimpleClass mySimpleClass = new SimpleClass(1,2);       // some stuff   }}

在这段代码中，SimpleClass是一个非常简单的类，无依赖关系，无多态，无业务逻辑。您可以使用工厂来创建此对象，但它会增加一倍的代码量。这种情况避免使用工厂

2.为什么要使用工厂？
1.控制对象
企业应用程序的一个常见用例是限制类的实例数。您如何管理一个类的一个(或两个或10个)实例，因为它使用一个资源，比如套接字，或数据库连接，或文件系统描述符之类的?使用构造函数方法，不同的函数(来自不同的类)很难知道一个类的实例是否已经存在。而且，即使有一个实例，如何得到这个实例呢?你可以通过使用每个方法都可以检查的共享变量来实现，这样会导致大量冗余的代码。
如果使用静态工厂，很容易做到

public class Singleton {   private static final Singleton INSTANCE = new Singleton();   private Singleton(){}   public static Singleton getInstance(){      return INSTANCE;   }...}...public class ClassXXX{   ...   public static void someFunctionInClassXXX(){      Singleton instance = Singleton.getInstance();      //some stuff   }}...public class ClassYYY{   ...   public static void someFunctionInClassYYY(){      Singleton instance = Singleton.getInstance();      //some stuff   }}

2.松耦合
假设您编写了一个程序，需要编写日志记录。由于它是一个大型的项目，所以在您编写业务类时，您需要用代码将日志写入文件系统(类文件系统日志程序)。在没有工厂的情况下，您需要在使用构造函数之前将文件系统日志程序实例化:

public class FileSystemLogger {   ...   public void writeLog(String s) {   //Implemation   }}...public void someFunctionInClassXXX(some parameters){   FileSystemLogger logger= new FileSystemLogger(some paramters);   logger.writeLog("This is a log");}

这样做的问题就是，如果现在需求突然改变，要把日志保存到数据库里，就需要去修改所有用到的地方….
而用到工厂之后，只需要改一个地方就行了；

//抽象日志接口public interface ILogger {   public void writeLog(String s);}public class FileSystemLogger implements ILogger {   ...   public void writeLog(String s) {      //实现   }}public class DatabaseLogger implements ILogger {   ...   public void writeLog(String s) {      //实现   }}public class FactoryLogger {   public static ILogger createLogger() {      //选择你要保存日志的方式，换成其他方式，只需要改此处就OK了      return new FileSystemLogger();   }}////////////////////用到工厂的代码public class SomeClass {   public void someFunction() {      //如果方式改变了，这些代码不用更改      ILogger logger = FactoryLogger.createLogger();      logger.writeLog("This is a log");   }}

使用工厂实现了业务代码和日志的松耦合。
3.体现封装性
。。。。

3.使用
1.static factory method
UML图

public class MyClass {   Integer a;   Integer b;   MyClass(int a, int b){      this.a=a;      this.b=b;   };   public static MyClass getInstance(int a, int b){      return new MyClass(a, b);   }   public static void main(String[] args){      //instanciation with a constructor      MyClass a = new MyClass(1, 2);      //instanciation with a static factory method      MyClass b = MyClass.getInstance(1, 2);   }}

在这段代码中，有两种创建对象的方式，new操作和工厂；
再往深一点，如果一个带有静态工厂方法的类可以实例化另一个类怎么办

/////////////////////////the productspublic interface Car {   public void drive();}public class Mustang implements Car{   public void drive() {      //    some stuff   }   ...}public class Ferrari implements Car{   public void drive() {      //    some stuff   }    ...}///////////////////////// the factorypublic abstract class CarFactory{   public static Car getCar() {      //    choose which car you want   }}.../////////////////////////some code using the factorypublic static void someFunctionInTheCode(){   Car myCar = CarFactory.getCar();   myCar.drive();}

在java中int i = 12;
String integerAsString = String.valueOf(i);也是一种静态工厂