genéricos de Java, singletons y métodos estáticos

Question

Así que tengo algunas clases de 'Administrador', por ejemplo GroupManager. Todos estos gerentes son solteros.

El uso de este método para la creación de instancias:

private static GroupManager groupManager = null; 

private GroupManager() 
{ 

} 

public static GroupManager Instance() 
{ 
    if (groupManager == null) 
    { 
     groupManager = new GroupManager(); 
    } 
    return groupManager; 
} 

Estoy pensando que debería empezar a utilizar alguna herencia, ya que tienen una gran cantidad de métodos copiados.

Los métodos de Instance() para cada administrador son los mismos.

Así que para la herencia que pueda hacer esto (obviamente):

GroupManager extends Manager 

¿Es posible el uso de los genéricos para utilizar el mismo método de instancia para todos los gerentes, algo así como:

public class Manager<E> 
{ 
    private static E instance = null; 

    public static E Instance() 
    { 
     if (instance == null) 
     { 
      instance = new E(); 
     } 
     return instance; 
    } 

} 

pienso eso tiene sentido :)

Entonces, usted haría GroupManager.Instance() como normal.

Answer 1

No entiende cómo funcionan los genéricos y la estática. Si tiene un campo o método estático (como "instancia" o instancia()), que puede invocarse sin instanciar el administrador de clase, ¿cómo espera que la JVM (y el compilador par) sepan qué tipo E se supone que debe ¿ser?

Aquí está un ejemplo, de acuerdo con la sugerencia de G_H:

Gerente General y AreaManager tanto se extienden Administrador

La clase Manager es el único que tiene la getInstance() método estático:

public class Manager { 

     private static Map<Class<? extends Manager>,Manager> INSTANCES_MAP = new java.util.HashMap<Class<? extends Manager>, Manager>(); 

//Also, you will want to make this method synchronized if your application is multithreaded, 
//otherwise you mihgt have a race condition in which multiple threads will trick it into 
//creating multiple instances 
     public static <E extends Manager> E getInstance(Class<E> instanceClass) throws InstantiationException, IllegalAccessException { 
      if(INSTANCES_MAP.containsKey(instanceClass)) { 
       return (E) INSTANCES_MAP.get(instanceClass); 
      } else { 
       E instance = instanceClass.newInstance(); 
       INSTANCES_MAP.put(instanceClass, instance); 
       return instance; 
      } 
     } 
    } 

Answer 2

No, no va a funcionar. Java usa genéricos en tiempo de compilación para la verificación de tipos, pero no genera clases adicionales ni retiene información sobre los parámetros de tipo en el tiempo de ejecución.

Cuando declara Manager<E> con ese parámetro de tipo E, eso es algo que solo desempeñará una función en una instancia real. Podrías tener una subclase como GroupManager extends Manager<String> o lo que sea, pero eso no va a generar mágicamente una variedad del método estático.

Los métodos y miembros estáticos pertenecen a una clase, no a una instancia. Así que tratar de usar genéricos allí, que están destinados a tipear instancias, no va a volar.

Answer 3

Si hace que su clase de administrador de grupo sea la siguiente, puede llamar a su método de instancia.

public class GroupManager extends Manager<GroupManager>{} 

Y en su clase Gestor de probar este ...

public class Manager<E> 
{ 
private static E instance = null; 

public static E Instance() 
{ 
        try { 
      return instance.newInstance(); 
     } catch (InstantiationException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (IllegalAccessException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 

     return null; 
} 

O si se conoce el objeto que desea una instancia para, simplemente hacer que el método genérico

public static <T> T getInstance(Class<T> t){ 
      try { 
      return t.newInstance(); 
     } catch (InstantiationException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (IllegalAccessException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 

     return null; 
    } 

I HAVN No intenté nada de esto, así que no estoy seguro de si funcionará.

Answer 4

Inyectando el constructor en un contexto genérico.Dinero en efectivo no es seguro para subprocesos, pero sólo se utiliza en el contexto estático por lo que su muy bien si usted no se pierda usarlo

public class Example { 

    public static class MySingletonClass { 
    } 

    public interface Provider<T> { 
     T get(); 
    } 

    static final Provider<MySingletonClass> myClassInstanceProvider = new Cash<MySingletonClass>(new Provider<MySingletonClass>() { 
      @Override 
      public MySingletonClass get() { 
       return new MySingletonClass(); 
      } 
     }); 


    public static class Cash<T> implements Provider<T> { 
     private Provider<T> provider; 

     public Cash(Provider<T> provider) { 
      this.provider = provider; 
     } 

     @Override 
     public T get() { 

      final T t = provider.get(); 
      provider = new Provider<T>() { 

       @Override 
       public T get() { 
        return t; 
       } 
      }; 
      return t; 
     } 
    } 
} 

Answer 5

public class Manager<E>{ 

private static Object instance = null; 

    public static E Instance() { 
     if (instance == null) 
     { 
     instance = new E(); 
     } 
     return (E)instance; 
    } 
}