¿Ocultando un constructor detrás de un método de creador estático?

Question

Recientemente descubrí una forma interesante de crear una nueva instancia de un objeto en Google Guava y Project Lombok: Ocultar un constructor detrás de un método de creador estático. Esto significa que en lugar de hacer new HashBiMap(), usted hace HashBiMap.create().

Mi pregunta es ¿por qué? ¿Qué ventaja tienes de ocultar el constructor? Para mí, no veo absolutamente ninguna ventaja de hacer esto, y parece romper los principios básicos de creación de objetos. Desde el principio, usted crea un objeto con new Object(), no con algún método Object.createMe(). Esto casi parece crear un método por el bien de crear un método.

¿Qué ganas al hacer esto?

Answer 1

Existen varias razones por las que puede preferir un método de fábrica estático en lugar de un constructor público. Puede leer el Artículo 1 en Effective Java, Second Edition para una discusión más larga.

1. Permite que el tipo de objeto devuelto por el método sea diferente del tipo de la clase que contiene el método. De hecho, el tipo devuelto puede depender de los parámetros. Por ejemplo, EnumSet.of(E) devolverá un tipo diferente si el tipo emum tiene muy pocos elementos vs si el tipo enum tiene muchos elementos (Edit: en este caso particular, mejorando el rendimiento para el caso común donde la enumeración no tiene muchos elementos)
2. Permite el almacenamiento en caché. Por ejemplo, Integer.valueOf(x) devolverá la misma instancia de objeto si se llama varias veces con el mismo valor x, si x está entre -128 y 127.
3. Le permite tener constructores con nombre (que pueden ser útiles si la clase necesita muchos constructores). Ver, por ejemplo, los métodos en java.util.concurrent.Executors.
4. Le permite crear una API que es conceptualmente simple pero realmente muy poderosa. Por ejemplo, los métodos estáticos en Collections esconden muchos tipos. En lugar de tener una clase Collections con muchos métodos estáticos, podrían haber creado muchas clases públicas, pero eso hubiera sido más difícil de entender o recordar para alguien nuevo en el lenguaje.
5. Para los tipos genéricos, puede limitar la cantidad de tipeo que necesita hacer. Por ejemplo, en lugar de escribir List<String> strings = new ArrayList<String>() en Guava, puede hacer List<String> strings = Lists.newArrayList() (el método newArrayList es un método genérico y se deduce el tipo del tipo genérico).

Para HashBiMap, la última razón es la más probable.

Answer 2

Esto se conoce como un patrón de método de fábrica. Donde la fábrica se encuentra dentro de la clase misma. Wikipedia describes it pretty well pero aquí hay algunos fragmentos.

Los métodos de fábrica son comunes en los kits de herramientas y marcos donde el código de la biblioteca necesita crear objetos de tipos que pueden ser subclasificados por aplicaciones que usan el marco.

Las jerarquías de clases paralelas a menudo requieren objetos de una jerarquía para poder crear objetos apropiados de otra.

Answer 3

Bien, sería posible que SomeClass.create() extrajera una instancia de un caché. new SomeClass() no hará eso sin algunos chanchullos.

También sería posible que create() devuelva cualquier cantidad de implementaciones de SomeClass. Básicamente, un tipo de trato de fábrica.

Answer 4

Esto generalmente se hace porque la clase realmente instanciada por el método create() puede ser diferente del tipo sobre el que está invocando el método. es decir, un patrón de fábrica donde el método create() devuelve una subclase específica que es apropiada dado el contexto actual. (Por ejemplo, devolver una instancia cuando el entorno actual es Windows y otra cuando es Linux).

Answer 5

Aunque no se aplica a este ejemplo de código particular, la práctica de ocultar el constructor detrás de un método estático es Singleton Pattern. Esto se usa cuando desea asegurarse de que se cree y use una única instancia de la clase.

Answer 6

Existen muchas razones para utilizar este patrón de método de fábrica, pero una de las principales razones por las que Guava lo utiliza es que le permite evitar el uso de parámetros de tipo dos veces al crear una nueva instancia. Compare:

HashBiMap<Foo, Bar> bimap = new HashBiMap<Foo, Bar>(); 

HashBiMap<Foo, Bar> bimap = HashBiMap.create(); 

Guava también hace un buen uso del hecho de que los métodos de fábrica pueden tener nombres útiles, a diferencia de los constructores. Considere ImmutableList.of, ImmutableList.copyOf, Lists.newArrayListWithExpectedSize, etc.

También se aprovecha del hecho de que los métodos de fábrica no necesariamente tienen que crear un objeto nuevo. Por ejemplo, ImmutableList.copyOf, cuando se le da un argumento que es en sí mismo un ImmutableList, simplemente devolverá ese argumento en lugar de hacer una copia real.

Por último, los métodos de fábrica ImmutableList 's regresan subclases (no públicas) de ImmutableList como , SingletonImmutableList y RegularImmutableList en función de los argumentos.

Ninguna de estas cosas es posible con los constructores.

Answer 7

A diferencia de los constructores, los métodos estáticos pueden tener nombres de métodos. Aquí está una clase reciente que escribí cuando esto era útil:

/** 
* A number range that can be min-constrained, max-constrained, 
* both-constrained or unconstrained. 
*/ 

public class Range { 
    private final long min; 
    private final long max; 
    private final boolean hasMin; 
    private final boolean hasMax; 

    private Range(long min, long max, boolean hasMin, boolean hasMax) { 
    // ... (private constructor that just assigns attributes) 
    } 

    // Static factory methods 

    public static Range atLeast (long min) { 
    return new Range(min, 0, true, false); 
    } 

    public static Range atMost (long max) { 
    return new Range(0, max, false, true); 
    } 

    public static Range between (long min, long max) { 
    return new Range(min, max, true, true); 
    } 

    public static Range unconstrained() { 
    return new Range (0, 0, false, false); 
    } 
} 

No se podía hacer esto utilizando sólo los constructores, como atLeast y atMost tendría la misma firma exacta (que ambos tienen una larga).

Answer 8

i tiene razón muy interesante para ocultar constructor de comprobarlo y por favor, hágamelo saber si hay alguna otra alternativa para lograr este

enter code here 

Class A 
{ 
    String val; 
    protected A() 
    { 
    } 
    protected A(String val) 
    { 
     this.val=val; 
    } 
    protected void setVal(String val) 
    { 
     this.val=val; 
    } 
    public String getVal() 
    { 
     return val; 
    }  
} 
class B extends A 
    { 
    B() 
    { 
     super(); 
    }  
    public val setVal(String val) 
    { 
     super.val=val;  
    } 
} 
class C extends A 
{ 
    C(String val) 
    { 
     super(val); 
    } 
} 

Answer 9

Algunas de las razones principales

• Principalmente se le da el poder para instanciar una (sub) clase diferente
• Posibilidad de devolver null
• Le permite devolver un alr objeto existente eady