Metode statis di kelas generik?

Di Jawa, saya ingin memiliki sesuatu sebagai:

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

Tapi saya mengerti

Tidak dapat membuat referensi statis ke tipe T non-statis

Saya tidak mengerti obat generik di luar penggunaan dasar dan karenanya tidak bisa memahaminya. Tidak membantu bahwa saya tidak dapat menemukan banyak info di internet tentang masalah ini.

Bisakah seseorang mengklarifikasi jika penggunaan semacam itu dimungkinkan, dengan cara yang serupa? Juga, mengapa upaya awal saya tidak berhasil?

Anda tidak bisa menggunakan parameter tipe generik kelas dalam metode statis atau bidang statis. Parameter tipe kelas hanya dalam cakupan untuk metode instance dan bidang instance. Untuk bidang statis dan metode statis, mereka dibagikan di antara semua instance kelas, bahkan instance dari parameter tipe yang berbeda, jadi jelas mereka tidak dapat bergantung pada parameter tipe tertentu.

Sepertinya masalah Anda tidak perlu menggunakan parameter tipe kelas. Jika Anda menggambarkan apa yang ingin Anda lakukan secara lebih rinci, mungkin kami dapat membantu Anda menemukan cara yang lebih baik untuk melakukannya.

Java tidak tahu apa Titu sampai Anda instantiate jenis.

Mungkin Anda bisa menjalankan metode statis dengan menelepon Clazz<T>.doit(something)tetapi sepertinya Anda tidak bisa.

Cara lain untuk menangani berbagai hal adalah dengan memasukkan parameter tipe dalam metode itu sendiri:

static <U> void doIt(U object)

yang tidak memberi Anda batasan yang tepat pada U, tapi itu lebih baik daripada tidak sama sekali ....

Saya mengalami masalah yang sama. Saya menemukan jawaban saya dengan mengunduh kode sumber untuk Collections.sortdalam kerangka java. Jawaban yang saya gunakan adalah untuk meletakkan<T> generik dalam metode, bukan dalam definisi kelas.

Jadi ini berhasil:

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

}

Tentu saja, setelah membaca jawaban di atas saya menyadari bahwa ini akan menjadi alternatif yang dapat diterima tanpa menggunakan kelas generik:

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

Dimungkinkan untuk melakukan apa yang Anda inginkan dengan menggunakan sintaks untuk metode generik ketika mendeklarasikan doIt()metode Anda (perhatikan penambahan di <T>antara staticdan voiddalam tanda tangan metode doIt()):

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

Saya mendapat editor Eclipse untuk menerima kode di atas tanpa Cannot make a static reference to the non-static type Tkesalahan dan kemudian memperluasnya ke program kerja berikut (lengkap dengan referensi budaya yang agak sesuai usia):

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

Yang mencetak garis-garis ini ke konsol ketika saya menjalankannya:

goyangkan 'kelas com.eclipseoptions.datamanager.Clazz $ KC' !!!
goyangkan 'class com.eclipseoptions.datamanager.Clazz $ SunshineBand' !!!

Saya pikir sintaks ini belum disebutkan (jika Anda ingin metode tanpa argumen):

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

Dan panggilannya:

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

Semoga ini bisa membantu seseorang.

Disebut dengan benar dalam kesalahan: Anda tidak dapat membuat referensi statis ke tipe T. non-statis. Alasannya adalah parameter tipe Tdapat diganti oleh salah satu argumen tipe misalnya Clazz<String>atauClazz<integer> dll Tapi bidang statis / metode yang dimiliki oleh semua non objek-statis dari kelas.

Kutipan berikut diambil dari dokumen :

Bidang statis kelas adalah variabel tingkat kelas yang dibagikan oleh semua objek non-statis kelas. Oleh karena itu, bidang statis dari parameter tipe tidak diperbolehkan. Pertimbangkan kelas berikut:

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

    // ...
}

Jika bidang statis dari jenis parameter dibolehkan, maka kode berikut akan bingung:

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

Karena os bidang statis dibagi melalui telepon, pager, dan pc, apa jenis os yang sebenarnya? Itu tidak bisa Smartphone, Pager, dan TabletPC secara bersamaan. Karenanya, Anda tidak dapat membuat bidang statis dari jenis parameter.

Seperti yang ditunjukkan oleh chris dalam jawabannya, Anda perlu menggunakan tipe parameter dengan metode dan bukan dengan kelas dalam kasus ini. Anda bisa menulis seperti:

static <E> void doIt(E object) 

Sesuatu seperti yang berikut ini akan membuat Anda lebih dekat

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

Sunting: Contoh yang diperbarui dengan lebih 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());
    }
}

Ketika Anda menentukan tipe generik untuk kelas Anda, JVM tahu tentang itu hanya memiliki turunan kelas Anda, bukan definisi. Setiap definisi hanya memiliki tipe parametrized.

Generik berfungsi seperti templat di C ++, jadi pertama-tama Anda harus membuat instance kelas Anda, lalu gunakan fungsi dengan tipe yang ditentukan.

Juga untuk membuatnya secara sederhana, itu terjadi karena properti "Penghapusan" dari obat generik. Yang berarti bahwa meskipun kita mendefinisikan ArrayList<Integer>dan ArrayList<String>, pada waktu kompilasi, ia tetap sebagai dua jenis beton yang berbeda tetapi pada saat runtime JVM menghapus jenis generik dan hanya membuat satu kelas ArrayList, bukan dua kelas. Jadi ketika kita mendefinisikan metode tipe statis atau apa pun untuk generik, itu dibagi oleh semua contoh generik itu, dalam contoh saya itu dibagi oleh keduanya ArrayList<Integer>dan ArrayList<String>. Itulah sebabnya Anda mendapatkan kesalahan. Parameter Tipe Generik dari Kelas Tidak Diizinkan dalam Konteks Statis!

@BD di Rivenhill: Karena pertanyaan lama ini telah mendapat perhatian baru tahun lalu, mari kita lanjutkan sedikit, hanya demi diskusi. Tubuh doItmetode Anda tidak melakukan apa-apa- Tspesifik sama sekali. Ini dia:

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

Jadi, Anda dapat sepenuhnya menghapus semua variabel tipe dan hanya kode

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

Baik. Tapi mari kita kembali lebih dekat ke masalah aslinya. Variabel tipe pertama pada deklarasi kelas adalah redundan. Hanya metode kedua yang diperlukan. Kita mulai lagi, tetapi ini bukanlah jawaban terakhir:

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

Namun, semuanya terlalu ribut tentang apa-apa, karena versi berikut berfungsi dengan cara yang sama. Yang dibutuhkan hanyalah tipe antarmuka pada parameter metode. Tidak ada variabel tipe yang terlihat di mana pun. Apakah itu benar-benar masalah awal?

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

Karena variabel statis dibagikan oleh semua instance kelas. Misalnya jika Anda memiliki kode berikut

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

T tersedia hanya setelah sebuah instance dibuat. Tetapi metode statis dapat digunakan bahkan sebelum instance tersedia. Jadi, parameter tipe umum tidak dapat dirujuk di dalam metode dan variabel statis