Thisismyhomework's Blog

pemograman generic pada Smalltalk,C++ dan Java

Posted on: April 17, 2010

  • Pemrograman Generik pada Smalltalk

Smalltalk adalah salah satu bahasa pemrograman berorientasi objek pertama. Bahasa ini masih digunakan hingga kini. Meskipun tidak menjadi sepopuler Java atau C++, bahasa ini adalah sumber ide yang diadopsi banyak bahasa pemrograman. Pada Smalltalk, pada dasarnya semua pemorgraman adalah generik, karena dua sifat bahasa ini.

Pertama, variabel pada Smalltalk tidak memiliki tipe. Suatu nilai memiliki tipe, seperti integer atau string, tetapi variabel tidak memiliki nilai. Suatu variabel bisa menampung jenis data apa saja. Parameter juga tidak memiliki tipe, sehingga subrutin bisa digunakan pada parameter apa saja. Demikian juga dengan struktur data bisa menampung data apa saja. Misalnya, sekali kita mendefinisikan struktur data pohon biner pada Smalltalk, kita bisa menggunakannya untuk integer, string, tanggal, atau data apa saja. Kita tidak perlu menulis kode baru untuk masing-masing tipe data.

Kedua, semua nilai adalah objek, dan semua operasi pada objek dilakukan dengan metode dalam kelas. Hal ini juga berlaku bahkan untuk tipe data primitif seperti integer. Ketika operator “+” digunakan untuk menjumlah integer, operasi ini dilakukan dengan memanggil metode pada kelas integer. Ketika kita membuat kelas baru, kita bisa membuat operator “+” sendiri kemudian kita bisa menjumlahkan dua objek dengan tipe kelas tersebut dengan menggunakan “a + b” seperti kita menjumlahkan angka seperti biasa.

Sekarang misalnya kita membuat subrutin baru yang menggunakan operator “+” untuk menjumlahkan masing-masing item di dalam list. Subtuin ini bisa digunakan untuk list integer, tapi juga bisa digunakan ke tipe data apapun yang mendefinisikan “+”. Demikian juga dengan subrutin yang menggunakan operator “<” untuk mengurutkan list juga bisa digunakan untuk list yang mengandung tipe data apapun yang memiliki definisi “<“. Kita tidak perlu menulis subrutin pengurutan untuk masing-masing tipe data.

Jika kedua fitur ini kita gabungkan, kita bisa memiliki bahasa di mana struktur data dan algoritmanya akan bekerja untuk jenis tipe data apapun (yang masuk akal), yaitu jika operasi yang sesuai telah didefinisikan. Inilah yang merupakan pemrograman generik yang sesungguhnya.

Mungkin ini terdengar sangat baik, dan Anda mungkin bertanya-tanya kenapa tidak semua bahasa pemrograman bekerja seperti ini. Kebebasan pemrograman seperti ini akan memudahkan kita membuat program, akan tetapi akan lebih sulit untuk membuat program yang benar dan tangguh.

Sekali kita membuat struktur data yang bisa menampung tipe data apa saja, akan sulit untuk menjamin ia bisa menampung tipe data yang kita inginkan. Jika kita ingin suatu subrutin mengurutkan tipe data apapun, maka akan sangat sulit untuk menjamin bahwa subrutin ini hanya digunakan untuk data di mana operator “<” telah didefinisikan. Lebih khusus, kompiler tidak bisa memastikannya. Masalah ini akan muncul di saat program dijalankan ketika kita mencoba untuk menjalankan operasi tertentu pada suatu tipe data yang belum ada, kemudian program akan crash.

  • Pemrograman Generik pada C++

Tidak seperti Smalltalk, C++ adalah bahasa pemrograman dengan tipe kuat, bahkan lebih kuat dari Java. Setiap variabel memiliki tipe, dan hanya bisa menampung tipe data itu saja. Artinya pemrograman generik seperti pada Smalltalk tidak mungkin diterapkan.

Lebih Jauh, C++ tidak memiliki sesuatu yang mirip dengan kelas Object pada Java. Artinya, tidak ada kelas yang merupakan kelas super dari semua kelas. Artinya C++ tidak bisa menggunakan pemrograman generik seperti Java.

Akan tetapi, C++ memiliki sistem pemrograman geneik yang canggih dan fleksibel, yaitu yang disebut template. Dalam C++, kita tidak membuat subrutin pengurutan yang berbeda untuk setiap tipe data. Akan tetapi kita bisa mmebuat template subrutin. Template ini bukan subrutin; akan tetapi mirip seperti pabrik pembuat subrutin. Kita lihat contoh berikutnya, karena sintaks C++ mirip dengan Java :

template<class TipeItem>

void urut( TipeItem A[], int banyak ) {

// Urut banyak item dalam array A, ke dalam urutan menaik

// Algoritma yang digunakan adalah pengurutan pilihan

for (int i = banyak-1; i > 0; i–) {

int posisi_maks = 0;

for (int j = 1; j <= banyak; j++)

if ( A[j] > A[posisi_maks] )

posisi_maks = j;

TipeItem temp = A[banyak];

A[banyak] = A[posisi_maks];

A[posisi_maks] = temp;

}

}

Dalam kode di atas, kita mendefinisikan template subrutin. Jika kita menghapus baris pertama, yaitu template<class TipeItem>”, dan mengganti kata “TipeItem” dengan “int”, pada semua isi template, maka kita bisa mendapatkan subrutin untuk mengurut array int. (Meskipun kita tulis seperti “class TipeItem”, kita bisa menggantinya dengan tipe apapun, termasuk tipe primitif). Jika kita mengganti “TipeItem” dengan string, maka kita bisa mendapatkan subrutin untuk mengurut array string. Ini yang sebenarnya dilakukan oleh compiler.

Jika program kita menyebut “urut(list,10)” di mana list adalah array int, maka kompiler menggunakan template ini untuk membuat subrutin untuk mengurut array int. Jika kita sebut “urut(kartu,10)” di mana kartu adalah array objek bertipe Kartu, maka kompiler akan membuat subrutin untuk mengurutkan array Kartu.

Template di atas menggunakan operator “>” untuk membandingkan nilai. Jika operator ini didefinisikan untuk nilai bertipe Kartu, maka kompiler akan menggunakan template dengan sukses. Jika “>” tidak didefinisikan untuk kelas Kartu, maka kompiler akan gagal, akan tetapi ini akan terjadi pada saat program dikompilasi bukan seperi Smalltalk di mana program akan crash pada saat dijalankan.

C++ juga memiliki template untuk membuat kelas. Jika kita menulis template untuk pohon biner, kita bisa menggunakan template itu untuk membuat kelas pohon biner int, pohon biner string, pohon biner tanggal, dan seterusnya — semua dari satu template. Versi paling baru C++ memiliki template bawaan yang cukup komplit yang disebut dengan Pustaka Template Standar (Standard Template Library atau STL). STL sendiri cukup kompleks, dan bahkan beberapa orang mengatakan sangat amat kompleks. Akan tetapi ini juga fitur paling menarik dari C++

  • Pemograman generic pada Java

Seperti pada C++, Java adalah bahasa bertipe kuat. Akan tetapi, pemrograman generik pada Java lebih dekat dengan Smalltalk daripada C++. Seperti telah dijelaskan sebelumnya, pemrograman generik pada Java berdasarkan pada kelas Object yang merupakan kelas super dari semua kelas. Hingga tingkat tertentu, ini membuat Java mirip dengan Smalltalk : Struktur data yang didesain untuk menampung Object bisa digunakan untuk menyimpan data kelas apapun. Kita tidak perlu membuat template atau fitur pada bahasa pemrograman lain untuk mendukung pemrograman generik.

Tentunya, tipe primitif, seperti integer, bukan objek pada Java, dan karenanya tidak bisa disimpan dalam tipe data generik. Dan sebenarnya, tidak ada cara untuk melakukan pemrograman generik dengan tipe data primitif pada Java. Pendekatan Smalltalk tidak bisa diterapkan pada Java kecuali untuk objek, dan pendekatan C++ tidak tersedia pada Java.

Lebih jauh, subrutin generik lebih bermasalah pada Java daripada Smalltalk atau C++. Pada Smalltak, subrutin dapat dipanggil dengan parameter bertipe apapun, dan akan bekerja asalkan operator yang digunakan pada subrutin didefinisikan pada parameternya.

Pada Java, parameter suatu subrutin harus bertipe tertentu. Dan subrutin hanya bisa menggunakan operasi untuk tipe itu saja. Subrutin dengan parameter Object bisa digunakan untuk objek tipe apa saja, akan tetapi subrutin hanya bisa menggunakan operasi pada kelas Object saja, dan sebenarnya hanya sedikit operasi pada kelas Object! Misalnya tidak ada operasi pembanding pada kelas Object, jadi kita tidak bisa membuat algoritma pengurutan generik. Kita akan lihat bagaimana Java menyelesaikan masalah ini.

Karena masalah seperti ini, beberapa orang menyatakan bahwa Java tidak mendukung pemrograman generik secara keseluruhan. Beberapa orang lain tidak setuju. Akan tetapi, tetap saja ini tidak menghambat Java untuk digunakan secara luas.

  • Perbedaan antara pemograman generic pada java dan C++

Java Generics yang secara besar-besaran berbeda dengan C + + template.

Pada dasarnya di C + + template pada dasarnya yang dimuliakan preprocessor / makro set (Catatan: karena beberapa orang tampaknya tidak dapat memahami suatu analogi, aku tidak mengatakan pengolahan template adalah makro). Di Jawa pada dasarnya mereka sintaksis gula untuk meminimalkan boilerplate Pemungutan Objek. Menjelaskan mengenai hal ini: ketika Anda menggunakan C + + template, Anda pada dasarnya membuat salinan lain kode, sama seperti jika Anda menggunakan #define makro. Hal ini memungkinkan Anda untuk melakukan hal-hal seperti memiliki int parameter dalam definisi template yang menentukan ukuran dari array dan semacamnya.

Java tidak bekerja seperti itu. Di Jawa semua objek sejauh java.lag.object begitu, pra-Generics, Anda akan menulis kode seperti ini:

public class PhoneNumbers {
private Map phoneNumbers = new HashMap();
public String getPhoneNumber(String name) {
return (String)phoneNumbers.get(name);
}

}

karena semua jenis koleksi Jawa digunakan sebagai basis mereka Obyek jenis sehingga Anda bisa memasukkan apa pun di dalamnya. Java 5 gulung sekitar dan menambah generik sehingga Anda dapat melakukan hal-hal seperti:

public class PhoneNumbers {
private Map<String, String> phoneNumbers = new HashMapString, String>();
public String getPhoneNumber(String name) {
return phoneNumbers.get(name);
}

}

Dan itu semua Java Generics adalah: pembungkus untuk casting objek. Itu karena Java Generics tidak tereifikasi. Mereka menggunakan tipe penghapusan. Keputusan ini diambil karena Generics Jawa datang terlambat dalam lembaran bahwa mereka tidak ingin menghancurkan kompatibilitas ke belakang (a Map<String, String> yang digunakan setiap kali Map disebut untuk). Bandingkan dengan. Net / C # di mana penghapusan jenis sedang tidak digunakan, yang mengarah pada segala macam perbedaan (misalnya anda dapat menggunakan tipe primitif dan IEnumerable dan IEnumerable<T> tidak ada hubungannya dengan satu sama lain).

Dan kelas generik menggunakan dikompilasi dengan Java 5 + compiler tidak dapat digunakan JDK 1,4 (dengan asumsi tidak menggunakan fitur ohter atau kelas yang membutuhkan Java 5 +).

Itu sebabnya Java Generics disebut sintaksis gula

Namun keputusan ini mengenai cara melakukan generik memiliki efek yang mendalam sedemikian rupa sehingga (yang hebat) java generic FAQ telah bermunculan untuk menjawab banyak pertanyaan orang tentang Generics Java.

C + + template memiliki sejumlah fitur yang tidak Generics Java:

  • Penggunaan tipe primitif argumen.

Contoh:

template<class T, int i>
class Matrix {
int T[i][i];

}

  • Penggunaan jenis argument default yang merupakan salah satu fitur Aku rindu di Java tetapi ada kompatibilitas mundur alasan untuk ini;
  • C + + memungkinkan penggunaan tipe primitif argumen, tidak Java, dan
  • Java memungkinkan argumen melompat-lompat.

Contoh:

public class ObservableList<T extends List> {

}

Banyak dari apa yang akan anda pelajari saat Java laerning semua pustaka (baik standar – apa yang datang dalam JDK – dan tidak standar, yang biasa digunakan mencakup hal-hal seperti Spring). Sintaks java lebih verbose daripada C + + sintaks dan tidak memiliki banyak fitur C + + (misalnya operator overloading, mutliple warisan, mekanisme destructor, dll) tapi itu tidak benar-benar membuatnya menjadi bagian dari C + + baik.

Sumber

http://java.lyracc.com

http://id.how-to.mobi/index.php?id=36347

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

universitas gunadarma

Twitter Updates

%d bloggers like this: