01.考虑使用静态工厂方法替代构造方法
前言
《Effective Java》中文第三版，是一本关于Java基础的书，这本书不止一次有人推荐我看。其中包括我很喜欢的博客园博主五月的仓颉，他曾在自己的博文《给Java程序猿们推荐一些值得一看的好书》中也推荐过。加深自己的记忆，同时向优秀的人看齐，决定在看完每一章之后，都写一篇随笔。如果有写的不对的地方、表述的不清楚的地方、或者其他建议，希望您能够留言指正，谢谢。
《Effective Java》中文第三版在线阅读链接.
什么是构造方法？
定义：
一个在创建对象时自动被调用的方法。
特点：
- 构造方法的名称和类同名。
- 没有返回值类型，即不能使用 return 关键字。
- 普通方法不能以任何形式调用构造方法（构造方法中可以调用普通方法）。
注意：
当类中没有定义构造方法时，系统会默认添加一个无参的构造方法，当在类中定义构造方法的时候，默认的构造方法会消失。
实例：
public class Cat {
//名字
private String name;
//颜色
private String color;
//年龄
private Integer age;
//构造方法的名称和类同名
public Cat(){
}
//带一个参数的构造方法
public Cat(String name){
this.name = name;
//普通方法不能以任何形式调用构造方法，构造方法中可以调用普通方法
commonMethod();
}
//有两个参数的构造方法
public Cat(String name, String color){
this.name = name;
this.color = color;
}
public void commonMethod(){
}
}
什么是静态工厂方法？
定义：
在类中提供一个公共的静态方法，通过这个静态方法，对外提供自身实例。
实例：
public class Cat {
//名字
private String name;
//颜色
private String color;
//年龄
private Integer age;
//创建只有名字的猫，带有一个构造参数
public static Cat createCatWithName(String name){
Cat cat = new Cat();
cat.name = name;
return cat;
}
//创建只有颜色的猫，带有一个构造参数
public static Cat createCatWithColor(String color){
Cat cat = new Cat();
cat.color = color;
return cat;
}
//创建有名字、颜色、年龄的猫
public static Cat createCatWithAllParam(String name, String color, Integer age){
Cat cat = new Cat();
cat.age = age;
cat.name = name;
cat.color = color;
return cat;
}
}
为什么考虑使用静态工厂方法替代构造方法？（静态工厂方法的优点）
- 与构造方法不同，静态工厂方法可以有多个入参数量相同，但名称不同的方法。
实例：
请参考上方的两个实例。
- 与构造方法不同，静态工厂方法都是有名字的。生成的代码更易于阅读，也能突出它们的差异。
实例：
public class Test02 {
private String s1;
private String s2;
private String s3;
private Integer i1;
public Test02(){
}
public Test02(String s1){
this.s1 = s1;
}
public Test02(String s1, String s2){
this.s1 = s1;
this.s2 = s2;
}
public Test02(String s1, Integer i1){
this.s1 = s1;
this.i1 = i1;
}
public Test02(String s1, String s2, String s3){
this.s1 = s1;
this.s2 = s2;
this.s3 = s3;
}
public static Test02 createTest02InitAParam(String s1){
Test02 result = new Test02();
result.s1 = s1;
return result;
}
public static Test02 createTest02InitTwoParam(String s1, String s2){
Test02 result = new Test02();
result.s1 = s1;
result.s2 = s2;
return result;
}
public static Test02 createTest02InitThreeParam(String s1, String s2, String s3){
Test02 result = new Test02();
result.s1 = s1;
result.s2 = s2;
result.s3 = s3;
return result;
}
public static void main(String[] args) {
//构造方法创建对象
//前面我们说过，构造方法的名称和类同名，这导致构造函数的名称不够灵活，不能准确的描述返回值。
//如果参数类型、数目比较相似的话，更加不容易找到合适的构造函数。例如test02与test04。
Test02 test0 = new Test02();
Test02 test01 = new Test02("A");
Test02 test02 = new Test02("A","B");
Test02 test03 = new Test02("A","B","C");
Test02 test04 = new Test02("A", 1);
//静态工厂方法创建对象
//这让程序员更好的记得调用哪个方法创建适合自己需要的实例。注意仔细选择名称来突出它们的差异，这里我只是随便取的名字。
Test02 aParam = Test02.createTest02InitAParam("A");
Test02 twoParam = Test02.createTest02InitTwoParam("A", "B");
Test02 threeParam = Test02.createTest02InitThreeParam("A", "B", "C");
}
}
- 与构造方法不同，静态工厂方法不用每次调用时都创建一个新对象。使用预先构建的实例，反复分配它们避免了不必要的重复。这个特点在创建新对象的代价非常昂贵的情况下，是可以极大地提高性能的。
实例：
public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);
public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
- 与构造方法不同，静态工厂方法可以返回原返回类型的子类。例如一个应用是API，这让它可以返回对象而不需要公开它的类，这种方式隐藏类会使得API非常紧凑。
实例：
Class Person {
public static Person getInstance(){
return new Person();
// return new Son01() / Son02()
}
}
Class Son01 extends Person{
}
Class Son02 extends Person{
}
- 与构造方法不同，静态工厂方法可以限制入参值的范围。作为类的提供者，类入参的范围越大，调用者就越容易出错。下方实例中，调用者只用传入type即可调用。当提供者期望传入构造函数的值是事先定好的值时（下方TYPE_A、TYPE_B），但如果不是，就很容易导致程序错误。避免这种错误，我们可以使用静态工厂模式。调用方无须知道也无需制定type值，这样就能控制type赋值的范围。
实例：
public class Test03 {
public static final int TYPE_A = 1;
public static final int TYPE_B = 2;
public static final int TYPE_C = 3;
int type;
private Test03(int type) {
this.type = type;
}
public static Test03 newA() {
return new Test03(TYPE_A);
}
public static Test03 newB() {
return new Test03(TYPE_B);
}
public static Test03 newC() {
return new Test03(TYPE_C);
}
public static void main(String[] args) {
Test03 test03 = newA();
}
}
静态工厂方法的缺点
- 类如果不含有public或protected的构造器，就不能被子类化。原因是父类缺少公有的构造方法，而子类无法调用父类的私有构造方法，导致子类无法生成构造方法。
实例：
public class Person {
private String name;
private Integer age;
private Person(String name, Integer age){
this.name = name;
this.age = age;
}
public static Person getSon01(String name, Integer age){
return new Person(name, age);
}
public static Person getSon02(String name, Integer age){
return new Person(name, age);
}
//此时Student无法创建，因为Person没有公共的构造方法
public class Son extends Person{
}
}
总结
静态工厂方法，语法层面：
-
能够有自己的名字
-
用子类使代码更加紧凑。
性能的层面： -
避免创建大量等价的实例对象。
最重要的是，当我们作为类的提供者，能够更好的控制调用者的具体行为，减少调用方出错的行为。我认为这也是对自己代码负责的体现。