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.
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.
0 komentar: