What is the difference between "new A()" and "A.newInstance()"?

Question

When should I prefer one over the other? What is the purpose of the method shown below?

class A {
    public static A newInstance() {
        A a = new A();
        return a ;
    }
}

Can someone explain to me the differences between these two calls?

Answer 1

newInstance() is often used as a way to instantiate an object without directly calling the object's default constructor. For example, it is often used to implement a Singleton design pattern:

public class Singleton {
    private static final Singleton instance = null;

    // make the class private to prevent direct instantiation.
    // this forces clients to call newInstance(), which will
    // ensure the class' Singleton property.
    private Singleton() { } 

    public static Singleton newInstance() {
        // if instance is null, then instantiate the object by calling
        // the default constructor (this is ok since we are calling it from 
        // within the class)
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

In this case, the programmer forces the client to call newInstance() to retrieve an instance of the class. This is important because simply providing a default constructor would allow the client access to multiple instances of the class (which goes against the Singleton property).

In the case of Fragments, providing a static factory method newInstance() is good practice since we often want to add initialization arguments to the newly instantiated object. Rather than having the client call the default constructor and manually set the fragment arguments themselves, we can provide a newInstance() method that does this for them. For example,

public static MyFragment newInstance(int index) {
    MyFragment f = new MyFragment();
    Bundle args = new Bundle();
    args.putInt("index", index);
    f.setArguments(args);
    return f;
}

Overall, while the difference between the two is mostly just a matter of design, this difference is really important because it provides another level of abstraction and makes code a lot easier to understand.

Answer 2

In your examples they are equivalent and there is no real reason to chose one over the other. However, using newInstance is commonly used if to perform some initialization prior to handing back an instance of the class. If every time you request a new instance of the class by calling its constructor, you end up setting a bunch of instance variables before you can use the object, then it would make more sense to have the newInstance method perform that initialization and return to you an object that's ready to use.

For example, Activitys and Fragments aren't initialized in their constructors. Instead, they are generally initialized during onCreate. Therefore, it's common practice for the newInstance method to accept whatever parameters the object will need to use during initialization, and it stores them in a Bundle that the object can read from later. An example of this can be seen here:

Sample class with newInstance method