Metoda statyczna w klasie ogólnej?

W Javie chciałbym mieć coś takiego:

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

Ale rozumiem

Nie można dokonać statycznego odniesienia do niestatycznego typu T.

Nie rozumiem leków generycznych poza podstawowymi zastosowaniami, a zatem nie mam większego sensu. Nie pomaga to, że nie byłem w stanie znaleźć wielu informacji na ten temat w Internecie.

Czy ktoś mógłby wyjaśnić, czy takie użycie jest możliwe w podobny sposób? Ponadto, dlaczego moja pierwotna próba się nie powiodła?

Nie można używać ogólnych parametrów klasy w metodach statycznych lub polach statycznych. Parametry typu klasy znajdują się w zakresie tylko dla metod instancji i pól instancji. W przypadku pól statycznych i metod statycznych są one wspólne dla wszystkich instancji klasy, nawet instancji różnych parametrów typu, więc oczywiście nie mogą zależeć od określonego parametru typu.

Nie wydaje się, że Twój problem powinien wymagać użycia parametru type klasy. Jeśli bardziej szczegółowo opisujesz to, co próbujesz zrobić, może pomożemy Ci znaleźć lepszy sposób.

Java nie wie co T jest, dopóki nie utworzysz instancji typu.

Może możesz wykonać metody statyczne, wywołując Clazz<T>.doit(something) ale brzmi to tak, jakbyś nie mógł.

Innym sposobem radzenia sobie z tym jest umieszczenie parametru type w samej metodzie:

static <U> void doIt(U object)

co nie zapewnia właściwego ograniczenia U, ale jest lepsze niż nic ....

Natrafiłem na ten sam problem. Znalazłem odpowiedź, pobierając kod źródłowy do Collections.sortframeworku Java. Odpowiedziałem, że użyłem <T>ogólny w metodzie, a nie w definicji klasy.

Więc to zadziałało:

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

}

Oczywiście po przeczytaniu powyższych odpowiedzi zdałem sobie sprawę, że byłaby to akceptowalna alternatywa bez użycia klasy ogólnej:

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

Można zrobić to, co chcesz, używając składni dla metod ogólnych podczas deklarowania doIt()metody (zwróć uwagę na dodanie <T>między statici voidw podpisie metody doIt()):

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

Poprosiłem edytor Eclipse, aby zaakceptował powyższy kod bez Cannot make a static reference to the non-static type Tbłędu, a następnie rozszerzyłem go na następujący program roboczy (wraz z odniesieniami do kultury nieco dostosowanymi do wieku):

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

Które drukuje te linie do konsoli po uruchomieniu:

potrząśnij tym łupem „klasa com.eclipseoptions.datamanager.Clazz $ KC” !!!
potrząśnij tym łupem „klasa com.eclipseoptions.datamanager.Clazz $ SunshineBand” !!!

Myślę, że ta składnia nie została jeszcze wspomniana (w przypadku, gdy chcesz metodę bez argumentów):

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

I połączenie:

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

Mam nadzieję, że komuś to pomoże.

Jest to poprawnie wymienione w błędzie: nie można odwoływać się statycznie do niestatycznego typu T. Powodem jest to, że parametr type Tmożna zastąpić dowolnym argumentem type, np. Clazz<String>LubClazz<integer> itd. Ale wszystkie pola / metody statyczne są wspólne -statyczne obiekty klasy.

Poniższy fragment pochodzi z dokumentu :

Pole statyczne klasy jest zmienną na poziomie klasy wspólną dla wszystkich niestatycznych obiektów klasy. Dlatego pola statyczne parametrów typu nie są dozwolone. Rozważ następującą klasę:

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

    // ...
}

Gdyby dozwolone były pola statyczne parametrów typu, następujący kod zostałby pomylony:

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

Ponieważ statyczny system operacyjny jest współdzielony przez telefon, pager i komputer, jaki jest rzeczywisty typ systemu operacyjnego? Nie może to być jednocześnie Smartfon, Pager i TabletPC. Dlatego nie można tworzyć pól statycznych o parametrach typu.

Jak słusznie zauważył Chris w swojej odpowiedzi , musisz użyć parametru type z metodą, a nie z klasą w tym przypadku. Możesz to napisać w następujący sposób:

static <E> void doIt(E object) 

Coś takiego może przybliżyć cię

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

EDYCJA: Zaktualizowano przykład bardziej szczegółowo

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

Gdy określisz typ ogólny dla swojej klasy, JVM wie o tym, że ma tylko instancję klasy, a nie definicję. Każda definicja ma tylko sparametryzowany typ.

Generyczne działają jak szablony w C ++, więc powinieneś najpierw utworzyć instancję swojej klasy, a następnie użyć funkcji z określonym typem.

Mówiąc prościej, dzieje się tak ze względu na właściwość „Wymaż” generyków. Oznacza to, że chociaż definiujemy ArrayList<Integer>i ArrayList<String>, w czasie kompilacji, pozostają jako dwa różne konkretne typy, ale w czasie wykonywania JVM usuwa typy ogólne i tworzy tylko jedną klasę ArrayList zamiast dwóch klas. Więc kiedy zdefiniujemy metodę typu statycznego lub cokolwiek innego dla rodzaju ogólnego, jest ona współdzielona przez wszystkie instancje tego typu ogólnego, w moim przykładzie jest wspólna dla obu ArrayList<Integer>i ArrayList<String>dlatego otrzymujesz błąd. Parametr typu ogólnego nie jest parametrem Dozwolone w kontekście statycznym!

@BD w Rivenhill: Ponieważ w zeszłym roku to stare pytanie zyskało nowe zainteresowanie, kontynuujmy trochę ze względu na dyskusję. Ciało twojej doItmetody nie robi nic Tspecyficznego. Oto on:

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

Możesz więc całkowicie upuścić wszystkie zmienne typu i po prostu kodować

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

Dobrze. Wróćmy jednak do pierwotnego problemu. Pierwsza zmienna typu w deklaracji klasy jest redundantna. Potrzebna jest tylko druga metoda. Zaczynamy od nowa, ale to jeszcze nie ostateczna odpowiedź:

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

Jednak jest to zbyt wielkie zamieszanie o nic, ponieważ następująca wersja działa tak samo. Wszystko czego potrzebuje to typ interfejsu parametru parametru. Nigdzie nie widać żadnych typów zmiennych. Czy to był naprawdę oryginalny 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";
      }
}

Ponieważ zmienne statyczne są wspólne dla wszystkich instancji klasy. Na przykład, jeśli masz następujący kod

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

T jest dostępny tylko po utworzeniu instancji. Ale można zastosować metody statyczne, nawet zanim instancje będą dostępne. Zatem do parametrów typu ogólnego nie można odwoływać się w metodach statycznych i zmiennych