Método estático en una clase genérica?

En Java, me gustaría tener algo como:

class Clazz<T> {
  static void doIt(T object) {
    // ...
  }
}

Pero consigo

No se puede hacer una referencia estática al tipo T no estático

No entiendo los genéricos más allá de los usos básicos y, por lo tanto, no tiene mucho sentido. No ayuda que no haya podido encontrar mucha información en Internet sobre el tema.

¿Podría alguien aclarar si tal uso es posible, de manera similar? Además, ¿por qué fracasó mi intento original?

No puede usar los parámetros de tipo genérico de una clase en métodos estáticos o campos estáticos. Los parámetros de tipo de la clase solo están dentro del alcance de los métodos de instancia y los campos de instancia. Para campos estáticos y métodos estáticos, se comparten entre todas las instancias de la clase, incluso instancias de diferentes parámetros de tipo, por lo que obviamente no pueden depender de un parámetro de tipo particular.

No parece que su problema deba requerir el uso del parámetro de tipo de la clase. Si describe lo que está tratando de hacer con más detalle, tal vez podamos ayudarlo a encontrar una mejor manera de hacerlo.

Java no sabe qué Tes hasta que crea una instancia de un tipo.

Tal vez pueda ejecutar métodos estáticos llamando, Clazz<T>.doit(something)pero parece que no puede.

La otra forma de manejar las cosas es poner el parámetro de tipo en el método mismo:

static <U> void doIt(U object)

lo que no te da la restricción correcta en U, pero es mejor que nada ...

Me encontré con este mismo problema. Encontré mi respuesta descargando el código fuente Collections.sorten el marco de Java. La respuesta que usé fue poner el <T>genérico en el método, no en la definición de la clase.

Entonces esto funcionó:

public class QuickSortArray  {
    public static <T extends Comparable> void quickSort(T[] array, int bottom, int top){
//do it
}

}

Por supuesto, después de leer las respuestas anteriores, me di cuenta de que esta sería una alternativa aceptable sin usar una clase genérica:

public static void quickSort(Comparable[] array, int bottom, int top){
//do it
}

Es posible hacer lo que quiera usando la sintaxis para métodos genéricos al declarar su doIt()método (observe la adición de <T>entre staticy voiden la firma del método de doIt()):

class Clazz<T> {
  static <T> void doIt(T object) {
    // shake that booty
  }
}

Obtuve el editor Eclipse para aceptar el código anterior sin el Cannot make a static reference to the non-static type Terror y luego lo expandí al siguiente programa de trabajo (completo con referencias culturales algo apropiadas para la edad):

public class Clazz<T> {
  static <T> void doIt(T object) {
    System.out.println("shake that booty '" + object.getClass().toString()
                       + "' !!!");
  }

  private static class KC {
  }

  private static class SunshineBand {
  }

  public static void main(String args[]) {
    KC kc = new KC();
    SunshineBand sunshineBand = new SunshineBand();
    Clazz.doIt(kc);
    Clazz.doIt(sunshineBand);
  }
}

Lo que imprime estas líneas en la consola cuando lo ejecuto:

agite ese botín 'class com.eclipseoptions.datamanager.Clazz $ KC' !!!
agite ese botín 'class com.eclipseoptions.datamanager.Clazz $ SunshineBand' !!!

Creo que esta sintaxis aún no se ha mencionado (en el caso de que desee un método sin argumentos):

class Clazz {
  static <T> T doIt() {
    // shake that booty
  }
}

Y la llamada:

String str = Clazz.<String>doIt();

Espero que esto ayude a alguien.

Se menciona correctamente en el error: no se puede hacer una referencia estática a T. tipo no estática La razón es el parámetro de tipo Tpuede ser sustituido por cualquiera de los argumentos por ejemplo, tipo Clazz<String>o Clazz<integer>etc, pero los campos estáticos / métodos son compartidos por todos los no -objetos estáticos de la clase.

El siguiente extracto se toma del documento :

El campo estático de una clase es una variable de nivel de clase compartida por todos los objetos no estáticos de la clase. Por lo tanto, los campos estáticos de parámetros de tipo no están permitidos. Considere la siguiente clase:

public class MobileDevice<T> {
    private static T os;

    // ...
}

Si se permitieran campos estáticos de parámetros de tipo, se confundiría el siguiente código:

MobileDevice<Smartphone> phone = new MobileDevice<>();
MobileDevice<Pager> pager = new MobileDevice<>();
MobileDevice<TabletPC> pc = new MobileDevice<>();

Debido a que el campo estático os es compartido por teléfono, buscapersonas y pc, ¿cuál es el tipo real de sistema operativo? No puede ser Smartphone, Pager y TabletPC al mismo tiempo. Por lo tanto, no puede crear campos estáticos de parámetros de tipo.

Como acertadamente señaló Chris en su respuesta , debe usar el parámetro type con el método y no con la clase en este caso. Puedes escribirlo como:

static <E> void doIt(E object) 

Algo como lo siguiente te acercaría

class Clazz
{
   public static <U extends Clazz> void doIt(U thing)
   {
   }
}

EDITAR: ejemplo actualizado con más detalles

public abstract class Thingo 
{

    public static <U extends Thingo> void doIt(U p_thingo)
    {
        p_thingo.thing();
    }

    protected abstract void thing();

}

class SubThingoOne extends Thingo
{
    @Override
    protected void thing() 
    {
        System.out.println("SubThingoOne");
    }
}

class SubThingoTwo extends Thingo
{

    @Override
    protected void thing() 
    {
        System.out.println("SuThingoTwo");
    }

}

public class ThingoTest 
{

    @Test
    public void test() 
    {
        Thingo t1 = new SubThingoOne();
        Thingo t2 = new SubThingoTwo();

        Thingo.doIt(t1);
        Thingo.doIt(t2);

        // compile error -->  Thingo.doIt(new Object());
    }
}

Cuando especifica un tipo genérico para su clase, JVM sabe que solo tiene una instancia de su clase, no una definición. Cada definición solo tiene un tipo parametrizado.

Los genéricos funcionan como plantillas en C ++, por lo que primero debe crear una instancia de su clase, luego usar la función con el tipo que se especifica.

También para decirlo en términos simples, ocurre debido a la propiedad "Erasure" de los genéricos. Lo que significa que aunque definimos ArrayList<Integer>y ArrayList<String>, en el momento de la compilación, permanece como dos tipos concretos diferentes, pero en el tiempo de ejecución la JVM borra los tipos genéricos y crea solo una clase ArrayList en lugar de dos clases. Entonces, cuando definimos un método de tipo estático o cualquier cosa para un genérico, es compartido por todas las instancias de ese genérico, en mi ejemplo es compartido por ambos ArrayList<Integer>y. ArrayList<String>Es por eso que obtiene el error. Un parámetro de tipo genérico de una clase no es Permitido en un contexto estático!

@BD en Rivenhill: Dado que esta vieja pregunta ha recibido una atención renovada el año pasado, sigamos un poco, solo por el bien de la discusión. El cuerpo de su doItmétodo no hace nada Tespecífico. Aquí está:

public class Clazz<T> {
  static <T> void doIt(T object) {
    System.out.println("shake that booty '" + object.getClass().toString()
                       + "' !!!");
  }
// ...
}

Por lo tanto, puede descartar por completo todas las variables de tipo y solo codificar

public class Clazz {
  static void doIt(Object object) {
    System.out.println("shake that booty '" + object.getClass().toString()
                       + "' !!!");
  }
// ...
}

Okay. Pero volvamos más cerca del problema original. La primera variable de tipo en la declaración de clase es redundante. Solo se necesita el segundo en el método. Aquí vamos de nuevo, pero aún no es la respuesta final:

public class Clazz  {
  static <T extends Saying> void doIt(T object) {
    System.out.println("shake that booty "+ object.say());
  }

  public static void main(String args[]) {
    Clazz.doIt(new KC());
    Clazz.doIt(new SunshineBand());
  }
}
// Output:
// KC
// Sunshine

interface Saying {
      public String say();
}

class KC implements Saying {
      public String say() {
          return "KC";
      }
}

class SunshineBand implements Saying {
      public String say() {
          return "Sunshine";
      }
}

Sin embargo, es demasiado alboroto por nada, ya que la siguiente versión funciona de la misma manera. Todo lo que necesita es el tipo de interfaz en el parámetro del método. No hay variables de tipo a la vista en ningún lado. ¿Era realmente ese el problema original?

public class Clazz  {
  static void doIt(Saying object) {
    System.out.println("shake that booty "+ object.say());
  }

  public static void main(String args[]) {
    Clazz.doIt(new KC());
    Clazz.doIt(new SunshineBand());
  }
}

interface Saying {
      public String say();
}

class KC implements Saying {
      public String say() {
          return "KC";
      }
}

class SunshineBand implements Saying {
      public String say() {
          return "Sunshine";
      }
}

Dado que las variables estáticas son compartidas por todas las instancias de la clase. Por ejemplo, si tiene el siguiente código

class Class<T> {
  static void doIt(T object) {
    // using T here 
  }
}

T está disponible solo después de crear una instancia. Pero los métodos estáticos se pueden usar incluso antes de que haya instancias disponibles. Por lo tanto, no se puede hacer referencia a los parámetros de tipo genérico dentro de los métodos y variables estáticos