TUGAS ESSAY

MATA KULIAH OBJECT ORIENTED PROGRAMMING

KONSEP DASAR POLYMORPHISM

DALAM JAVA

NPM : P31.2009.00680

NAMA : ADHITYA PRAMESWARA

ANGKATAN / KELAS : XVI / WEEKEND

MATA KULIAH : OBJECT ORIENTED PROGRAMMING

DOSEN : HENDRO SUBAGYO, M. Eng

MAGISTER TEKNIK INFORMATIKA

PASCA SARJANA

UNIVERSITAS DIAN NUSWANTORO SEMARANG

2010
 KONSEP DASAR POLYMORPHISM DALAM JAVA

Polymorphism adalah salah satu dari tiga kemampuan yang mendasar yang dimiliki oleh OOP,
setelah data abstraction dan inheritance.

Polymorphism menyediakan cara yang berbeda pada pemisahan interface dari implementasinya,
untuk memasangkan ulang apa dari bagaimana. Polymorphism memberikan organisasi kode
yang lebih baik dan kode menjadi lebih mudah dibaca, juga memberikan suatu kemampuan pada
program untuk berkembang secara terus menerus baik pada tahap pengembangan awal ataupun
pada saat ingin menambahkan kemampuan-kemampuan yang baru.

Encapsulation membuat tipe data yang baru dengan mengkombinasikan karakteristik-

karakteristik dan perilaku-perilaku. Dengan menggunakan kata kunci private kita dapat
menyembunyikan interface dari implementasi. Cara yang seperti ini dapat memudahkan para
programmer yang mempunyai background prosedural. Tetapi polymorphism menangani
decoupling dalam bentuk types. Kita mengetahui kalau inheritance memperbolehkan perlakuan
yang sama pada object turunan maupun object asal. Kemampuan ini sangat penting karena
memperbolehkan beberapa tipe yang ada (turunan dari tipe asal yang sama) mendapat perlakuan
seperti kalau mereka itu satu tipe, dan hanya dibutuhkan satu kode saja untuk mengakses
keseluruhan tipe yang ada. Metode polymorphism ini memperbolehkan untuk memanggil satu
tipe untuk mengekspresikan perbedaannya dari tipe yang lainnya, yang sejenis, selama mereka
diturunkan dari tipe asal yang sama. Perbedaan ini diekspresikan melalui perbedaan-perbedaan
dalam perilaku dari metoda-metoda yang dapat kita panggil dari class asal.

Dalam pembahasan ini kita akan menjelaskan tentang polymorphism (juga disebut sebagai
dynamic binding atau late binding atau run-time binding) mulai dari yang paling dasar, dengan
contoh yang membeberkan tentang pengaruh polymophism dalam program yang akan dibuat.

Sebelumnya kita mengetahui kalau sebuah object dapat digunakan sebagai tipenya sendiri atau
sebagai object dari tipe asalnya. Mengambil handle sebuah object dan memperlakukannya
sebagai handle dari tipe asal disebut sebagai upcasting karena urutan dari cabang-cabang
inheritance digambarkan class asal terletak yang paling atas.
Kita juga akan menemui sebuah masalah seperti yang tertera dari kode berikut ini:

//: Music.java

// Inheritance & upcasting

package c07;

class Note {
private int value;
private Note(int val) { value = val; }
public static final Note
middleC = new Note(0),
cSharp = new Note(1),
cFlat = new Note(2);
} // Etc.

class Instrument {
public void play(Note n) {
System.out.println(\"Instrument.play()\");
}
}

// Wind objects are instruments

// because they have the same interface:
class Wind extends Instrument {
// Redefine interface method:
public void play(Note n) {
System.out.println(\"Wind.play()\");
}
}

public class Music {

public static void tune(Instrument i) {
// ...
i.play(Note.middleC);
}
public static void main(String[] args) {
 Wind flute = new Wind();
tune(flute); // Upcasting
}
} ///:~

Metode diatas Music.tune() menerima sebuah handle Instrument, tetapi juga segala sesuatunya
yang diturunkan dari Instrument. Didalam main(), kita dapat melihat semua ini terjadi sebagai
sebuah handle Wind dilewatkan ke tune(), dengan tanpa cast sama sekali. Ini semua masih dapat
diterima, interface dari Instrument harus muncul didalam Wind, karena Wind diturunkkan dari
Instrument. Upcasting dari Wind ke Instrument bisa membuat “narrow” pada interface
tersebut, tapi semua ini tidak dapat mengurangi interface keseluruhan dari Instrument.

Program berikut ini mungkin akan tampak aneh. Mengapa kita secara sengaja melupakan tipe
dari sebuah object ? Ini semua dapat terjadi bila kita melakukan upcast, dan menjadikannya
kelihatan seperti kalau tune() secara langsung mengambil handle dari Wind sebagai sebuah
argumen. Ini semua membuat sesuatu yang mendasar : Kalau kita melakukannya, kita harus
menuliskan tune() yang baru untuk setiap Instrument didalam system kita. Anggap saja kita
mengikuti alasan ini dan menambahkan instrument Stringed dan Brass :

//: Music2.java
// Overloading instead of upcasting

class Note2 {
private int value;
private Note2(int val) { value = val; }
public static final Note2
middleC = new Note2(0),
cSharp = new Note2(1),
cFlat = new Note2(2);
} // Etc.

class Instrument2 {
public void play(Note2 n) {
System.out.println(\"Instrument2.play()\");
}
}

class Wind2 extends Instrument2 {

public void play(Note2 n) {
System.out.println(\"Wind2.play()\");
}
}

class Stringed2 extends Instrument2 {

public void play(Note2 n) {
System.out.println(\"Stringed2.play()\");
}
}

class Brass2 extends Instrument2 {

public void play(Note2 n) {
System.out.println(\"Brass2.play()\");
}
}

public class Music2 {

public static void tune(Wind2 i) {
i.play(Note2.middleC);
}
public static void tune(Stringed2 i) {
i.play(Note2.middleC);
}
public static void tune(Brass2 i) {
i.play(Note2.middleC);
}
public static void main(String[] args) {
Wind2 flute = new Wind2();
Stringed2 violin = new Stringed2();
Brass2 frenchHorn = new Brass2();
tune(flute); // No upcasting
tune(violin);
tune(frenchHorn);
 }
} ///:~

Kode diatas dapat dijalankan, tetapi disana ada kekurangan terbesar. Kita harus menuliskan
metoda tipe yang spesifik untuk setiap class Instrument2 yang baru kita tambahkan. Ini semua
berarti makin banyak kode yang akan kita tulis, tetapi juga berarti kalau kita ingin menambahkan
sebuah metoda baru seperti tune() atau sebuah tipe baru dari Instrument, kita mendapatkan
kalau perkerjaan kita makin banyak. Dengan menambahkan fakta bahwa kompiler tidak akan
memberikan pesan-pesan kesalahan kalau kita lupa meng overload salah satu dari metoda-
metoda kita dan seluruh proses pekerjaan dengan tipe menjadi tidak dapat ditangani.

Bukankah dapat menjadi lebih menyenangkan kalau kita hanya menuliskan satu metoda saja
yang dapat mengambil class asal sebagai argumennya, dan bukan dari semua class-class
turunannya. Itulah memang lebih memudahkan bila kita melupakan adanya class-class turunan,
dan menuliskan kode yang hanya berkomunikasi dengan class asal?

Itulah apa yang disediakan oleh polymorphism. Walau bagaimanapun kebanyakan programmer
(yang berasal dari latar belakang prosedural) mempunyai sedikit kesulitan untuk beradaptasi
dengan polymorphism.

Kesimpulan

Dengan polymorphism pekerjaan seorang programmer dapat dimudahkan dengan menuliskan

kode yang lebih sedikit. Untuk mengakses class-class turunan tidak dibutuhkan penulisan kode
yang berlainan.

Daftar Pustaka

• Bruce Eckel, Thinking in Java

• http://www.amazon.com/exec/obidos/tg/detail/-/0131002872...
• Jamie Jaworski, Java Developer\'s Guide
• http://www.amazon.com/exec/obidos/tg/detail/-/157521069X...
• Ady Wicaksono, Dasar-Dasar Pemrograman Java 2, Elex Media
Computindo
 • Arief Hamdani Gunawan, Filosofi Dasar Object dalam Object Oriented
Programming, RisTISHOP.com, 26 Juli 2004.
• http://www.ristishop.com/portal/portal_article_detail.php?id=235〈=

Diambil dari web :

http://www.ristinet.com/index.php?
ch=8&lang=&s=66f0e95bbb8284ac2e1ee7c1fe2b628b&n=246

Ditulis oleh :

Arief Hamdani Gunawan, engineer Lab. Solusi TI – R&D Center TELKOM

Diposting pada tanggal 14 Oktober 2004 - 05:09:21 PM