考虑用静态工厂方法代替构造器

第一条：考虑用静态工厂方法代替构造器

1. 简单介绍（个人理解）

这一条是告诉我们最好要这样写一个类：

public class MyObject {
       private String objectId;
       private MyObject(String objectId) {//私有构造器
         this.objectId = objectId;
       }

       public static MyObject newInstance(String objectId){//静态工厂方法
         return new MyObject(objectId);
       }
}

最好不要这样：

public class MyObject {
       private String objectId;
       public MyObject(String objectId) {//共有构造器
         this.objectId = objectId;
       }
}

2. 这样做的原因（也就是好处）:

1).静态工厂方法我们可以自己定义名字，体现这个优势的地方在哪里？
答：在需要多个构造器的时候，一堆构造器虽然参数不同，但是名字相同，记住参数来识别不同的构造器是不直观的。
2).通过静态工厂方法获取实例可以不需要生成一个新对象，这个优势体现在哪里？
答：a. 你可以在类中创建一些static的默认的实例，然后静态工厂方法就可以直接返回这些实例，反复使用这些实例的时候相对于new出来要更加高效。
b. 你可以更容易的控制这些默认的实例。
3).你可以返回一个当前返回类型的子类对象，用简单的代码解释意思，看代码：

public class MyObject{
          public static MyObject getChildObject() { //静态工厂方法
              return MyChildObject.newInstance();
          }
}
class MyChildObject extends MyObject{
          public static MyChildObject newInstance() {
              return new MyChildObject();
          }
}

那么问题来了，学挖。。。。额。。不对，这个优势体现在什么地方呢？
答： 体现在面向接编程上，隐藏接口的实现类，使得接口的编写和调用更加简洁，并且可以直观的看到有哪些实现类，并且可以直接的获取到实现类的实例，当然，接口里面是不能写静态工厂方法的，所以我们需要做一些处理。代码如下：
接口：

public interface Service {
          void method();
}

通过一个Services提供各种接口的实现：

public class Services {
          private static final MyService myService = new MyService();
          private static final AnotherService anotherService = new AnotherService();
          private Services(){}

          public static Service getMyService() {//构造器
              return myService;
          }
          public static Service getAnotherService(){//构造器
              return anotherService;
          }

          private static class MyService implements Service{
              @Override
              public void method() {
                  //do some things...
              }
          }
          private static class AnotherService implements Service{
              @Override
              public void method() {
                  //do some things...
              }
          }
}

使用的时候：

Service mySevice = Services.getMyService();
Service anotherService = Services.getAnotherService();

3. 现在来说说缺点：

缺点一：类如果不包含共有的或受保护的构造器，就不能被子类化。
PS: 个人理解：类的构造器如果是private类型的，它将不能被继承，所以说不能被子类化；
缺点二：想要查明一个类该如何被实例化十分困难。

• 总结

引用原文中的话：

简而言之，静态工厂方法和共有构造器都各有用处，我们需要理解他们各自的长处。静态工厂通常更加合适，因此切忌第一反应就是提供共有的构造器，而不先考虑静态工厂。