这一切都归结为可维护性。最好的方式是，无论何时使用new关键字创建对象，都是将所编写的代码耦合到实现中。

The factory pattern lets you separate how you create an object from what you do with the object. When you create all of your objects using constructors, you are essentially hard-wiring the code that uses the object to that implementation. The code that uses your object is "dependent on" that object. This may not seem like a big deal on the surface, but when the object changes (think of changing the signature of the constructor, or subclassing the object) you have to go back and rewire things everywhere.

如今，由于依赖注入需要大量的样板代码，而这些代码本身维护起来有点困难，工厂在很大程度上被忽略了。依赖注入基本上等同于工厂，但允许你以声明的方式(通过配置或注释)指定你的对象如何连接在一起。

可读性可以通过静态工厂方法来提高:

比较

public class Foo{
  public Foo(boolean withBar){
    //...
  }
}

//...

// What exactly does this mean?
Foo foo = new Foo(true);
// You have to lookup the documentation to be sure.
// Even if you remember that the boolean has something to do with a Bar
// you might not remember whether it specified withBar or withoutBar.

to

public class Foo{
  public static Foo createWithBar(){
    //...
  }

  public static Foo createWithoutBar(){
    //...
  }
}

// ...

// This is much easier to read!
Foo foo = Foo.createWithBar();

静态

用关键字'static'声明的成员。

工厂方法

方法，用于创建和返回新对象。

在Java中

编程语言与“静态”的含义相关，但与“工厂”的定义无关。

当您希望确保只有一个实例将返回要使用的具体类时，静态工厂方法很好。

例如，在一个数据库连接类中，您可能希望只有一个类创建数据库连接，因此如果您决定从Mysql切换到Oracle，您只需更改一个类中的逻辑，而应用程序的其余部分将使用新的连接。

如果您希望实现数据库池，那么也可以在不影响应用程序其余部分的情况下完成。

它保护应用程序的其余部分不受您可能对工厂所做的更改的影响，这就是目的。

它是静态的原因是，如果你想跟踪一些有限的资源(套接字连接或文件句柄的数量)，那么这个类可以跟踪已经传递和返回了多少，这样你就不会耗尽有限的资源。

这一切都归结为可维护性。最好的方式是，无论何时使用new关键字创建对象，都是将所编写的代码耦合到实现中。

The factory pattern lets you separate how you create an object from what you do with the object. When you create all of your objects using constructors, you are essentially hard-wiring the code that uses the object to that implementation. The code that uses your object is "dependent on" that object. This may not seem like a big deal on the surface, but when the object changes (think of changing the signature of the constructor, or subclassing the object) you have to go back and rewire things everywhere.

如今，由于依赖注入需要大量的样板代码，而这些代码本身维护起来有点困难，工厂在很大程度上被忽略了。依赖注入基本上等同于工厂，但允许你以声明的方式(通过配置或注释)指定你的对象如何连接在一起。

One of the advantages of the static factory methods with private constructor(object creation must have been restricted for external classes to ensure instances are not created externally) is that you can create instance-controlled classes. And instance-controlled classes guarantee that no two equal distinct instances exist(a.equals(b) if and only if a==b) during your program is running that means you can check equality of objects with == operator instead of equals method, according to Effective java.

The ability of static factory methods to return the same object from repeated invocations allows classes to maintain strict control over what instances exist at any time. Classes that do this are said to be instance-controlled. There are several reasons to write instance-controlled classes. Instance control allows a class to guarantee that it is a singleton (Item 3) or noninstantiable (Item 4). Also, it allows an immutable class (Item 15) to make the guarantee that no two equal instances exist: a.equals(b) if and only if a==b. If a class makes this guarantee, then its clients can use the == operator instead of the equals(Object) method, which may result in improved performance. Enum types (Item 30) provide this guarantee.

摘自Effective Java, Joshua Bloch(第1项，第6页)