静态工厂方法比构造器方法“香”在哪？

自己在写bean的实例化中感觉后面明明比构造器更麻烦，为什么还能留着，后来在网上学习才懂“香”在哪？
翻开《Effective Java》的第一条建议就是用静态工厂方法代替构造器，下面先给出书上的解释





接下来谈谈我对于这部分的理解，使用静态方法的优势有如下：

1. 静态工厂方法与构造器不同的第一大优势在于，它们有名称。
2. 静态工厂方法与构造器不同的第二大优势在于，不必在每次调用它们的时候都创建一个新对象。
3. 静态工厂方法与构造器不同的第三大优势在于，它们可以返回原返回类型的任何子类型的对象。
4. 静态工厂的第四大优势在于，所返回的对象的类可以随着每次调用而发生变化，这取决于静态工厂方法的参数值。
5. 静态工厂的第五大优势在于，方法返回的对象所属的类，在编写包含该静态工厂方法的类时可以不存在。
   可归结如下：
   ①静态工厂方法有名称而构造器没有（前者可读性更好）
   ②不必每次调用它们的时候都创建一个新对象
   ③可以返回原返回类型的任何子类对象（不局限于单一特定的类）
   ④创建泛型对象可以更加简洁

静态工厂有什么名称？

通过下面的例子，可以很好的理解，假如我们想“找对象”，在找之前需要选择高矮丑俊，粗俗的大汉直接用一个new即可，看起来非常方便，仅仅需要一个构造方法，但是有什么弊端呢？大汉在构造对象的时候，都是调用new girl填写参数的时候，他可能稀里糊涂的构造了一个不是让自己满意的对象，因此她需要了解每个构造参数的意义，这显然不满足见名知意。但是如果我们将其封装在一个工厂类中，专门生产“对象”，将具体的实现遮蔽，无需用户输入参数。减少了出错的可能，也实现了见名知意。
首先创建实体类

public class Girl {
    boolean tall;
    boolean beautiful;
    public Girl( ){
        System.out.println("不高不漂亮");
    }
    public Girl( boolean tall ){
        this.tall  = tall;
        System.out.println("高不漂亮");
    }
    public Girl(boolean beautiful,boolean tall){
        this.tall = tall;
        this.beautiful = beautiful;
        System.out.println("又高又漂亮");
    }
}

粗鲁大汉的直接构造

       System.out.print("girl1");
       Girl girl1 = new Girl();
       System.out.println("-----------------");
       System.out.print("girl2");
       Girl girl2 = new Girl(true);
       System.out.println("-----------------");
       System.out.print("girl3");
       Girl girl3  = new Girl(true,true);
       System.out.println("-----------------");

精心小伙通过静态方法，首先定义了静态工厂类

public class Staticmethod {
    public static Girl  getTallGirl(){
        return  new Girl(true);
    }
    public static Girl getTallAndBeautiful(){
        return new Girl(true,true);
    }
    public static Girl getGirl(){
        return new Girl();
    }
}

接下来直接通过静态方法即可获取心仪对象。

 Girl commongirl = Staticmethod.getGirl();
 Girl tallgirl = Staticmethod.getTallGirl();
 Girl tallandbutgirl =Staticmethod.getTallAndBeautiful();

当然都可以获得运行结果

减少对象创建

静态工厂方法能够为重复的调用返回相同对象，这样有助于类总能严格控制在某个时刻哪些实例应该存在。这类似于享元模式，用于减少创建对象的数量，以减少内存占用和提高性能。
下面展示单例模式的饿汉式和懒汉式，实现了对象的多次使用。
饿汉式

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

懒汉式

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}

返回原返回类型的任何子类型的对象

当然可以选择日本女孩和欧美女孩继承女孩类，返回子类类型
创建日本女孩和欧美女孩类，在工厂类中写静态方法

    public static Girl getJapanGirl(){
        return new JapanGirl();
    }
    public static Girl getOumeiGiel(){
        return new OumeiGirl();
    }
    JapanGirl japanGirl =(JapanGirl) Staticmethod.getJapanGirl();
    OumeiGirl oumeiGirl = (OumeiGirl)Staticmethod.getOumeiGiel();

运行结果为

另外的优点在jdk1.7之后已经没有了。

缺点

当然，静态方法也有一定的缺点。如果构造方法都私有化了，就没法通过这种方法实例化。

总结

因此并非静态方法一定好，我们需要合理选择。