Statische Methode in einer generischen Klasse?

Können Sie nicht verwenden Sie eine Klasse einen generischen Typ-Parameter in statische Methoden oder statische Felder. Die Klasse der Typ-Parameter sind nur in dem Bereich für Instanzmethoden und instanzfelder. Für statische Felder und statische Methoden, die Sie freigegeben werden, die von allen Instanzen der Klasse werden auch Instanzen von anderen Typ-Parameter, so natürlich Sie können nicht abhängig von einem bestimmten Typ-parameter.

Es scheint nicht, wie sollte dein problem mit der Klasse der Typ-parameter. Wenn Sie beschreiben, was Sie zu tun versuchen, im detail, vielleicht können wir Ihnen helfen, einen besseren Weg, es zu tun.

InformationsquelleAutor der Antwort newacct

Ich lief in das gleiche problem. Ich fand meine Antwort durch das herunterladen der source-code für Collections.sort im java framework. Die Antwort, die ich verwendet wurde, um die <T> Generika in der Methode, nicht in der definition der Klasse.

So, das hat funktioniert:

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

}

Natürlich, nach der Lektüre der Antworten oben erkannte ich, dass dies eine akzeptable alternative ohne Verwendung einer generischen Klasse:

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

InformationsquelleAutor der Antwort Chris

Andere haben beantwortet Ihre Frage bereits, aber darüber hinaus kann ich durchweg empfehlen Ihnen, die O ' Reilly Java Generics Buch. Es ist ein subtiles und Komplexes Thema bei Zeiten, und wenn es oft scheint sinnlos Einschränkungen, aber das Buch hat einen ziemlich guten job zu erklären, warum die java-generics sind, wie Sie sind.

InformationsquelleAutor der Antwort skaffman

Etwas wie das folgende bekommen würde, Sie näher

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

EDIT: Aktualisiert, Beispiel mit mehr detail

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());
    }
}

InformationsquelleAutor der Antwort ekj

Wenn Sie angeben, dass ein generischer Typ für Ihre Klasse, JVM wissen es, nur eine Instanz der Klasse, nicht definition. Jede definition hat nur parametrisierten Typ.

Generika funktionieren wie templates in C++, sollte man zuerst instanziieren der Klasse, dann die Funktion mit dem Typ angegeben wird.

InformationsquelleAutor der Antwort Marcin Cylke

@BD bei Rivenhill: Da diese alte Frage hat bekommen neue Aufmerksamkeit im letzten Jahr, gehen wir nun ein bisschen, nur für die Zwecke der Diskussion.
Der Körper Ihres doIt Methode tut man nicht alles T-spezifisch an allen. Hier ist es:

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

So können Sie ganz drop alle Variablen-und code

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

Ok. Aber kommen wir wieder näher an das ursprüngliche problem. Der erste Typ, den die variable auf die Klasse Erklärung ist überflüssig. Nur der zweite eine über die Methode benötigt wird. Hier gehen wir wieder, aber es ist nicht die endgültige Antwort, dennoch:

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";
      }
}

Jedoch, es ist alles zu viel Aufregung um nichts, da die folgende version funktioniert genau die gleiche Weise. Alle es braucht, ist die Art der Schnittstelle auf die parameter der Methode. Keine Typ-Variablen in Sicht, nirgendwo. War das eigentlich das ursprüngliche problem?

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";
      }
}

InformationsquelleAutor der Antwort Hubert Kauker