Static factory method

Patrón creacional (método de fabrica estático)

El static factory method es un patrón que permite crear objetos usando un método en vez de un constructor.

//Constructor
final A a = new A();

//Static factory method
final A a = A.instance();

En un primer momento uno puedo pensar que hacer eso no tiene ninguna utilidad, pero quizas con otro ejemplo podamos empezar a ver ventajas.

//Constructor
final A a = new A(1, 2);

//Static factory method
final A a = A.fromWidthAndHeight(1, 2);

Ahora claramente se ve una diferencia, es mucho más fácil saber que es cada parámetro. Al usar métodos estáticos podemos aprovechar para dar contexto de lo que vamos a usar.

Get ECN’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Al no usar constructores, no es necesario de devolver siempre una nueva instancia, podemos reutilizar una existente. Si tenemos un número reducido de opciones (como un Enum), podríamos tener preparadas las instancias y devolverlas.

private static final A DEFAULTE = new Rectangle(100, 100);    

public static A fromWidthAndHeight(final int width, final int height) {
    if (width == 100 && height == 100) {
        return DEFAULT_RECTANGLE;
    }

    return new A(width, height);
}

Otra ventaja es que podemos devolver subclases, al estar usando un método estático, no tenemos por qué devolver la misma clase. Y eso a su vez permite ocultar clases.

public interface Animal {
    void makeSound();

    static Animal createDog() {
        return new Dog();
    }
}

// Dog puede ser privado o package-private
class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

Similar a lo anterior, dependiendo de los parámetros podemos devolver clases distintas llamando al mismo método.

public interface Animal {
    void makeSound();

    static Animal createDog(final int size) {
        if(size > 5) {
          return new BigDog();
        }

        return new Dog();
    }
}

Y finalmente, este patrón ofrece las bases para el patrón service provider framework (por ejemplo usado en JDBC).

Encontramos dos desventajas principales:

1. En el caso de usar constructores privados para usar métodos estáticos, no podremos tener subclases
2. Otro problema es que son más difíciles de encontrar para los programadores, ya que dentro de la documentación de Java (Javadoc), no tienen nada que los destaque como si lo tienen los constructores.

Referencia

Joshua Bloch, *Effective Java* (3ª edición), Addison-Wesley, 2018.