Why do some Java libraries use static newInstance functions instead of constructors?

Question

While developing for Android, I came across a Bitmap class. I find it strange that this class has no public constructors, but instead offers the static createBitmap function with the exact same purpose.

Syntactically there's no advantage:

Bitmap bm = new Bitmap(10, 10);
Bitmap bm = Bitmap.createBitmap(10, 10);

I've seen other classes do this as well, where the equivalent static function is usually named newInstance. What is the reason for this?

Answer 1

What you're describing is called a Factory Method. It exists because it provides the ability to get an object that conforms to a particular interface, but which may have a different underlying implementation.

For (a completely arbitrary and trivial) example, the Factory Method may choose to hand you a LinkedList object instead of an ArrayList object, because the initial size you specified may have performance advantages in the LinkedList.

But both list implementations conform to the IList interface, so the resulting object is returned as an IList.

Answer 2

In the first case, you need to instantiate a specific type. In the second you leave it to the implementer to decide which type to return.

I am not familiar with Bitmap, but another example is EnumSet. When you call:

EnumSet<SomeEnum> set = EnumSet.noneOf(SomeEnum.class);

the static factory method uses a different implementation depending on the number of items in your enum to be as efficient as possible in all situations.

The underlying code returns either a RegularEnumSet for small enums or a JumboEnumSet for large enums. That kind of contextual optimisation would not be possible with a constructor.

public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
    Enum[] universe = getUniverse(elementType);
    if (universe == null)
        throw new ClassCastException(elementType + " not an enum");

    if (universe.length <= 64)
        return new RegularEnumSet<>(elementType, universe);
    else
        return new JumboEnumSet<>(elementType, universe);
}

Answer 3

This is the factory method pattern.

There are two main reasons to do this:

1. It allows for the possibility of in the future not always returning a new instance each time. For example Integer.valueOf(int) will re-use the same Integer objects it already created if the values are between -127 and 128. which are the most common Integer values used in code so we don't have the JVM making thousands of copies of identical instances (which each take up memory) and can just reuse the same instance.

2. It allows for the static method to return a subclass without the caller knowing. This can be useful if combining the factory method with other Design Patterns like Proxy or Adapter to return modified versions of the class.

Answer 4

Edit: This question is some what covered:

Factory, Abstract Factory and Factory Method

Design Patterns: Factory vs Factory method vs Abstract Factory

That's the factory pattern. The whole point is to create classes from a static class, so you can hide the programmed details of the class (security measure).

Source:

http://www.oodesign.com/factory-pattern.html

Intent:

creates objects without exposing the instantiation logic to the client. refers to the newly created object through a common interface

Example:

public class ProductFactory{
    public Product createProduct(String ProductID){
        if (id==ID1)
            return new OneProduct();
        if (id==ID2) return
            return new AnotherProduct();
        ... // so on for the other Ids

        return null; //if the id doesn't have any of the expected values
    }
    ...
}

Another solid source:

http://sourcemaking.com/design_patterns/factory_method