静态工厂方法代替构造器

java
effective java
创建和销毁对象

1 静态工厂方法 与 构造器 是什么？

假设我们有一个学生类Animal

  1. public class Animal{ 
  2. //your code 
  3. } 

我们获取这个类的示例 最常用的方式就是使用这个类公有的构造器，每个类默认会有一个无参的构造器

  1. public class AnimalTest { 
  2.  
  3. public static void main(String [] args){ 
  4. Animal animal = new Animal(); 
  5. } 
  6.  
  7. } 

还有另外一种方法，也就是我们需要了解的静态工厂方法(static factorymethod),它是一个返回类实例的静态方法。那么我们就给Student类一个静态工厂方法

  1. public class Animal{ 
  2. private static Animal s = new Animal(); 
  3. public static Animal getInstance(){ 
  4. return animal; 
  5. } 
  6. } 
  1. public class AnimalTest { 
  2.  
  3. public static void main(String [] args){ 
  4. Animal animal = new Animal(); 
  5. Animal animal2 = Animal.getInstance(); 
  6. } 
  7.  
  8. } 

说明这里面的静态工厂方法并不是设计模式中的工厂模式

2 静态工厂方法 与 构造器 的对比

我们可以通过类的静态工厂方法来获得示例，而不是单独是构造器。

2.1 使用 静态工厂方法 的优点

2.1.1 静态工厂方法是有名称的

与构造器相比，静态工厂方法是有名称的。 如果构造器的参数不能够明确的描述返回的对象，我们使用有名称的静态工厂方法就是比较好的。我们可以通过名称的含义来理解这个静态工厂方法返回类的示例。
这种方法尤其在一种情况下很突出，当一个类只能有一个带有签名的构造器。我们都是通过修改两个构造器中的参数列表中的参数类型顺序。面对这样的API 使用起来是很麻烦的，由于静态工厂方法 是有名称的，所以不受这个限制。

2.1.2 不必每次调用都创建新的对象

使用静态的工厂方法，我们可以预先构造好类的实例，或者将写好的实例放入缓存中，进行重复的利用。
静态的工厂方法能够进行重复的调用而返回相同的对象，这可以帮助类控制那些时刻哪些实例应该存在。这种类型的类被称为 示例受控制的类(instance-controlled)，写这样的类有几个原因：

  • 确保这个类是单例模式(Singleton) 或者不可实例化的

  • 可是使用 "==" 操作符来代替 equals(Object)方法，提高性能

  1. public class AnimalTest { 
  2. public static void main(String [] args){ 
  3. Animal animal = Animal.getInstance(); 
  4. Animal animal1 = Animal.getInstance(); 
  5. System.out.println(animal == animal1); 
  6. } 
  7. } 

2.1.3 可以返回类子类的对象 *

这个特性是非常灵活的，我们先试图想象三个组件 服务接口(用于用户获得实例)、 提供者注册API(服务器注册的实例)、 服务访问API(用于用户访问，获取) .其中还有一个可选的组件 服务提供者接口(用于创建实例)。这个就是基本的服务提供者框架，它也可以变化为 适配器(Adapter) 模式
说明：如果有web开发经验的可以把这个当作一个用户拿不同的数据访问 action ，而action 返回不同的视图。而第四个组件我们可以想象成一个Spring 的 base 实例化 action 对象。
这里提供一个完整的代码，希望大家能够自己拿去运行一下、拓展一下。

  1. /** 
  2. *服务访问API 
  3. */ 
  4. public interface IAnimal { 
  5. } 
  6.  
  7. /** 
  8. *服务提供者接口 
  9. */ 
  10. public interface IProvider { 
  11. IAnimal ianimal(); 
  12. } 
  13.  
  14. public class Animal{ 
  15.  
  16. //构造方法私有化，客户端不能够使用构造器获得对象 
  17. private Animal(){} 
  18.  
  19. //根据名称放入相应的实例 
  20. private static final Map<String,IProvider> providers= new ConcurrentHashMap<String,IProvider>(); 
  21. public static final String DEFAULT_IPROVIDER_NAME = "<dfe>"; 
  22.  
  23. //用户注册实例的接口 提供者注册API 
  24. public static void registerDefaultProvider(IProvider p){ 
  25. registerProvider(DEFAULT_IPROVIDER_NAME,p); 
  26. } 
  27.  
  28. public static void registerProvider(String name,IProvider p){ 
  29. providers.put(name, p); 
  30. } 
  31.  
  32. //用户获得实例的接口 服务接口 
  33. public static IAnimal newInstance(){ 
  34. return newInstance(DEFAULT_IPROVIDER_NAME); 
  35. } 
  36.  
  37. public static IAnimal newInstance(String name){ 
  38. IProvider p = providers.get(name); 
  39. if(p == null) 
  40. throw new IllegalArgumentException( 
  41. "没有实例注册这个名称:"+name); 
  42. return p.ianimal(); 
  43. } 
  44.  
  45. } 
  46.  
  47. public class Provider implements IProvider{ 
  48.  
  49. private IAnimal iAnimal; 
  50.  
  51. public Provider(IAnimal iAnimal){ 
  52. this.iAnimal = iAnimal; 
  53. } 
  54.  
  55. @Override 
  56. public IAnimal ianimal() { 
  57. return iAnimal; 
  58. } 
  59.  
  60. } 
  61.  
  62. public class Person implements IAnimal{ 
  63. @Override 
  64. public String toString() { 
  65. return "Person 实例"; 
  66. } 
  67. } 
  68.  
  69. public class Dog implements IAnimal{ 
  70. @Override 
  71. public String toString() { 
  72. return "Dog 实例"; 
  73. } 
  74. } 
  75.  
  76. public class AnimalTest { 
  77. public static void main(String [] args){ 
  78. Animal.registerProvider("dog", new Provider(new Dog())); 
  79.  
  80. Animal.registerProvider("person", new Provider(new Person())); 
  81.  
  82. IAnimal dog = Animal.newInstance("dog"); 
  83. IAnimal person = Animal.newInstance("person"); 
  84.  
  85. System.out.println(dog.toString()); 
  86. System.out.println(person.toString()); 
  87. } 
  88. } 
  89.  

2.1.4 创建参数化类型实例更加简洁

在创建参数化类型实例的时候，静态工厂方法 会让代码变得更加的简洁
在调用参数化的构造器的时，即时类型参数很明显，也必须指明。通常要接连提供两次类型参数

Map<String,List<String>> m = new HashMap<String,List<String>>();

这个类型的声明太过于冗长，假设HashMap 有一个这样的静态工厂方法：

  1. public static <K, V> HashMap<K, V> newInstance(){ 
  2. return new HashMap<K, V>; 
  3. } 

这样我们就可以这样声明HashMap 了 Map<String,List<String>> m = HashMap.newInstance()

2.2 使用 静态工厂方法 的缺点

2.2.1 可能类不能实例化

类如果实现静态的工厂方法，而不含有公有的或者受保护的构造器，就不能够被实例化。这也鼓励我们多使用 复合(composition) 而不是继承

2.2.2 与其他的静态方法没有区别

静态工厂方法在API 文档中没有像构造器一样明确的表示出来，所以，对于静态工厂方法而不是构造器的类来说，想要看清楚是一件不简单的事情。在javadoc工具没有注意到静态工厂方法前，我们通过命名来区分：

  • valueOf -- 这个方法返回的实例与它的参数具有相同的值，这样的静态工厂方法实际上是用来做类型转换的。

  • of -- valueOf的简写，在EnumSet 开始使用流行

  • getInstance -- 返回的实例是通过方法的参数来描述的，但是不能够说与参数具有相同的值。对于Singleton来说这个方法没有参数，并返回唯一的实例

  • newInstance -- 像getInstance一样，但newInstance确保返回的每个实例都与其他实例不同。

  • getType -- 像getInstance一样，但是在工厂方法处于不同的类中的时候使用。type表示工厂方法所返回的对象类型

  • newType -- 像newInstance一样，但是在工厂方法处于不同的类中的时候使用。type表示工厂方法所返回的对象类型

3 总结

静态工厂方法和公有构造器是各有用处的，但是我们需要理解他们的长处。静态工厂方法通常更加的合适，希望我们以后第一时间不是考虑构造器，而是想想静态工厂方法。

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode