Apa yang keren tentang obat generik, mengapa menggunakannya?

Saya pikir saya akan menawarkan softball ini kepada siapa pun yang ingin memukulnya keluar dari taman. Apa itu obat generik, apa kelebihan obat generik, mengapa, dimana, bagaimana cara menggunakannya? Harap pertahankan agar cukup mendasar. Terima kasih.

• Memungkinkan Anda untuk menulis kode / menggunakan metode pustaka yang tipe-aman, yaitu Daftar <string> dijamin menjadi daftar string.
• Sebagai hasil dari penggunaan generik, kompilator dapat melakukan pemeriksaan waktu kompilasi pada kode untuk keamanan tipe, misalnya apakah Anda mencoba memasukkan int ke dalam daftar string itu? Menggunakan ArrayList akan menyebabkan kesalahan waktu proses menjadi kurang transparan.
• Lebih cepat daripada menggunakan objek karena ini menghindari boxing / unboxing (di mana .net harus mengubah tipe nilai menjadi tipe referensi atau sebaliknya ) atau mentransmisikan dari objek ke tipe referensi yang diperlukan.
• Memungkinkan Anda untuk menulis kode yang dapat diterapkan ke banyak jenis dengan perilaku dasar yang sama, yaitu Dictionary <string, int> menggunakan kode dasar yang sama sebagai Dictionary <DateTime, double>; menggunakan obat generik, tim kerangka kerja hanya perlu menulis satu bagian kode untuk mencapai kedua hasil dengan keuntungan yang disebutkan di atas juga.

Saya benar-benar benci untuk mengulang. Saya benci mengetik hal yang sama lebih sering daripada yang seharusnya. Saya tidak suka mengulang beberapa kali dengan sedikit perbedaan.

Daripada membuat:

class MyObjectList  {
   MyObject get(int index) {...}
}
class MyOtherObjectList  {
   MyOtherObject get(int index) {...}
}
class AnotherObjectList  {
   AnotherObject get(int index) {...}
}

Saya dapat membuat satu kelas yang dapat digunakan kembali ... (dalam kasus di mana Anda tidak ingin menggunakan koleksi mentah karena suatu alasan)

class MyList<T> {
   T get(int index) { ... }
}

Saya sekarang 3x lebih efisien dan saya hanya perlu menyimpan satu salinan. Mengapa Anda TIDAK ingin mempertahankan lebih sedikit kode?

Ini juga berlaku untuk kelas non-koleksi seperti a Callable<T>atau Reference<T>yang harus berinteraksi dengan kelas lain. Apakah Anda benar-benar ingin memperluas Callable<T>dan Future<T>dan setiap kelas terkait lainnya untuk membuat versi yang aman bagi tipe?

Bukan saya.

Tidak perlu typecast adalah salah satu keuntungan terbesar dari generik Java , karena ia akan melakukan pemeriksaan jenis pada waktu kompilasi. Ini akan mengurangi kemungkinanClassCastException yang dapat dilemparkan saat runtime, dan dapat menghasilkan kode yang lebih kuat.

Tetapi saya curiga Anda sepenuhnya menyadarinya.

Setiap kali saya melihat Generik, itu membuat saya pusing. Saya menemukan bagian terbaik dari Java adalah kesederhanaannya dan sintaksis minimal dan generik tidak sederhana dan menambahkan sejumlah besar sintaks baru.

Pada awalnya, saya juga tidak melihat manfaat obat generik. Saya mulai belajar Java dari sintaks 1.4 (meskipun Java 5 keluar pada saat itu) dan ketika saya menemukan generik, saya merasa lebih banyak kode untuk ditulis, dan saya benar-benar tidak mengerti manfaatnya.

IDE modern membuat penulisan kode dengan generik lebih mudah.

IDE yang paling modern dan layak cukup pintar untuk membantu menulis kode dengan obat generik, terutama dengan penyelesaian kode.

Berikut contoh pembuatan Map<String, Integer>dengan a HashMap. Kode yang harus saya ketik adalah:

Map<String, Integer> m = new HashMap<String, Integer>();

Dan memang, banyak sekali mengetik hanya untuk membuat yang baru HashMap. Namun, pada kenyataannya, saya hanya perlu mengetik sebanyak ini sebelum Eclipse tahu apa yang saya butuhkan:

Map<String, Integer> m = new Ha Ctrl+Space

Benar, saya memang perlu memilih HashMapdari daftar kandidat, tetapi pada dasarnya IDE tahu apa yang harus ditambahkan, termasuk tipe generik. Dengan alat yang tepat, menggunakan obat generik tidak terlalu buruk.

Selain itu, karena jenisnya diketahui, saat mengambil elemen dari koleksi generik, IDE akan bertindak seolah-olah objek tersebut sudah menjadi objek dari jenis yang dideklarasikan - tidak perlu melakukan casting agar IDE mengetahui jenis objek tersebut. adalah.

Keuntungan utama dari obat generik berasal dari cara kerjanya yang baik dengan fitur Java 5 yang baru. Berikut adalah contoh melempar bilangan bulat ke a Setdan menghitung totalnya:

Set<Integer> set = new HashSet<Integer>();
set.add(10);
set.add(42);

int total = 0;
for (int i : set) {
  total += i;
}

Dalam potongan kode itu, ada tiga fitur Java 5 baru yang ada:

• Generik
• Autoboxing dan unboxing
• Untuk setiap loop

Pertama, generik dan autoboxing primitif memungkinkan baris berikut:

set.add(10);
set.add(42);

Integer di 10-autobox menjadi sebuah Integerdengan nilai 10. (Dan sama untuk 42). Kemudian yang Integerdilemparkan ke dalam Setyang dikenal dengan Integers. Mencoba memasukkan Stringakan menyebabkan kesalahan kompilasi.

Selanjutnya, for-each loop mengambil ketiga dari itu:

for (int i : set) {
  total += i;
}

Pertama, s yang Setberisi Integerdigunakan dalam for-each loop. Setiap elemen dideklarasikan sebagai sebuah intdan yang diizinkan saat Integerdikembalikan ke kotak primitif int. Dan fakta bahwa unboxing ini terjadi diketahui karena obat generik digunakan untuk menentukan bahwa ada yang Integerdisimpan di fileSet .

Generik bisa menjadi perekat yang menyatukan fitur-fitur baru yang diperkenalkan di Java 5, dan itu membuat pengkodean lebih sederhana dan lebih aman. Dan sebagian besar waktu IDE cukup pintar untuk membantu Anda dengan saran yang bagus, jadi umumnya, itu tidak akan lebih banyak mengetik.

Dan terus terang, seperti yang bisa dilihat dari Set contoh, saya merasa bahwa memanfaatkan fitur Java 5 dapat membuat kode lebih ringkas dan kuat.

Edit - Contoh tanpa obat generik

Berikut adalah ilustrasi Setcontoh di atas tanpa menggunakan obat generik. Itu mungkin, tetapi tidak terlalu menyenangkan:

Set set = new HashSet();
set.add(10);
set.add(42);

int total = 0;
for (Object o : set) {
  total += (Integer)o;
}

(Catatan: Kode di atas akan menghasilkan peringatan konversi yang tidak dicentang pada waktu kompilasi.)

Saat menggunakan koleksi non-generik, tipe yang dimasukkan ke dalam koleksi adalah tipe objek Object. Oleh karena itu, dalam contoh ini, a Objectadalah apa yang sedang adddiedit ke dalam himpunan.

set.add(10);
set.add(42);

Di baris di atas, autoboxing dalam bermain - primitif intnilai 10dan 42sedang autoboxed menjadi Integerobjek, yang sedang ditambahkan ke Set. Namun, perlu diingat, Integerobjek ditangani sebagai Objects, karena tidak ada informasi tipe untuk membantu kompilator mengetahui tipe apa yang Setdiharapkan.

for (Object o : set) {

Ini adalah bagian yang sangat penting. Alasan for-each loop berfungsi adalah karena antarmuka Setmengimplementasikan Iterable, yang mengembalikan Iteratorinformasi with type, jika ada. (Iterator<T> , itu.)

Namun, karena tidak ada informasi tipe, Setkehendak mengembalikan Iteratoryang akan mengembalikan nilai dalam Setas Objects, dan itulah mengapa elemen yang diambil di untuk-setiap loop harus berjenisObject .

Sekarang setelah Objectdiambil dari Set, itu perlu dilemparkan ke Integermanual untuk melakukan penambahan:

  total += (Integer)o;

Di sini, typecast dilakukan dari sebuah Objectke Integer. Dalam hal ini, kami tahu ini akan selalu berfungsi, tetapi typecasting manual selalu membuat saya merasa ini adalah kode yang rapuh yang dapat rusak jika perubahan kecil dilakukan di tempat lain. (Saya merasa bahwa setiap typecast ClassCastExceptionmenunggu untuk terjadi, tetapi saya ngelantur ...)

The Integerkini unboxed menjadi intdan memungkinkan untuk melakukan penambahan ke dalam intvariabel total.

Saya harap saya dapat mengilustrasikan bahwa fitur baru Java 5 dapat digunakan dengan kode non-generik, tetapi tidak sebersih dan langsung menulis kode dengan obat generik. Dan, menurut pendapat saya, untuk memanfaatkan sepenuhnya fitur-fitur baru di Java 5, kita harus melihat ke generik, jika paling tidak, memungkinkan pemeriksaan waktu kompilasi untuk mencegah typecast yang tidak valid membuang pengecualian saat runtime.

Jika Anda mencari database bug Java sebelum 1.5 dirilis, Anda akan menemukan tujuh kali lebih banyak bug dengan NullPointerExceptionthan ClassCastException. Jadi sepertinya bukan fitur yang bagus untuk menemukan bug, atau setidaknya bug yang tetap ada setelah sedikit pengujian asap.

Bagi saya, keuntungan besar dari obat generik adalah bahwa mereka mendokumentasikan informasi jenis kode yang penting. Jika saya tidak ingin informasi jenis itu didokumentasikan dalam kode, maka saya akan menggunakan bahasa yang diketik secara dinamis, atau setidaknya bahasa dengan jenis inferensi yang lebih implisit.

Menyimpan koleksi objek untuk dirinya sendiri bukanlah gaya yang buruk (tetapi gaya yang umum adalah mengabaikan enkapsulasi secara efektif). Ini lebih tergantung pada apa yang Anda lakukan. Meneruskan koleksi ke "algoritme" sedikit lebih mudah untuk diperiksa (pada atau sebelum waktu kompilasi) dengan obat generik.

Generik di Java memfasilitasi polimorfisme parametrik . Melalui parameter tipe, Anda bisa meneruskan argumen ke tipe. Sama seperti metode seperti String foo(String s)memodelkan beberapa perilaku, tidak hanya untuk string tertentu, tetapi untuk string apa pun s, jadi tipe seperti List<T>memodelkan beberapa perilaku, tidak hanya untuk jenis tertentu, tetapi untuk jenis apa pun . List<T>mengatakan bahwa untuk semua tipe T, ada tipe Listyang elemennya adalah Ts . Jadi Listsebenarnya adalah tipe konstruktor . Ini mengambil tipe sebagai argumen dan membangun tipe lain sebagai hasilnya.

Berikut adalah beberapa contoh tipe generik yang saya gunakan setiap hari. Pertama, antarmuka umum yang sangat berguna:

public interface F<A, B> {
  public B f(A a);
}

Antarmuka ini mengatakan bahwa untuk dua jenis, Adan B, ada fungsi (disebut f) yang mengambil Adan mengembalikan a B. Saat Anda mengimplementasikan antarmuka ini, Adan Bbisa jenis apa pun yang Anda inginkan, selama Anda menyediakan fungsi fyang mengambil yang pertama dan mengembalikan yang terakhir. Berikut contoh implementasi antarmuka:

F<Integer, String> intToString = new F<Integer, String>() {
  public String f(int i) {
    return String.valueOf(i);
  }
}

Sebelum generik, polimorfisme dicapai dengan subclassing menggunakan extendskata kunci. Dengan obat generik, kita sebenarnya bisa menghilangkan subclass dan menggunakan polimorfisme parametrik sebagai gantinya. Misalnya, pertimbangkan kelas berparameterisasi (generik) yang digunakan untuk menghitung kode hash untuk semua jenis. Alih-alih menimpa Object.hashCode (), kita akan menggunakan kelas generik seperti ini:

public final class Hash<A> {
  private final F<A, Integer> hashFunction;

  public Hash(final F<A, Integer> f) {
    this.hashFunction = f;
  }

  public int hash(A a) {
    return hashFunction.f(a);
  }
}

Ini jauh lebih fleksibel daripada menggunakan pewarisan, karena kita bisa tetap menggunakan tema penggunaan komposisi dan polimorfisme parametrik tanpa mengunci hierarki yang rapuh.

Generik Java tidak sempurna. Anda bisa mengabstraksi tipe, tetapi Anda tidak bisa mengabstraksi konstruktor tipe, misalnya. Artinya, Anda dapat mengatakan "untuk semua tipe T", tetapi Anda tidak dapat mengatakan "untuk tipe T apa pun yang menggunakan parameter tipe A".

Saya menulis artikel tentang batasan generik Java ini, di sini.

Satu keuntungan besar dengan obat generik adalah mereka memungkinkan Anda menghindari subclass. Subclassing cenderung menghasilkan hierarki kelas yang rapuh yang canggung untuk diperluas, dan kelas yang sulit dipahami secara individual tanpa melihat seluruh hierarki.

Wereas sebelum generik Anda mungkin memiliki kelas seperti Widgetdiperpanjang oleh FooWidget, BarWidget, dan BazWidget, dengan obat generik Anda bisa memiliki kelas generik tunggal Widget<A>yang membutuhkan Foo, Baratau Bazdalam konstruktor untuk memberikan Widget<Foo>, Widget<Bar>dan Widget<Baz>.

Generik menghindari pukulan kinerja tinju dan unboxing. Pada dasarnya, lihat ArrayList vs List <T>. Keduanya melakukan hal inti yang sama, tetapi List <T> akan jauh lebih cepat karena Anda tidak perlu melakukan box ke / dari objek.

Manfaat terbaik untuk Generics adalah penggunaan kembali kode. Katakanlah Anda memiliki banyak objek bisnis, dan Anda akan menulis kode yang SANGAT mirip untuk setiap entitas untuk melakukan tindakan yang sama. (IE Linq ke operasi SQL).

Dengan generik, Anda dapat membuat kelas yang akan dapat beroperasi dengan jenis apa pun yang mewarisi dari kelas dasar tertentu atau mengimplementasikan antarmuka yang diberikan seperti:

public interface IEntity
{

}

public class Employee : IEntity
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int EmployeeID { get; set; }
}

public class Company : IEntity
{
    public string Name { get; set; }
    public string TaxID { get; set }
}

public class DataService<ENTITY, DATACONTEXT>
    where ENTITY : class, IEntity, new()
    where DATACONTEXT : DataContext, new()
{

    public void Create(List<ENTITY> entities)
    {
        using (DATACONTEXT db = new DATACONTEXT())
        {
            Table<ENTITY> table = db.GetTable<ENTITY>();

            foreach (ENTITY entity in entities)
                table.InsertOnSubmit (entity);

            db.SubmitChanges();
        }
    }
}

public class MyTest
{
    public void DoSomething()
    {
        var dataService = new DataService<Employee, MyDataContext>();
        dataService.Create(new Employee { FirstName = "Bob", LastName = "Smith", EmployeeID = 5 });
        var otherDataService = new DataService<Company, MyDataContext>();
            otherDataService.Create(new Company { Name = "ACME", TaxID = "123-111-2233" });

    }
}

Perhatikan penggunaan kembali layanan yang sama dengan jenis yang berbeda dalam metode DoSomething di atas. Benar-benar elegan!

Ada banyak alasan bagus lainnya untuk menggunakan obat generik untuk pekerjaan Anda, ini adalah favorit saya.

Saya suka mereka karena mereka memberi Anda cara cepat untuk menentukan jenis kustom (seperti yang saya gunakan).

Jadi misalnya, alih-alih mendefinisikan struktur yang terdiri dari string dan integer, lalu harus mengimplementasikan seluruh kumpulan objek dan metode tentang cara mengakses array dari struktur tersebut dan seterusnya, Anda cukup membuat Dictionary

Dictionary<int, string> dictionary = new Dictionary<int, string>();

Dan compiler / IDE melakukan tugas berat lainnya. Kamus khususnya memungkinkan Anda menggunakan tipe pertama sebagai kunci (tidak ada nilai yang berulang).

• Koleksi yang diketik - bahkan jika Anda tidak ingin menggunakannya, kemungkinan besar Anda harus menanganinya dari perpustakaan lain, sumber lain.

• Pengetikan umum dalam pembuatan kelas:

  kelas publik Foo <T> {publik T get () ...

• Menghindari casting - Saya selalu tidak menyukai hal-hal seperti

  Pembanding baru {public int bandingkanTo (Object o) {if (o instanceof classIcareAbout) ...

Di mana Anda pada dasarnya memeriksa kondisi yang seharusnya hanya ada karena antarmuka diekspresikan dalam bentuk objek.

Reaksi awal saya terhadap obat generik mirip dengan Anda - "terlalu berantakan, terlalu rumit". Pengalaman saya adalah bahwa setelah menggunakannya sebentar Anda akan terbiasa dengan mereka, dan kode tanpa mereka terasa kurang jelas ditentukan, dan hanya kurang nyaman. Selain itu, seluruh dunia java menggunakannya sehingga Anda harus mengikuti program pada akhirnya, bukan?

Generik juga memberi Anda kemampuan untuk membuat lebih banyak objek / metode yang dapat digunakan kembali sambil tetap memberikan dukungan khusus jenis. Anda juga mendapatkan banyak performa dalam beberapa kasus. Saya tidak tahu spesifikasi lengkapnya tentang Java Generics, tetapi di .NET saya dapat menentukan batasan pada parameter Type, seperti Menerapkan Antarmuka, Pembuat, dan Turunan.

1. Mengaktifkan pemrogram untuk mengimplementasikan algoritme generik - Dengan menggunakan algoritme generik, pemrogram dapat mengimplementasikan algoritme generik yang bekerja pada kumpulan jenis berbeda, dapat disesuaikan, dan aman untuk tipe serta lebih mudah dibaca.

2. Pemeriksaan jenis yang lebih kuat pada waktu kompilasi - Pengompilasi Java menerapkan pemeriksaan jenis yang kuat ke kode umum dan mengeluarkan kesalahan jika kode tersebut melanggar keamanan jenis. Memperbaiki kesalahan waktu kompilasi lebih mudah daripada memperbaiki kesalahan waktu proses, yang mungkin sulit ditemukan.

3. Penghapusan gips.