Statische Methode in einer generischen Klasse?

In Java hätte ich gerne etwas wie:

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

Aber ich verstehe

Es kann kein statischer Verweis auf den nicht statischen Typ T erstellt werden

Ich verstehe Generika nicht über die grundlegenden Verwendungszwecke hinaus und kann daher nicht viel Sinn daraus machen. Es hilft nicht, dass ich im Internet nicht viele Informationen zu diesem Thema finden konnte.

Könnte jemand auf ähnliche Weise klären, ob eine solche Verwendung möglich ist? Warum war mein ursprünglicher Versuch ebenfalls erfolglos?

Sie können die generischen Typparameter einer Klasse nicht in statischen Methoden oder statischen Feldern verwenden. Die Typparameter der Klasse sind nur für Instanzmethoden und Instanzfelder gültig. Bei statischen Feldern und statischen Methoden werden sie von allen Instanzen der Klasse gemeinsam genutzt, auch von Instanzen unterschiedlicher Typparameter. Daher können sie offensichtlich nicht von einem bestimmten Typparameter abhängen.

Es scheint nicht so, als ob Ihr Problem die Verwendung des Typparameters der Klasse erfordern sollte. Wenn Sie detaillierter beschreiben, was Sie versuchen, können wir Ihnen vielleicht dabei helfen, einen besseren Weg zu finden.

Java weiß nicht, was Tist, bis Sie einen Typ instanziieren.

Vielleicht können Sie statische Methoden durch Aufrufen ausführen, Clazz<T>.doit(something)aber es hört sich so an, als könnten Sie das nicht.

Die andere Möglichkeit, mit Dingen umzugehen, besteht darin, den Typparameter in die Methode selbst einzufügen:

static <U> void doIt(U object)

Das bringt dir nicht die richtige Einschränkung für U, aber es ist besser als nichts ...

Ich bin auf dasselbe Problem gestoßen. Ich fand meine Antwort, indem ich den Quellcode für Collections.sortim Java-Framework herunterlud . Die Antwort, die ich verwendet habe, war, das <T>Generikum in die Methode und nicht in die Klassendefinition einzufügen.

Das hat also funktioniert:

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

}

Nachdem ich die obigen Antworten gelesen hatte, wurde mir klar, dass dies eine akzeptable Alternative wäre, ohne eine generische Klasse zu verwenden:

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

Sie können tun, was Sie möchten, indem Sie beim Deklarieren Ihrer doIt()Methode die Syntax für generische Methoden verwenden (beachten Sie das Hinzufügen von <T>zwischen staticund voidin der Methodensignatur von doIt()):

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

Ich habe den Eclipse-Editor dazu gebracht, den obigen Code ohne Cannot make a static reference to the non-static type TFehler zu akzeptieren, und ihn dann auf das folgende Arbeitsprogramm erweitert (komplett mit einem altersgerechten kulturellen Bezug):

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

Was druckt diese Zeilen auf der Konsole, wenn ich es ausführe:

Schütteln Sie diese Beute 'Klasse com.eclipseoptions.datamanager.Clazz $ KC' !!!
Schütteln Sie diese Beute 'Klasse com.eclipseoptions.datamanager.Clazz $ SunshineBand' !!!

Ich denke, diese Syntax wurde noch nicht erwähnt (falls Sie eine Methode ohne Argumente wünschen):

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

Und der Anruf:

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

Hoffe das hilft jemandem.

Es ist richtig in dem Fehler erwähnt: Sie keinen statischen Verweis auf nicht-statischen Typ T. Der Grund machen können , ist der Typparameter Tdurch eine des Typargument zB ersetzt werden kann Clazz<String>oder Clazz<integer>etc. Aber statische Felder / Methoden , die von allen nicht geteilt werden -statische Objekte der Klasse.

Der folgende Auszug stammt aus dem Dokument :

Das statische Feld einer Klasse ist eine Variable auf Klassenebene, die von allen nicht statischen Objekten der Klasse gemeinsam genutzt wird. Daher sind statische Felder von Typparametern nicht zulässig. Betrachten Sie die folgende Klasse:

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

    // ...
}

Wenn statische Felder mit Typparametern zulässig wären, wäre der folgende Code verwirrt:

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

Was ist der tatsächliche Betriebssystemtyp, da das statische Feld os von Telefon, Pager und PC gemeinsam genutzt wird? Es können nicht gleichzeitig Smartphone, Pager und TabletPC sein. Sie können daher keine statischen Felder mit Typparametern erstellen.

Wie Chris in seiner Antwort zu Recht betont hat, müssen Sie den Typparameter für die Methode und in diesem Fall nicht für die Klasse verwenden. Sie können es schreiben wie:

static <E> void doIt(E object) 

So etwas wie das Folgende würde dich näher bringen

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

BEARBEITEN: Beispiel mit mehr Details aktualisiert

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

Wenn Sie einen generischen Typ für Ihre Klasse angeben, weiß JVM, dass nur eine Instanz Ihrer Klasse vorhanden ist, keine Definition. Jede Definition hat nur einen parametrisierten Typ.

Generika funktionieren wie Vorlagen in C ++, daher sollten Sie zuerst Ihre Klasse instanziieren und dann die Funktion mit dem angegebenen Typ verwenden.

Einfach ausgedrückt geschieht dies aufgrund der "Erasure" -Eigenschaft der Generika. Dies bedeutet, dass wir zwar definieren ArrayList<Integer>und ArrayList<String>zur Kompilierungszeit zwei verschiedene konkrete Typen beibehalten, die JVM jedoch zur Laufzeit generische Typen und löscht Erstellt nur eine ArrayList-Klasse anstelle von zwei Klassen. Wenn wir also eine statische Typmethode oder etwas anderes für ein Generikum definieren, wird sie von allen Instanzen dieses Generikums gemeinsam genutzt. In meinem Beispiel wird sie von beiden ArrayList<Integer>gemeinsam genutzt. ArrayList<String>Aus diesem Grund wird der Fehler angezeigt. Ein generischer Typparameter einer Klasse ist nicht In einem statischen Kontext erlaubt!

@BD bei Rivenhill: Da diese alte Frage im letzten Jahr erneut Beachtung gefunden hat, lassen Sie uns ein wenig weitermachen, nur um zu diskutieren. Der Körper Ihrer doItMethode macht überhaupt nichts TSpezifisches. Hier ist es:

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

Sie können also alle Typvariablen und nur Code vollständig löschen

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

OK. Aber kommen wir dem ursprünglichen Problem näher. Die erste Typvariable in der Klassendeklaration ist redundant. Es wird nur die zweite Methode benötigt. Jetzt geht es wieder los, aber es ist noch nicht die endgültige Antwort:

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

Es ist jedoch allzu viel Aufhebens um nichts, da die folgende Version genauso funktioniert. Es wird lediglich der Schnittstellentyp für den Methodenparameter benötigt. Nirgendwo sind Typvariablen in Sicht. War das wirklich 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";
      }
}

Da statische Variablen von allen Instanzen der Klasse gemeinsam genutzt werden. Zum Beispiel, wenn Sie folgenden Code haben

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

T ist erst verfügbar, nachdem eine Instanz erstellt wurde. Statische Methoden können jedoch verwendet werden, noch bevor Instanzen verfügbar sind. Daher können generische Typparameter nicht in statischen Methoden und Variablen referenziert werden