Polymorphism Dalam Berguru Bahasa Pemrograman Java

Apa Itu Polymorphism?

Ketika anda mencar ilmu bahasa pemrograman Java, memahami mengenai polymorphism sebagai salah satu konsep penting dari Java selain inheritance, abstraction dan encapsulation yaitu hal yang sangat penting.

Polymorphism artinya mempunyai banyak bentuk.

Polymorphism pada konsep Object Oriented Programming merupakan proses untuk merepresentasikan satu bentuk ke dalam banyak bentuk.

Ini mungkin terdengar sangat membingungkan, tapi dengan coding, semuanya akan jelas.

Untuk mudahnya, misalkan anda menulis isyarat menyerupai ini:

public class Manusia {      void makan(){     }    void tidur(){     }    void bergerak(){     }  } 

Pada isyarat di atas, objek Manusia sanggup melaksanakan 3 jenis kegiatan yaitu makan, tidur dan bergerak.

Namun, perlu diingat, kegiatan itu sanggup dilakukan juga oleh objek sub class dari class Manusia ataupun class apa saja yang di atasnya terdapat class Manusia yang terkait dalam hirarki inheritance.

Oke, selanjutnya perhatikan isyarat di bawah ini:

public class Siswa extends Manusia {   } 

public class Test {    public static void main(String[] args) {      Siswa siswa_A = new Siswa();     }  } 

Pada isyarat di atas, alasannya yaitu class Siswa extends dari class Manusia, maka siswa juga yaitu manusia, atau Siswa IS-A Manusia, dan objek siswa ini sanggup juga makan, tidur dan bergerak.

Kemudian ketika objek siswa dibentuk dengan pernyataan:

Siswa siswa_A = new Siswa();

Artinya, siswa_A merupakan variabel rujukan objek dengan tipe Siswa, demikian juga dengan objek yang dibentuk merupakan objek Siswa, dinyatakan dengan new Siswa();.

Namun, dengan polymorphism, tipe variabel rujukan objek dan tipe objek sanggup berbeda.

Contoh:

Manusia siswa_A = new Siswa();

Apa artinya?

Artinya, tipe variabel rujukan merupakan Manusia, sedangkan objek yang dibentuk yaitu tipe Siswa yang dinyatakan dengan new Siswa(). Dengan kata lain, ini yaitu dua tipe yang berbeda!.

Dengan memakai polymorphism maka tipe variabel rujukan dari tipe objek faktual sanggup memakai super class.

Perhatikan isyarat simpel yang terdiri dari beberapa class berikut ini, maka anda akan lebih memahami polymorphism.

//Superclass public class Manusia {      void makan(){   System.out.println("Manusia makan");  }    void tidur(){   System.out.println("Manusia tidur");  }    void bergerak(){   System.out.println("Manusia bergerak");  }  } 

public class Siswa extends Manusia {    @Override  void makan(){   System.out.println("Siswa makan");  }    @Override  void tidur(){   System.out.println("Siswa tidur");  }    @Override  void bergerak(){   System.out.println("Siswa bergerak");  }   } 

public class Karyawan extends Manusia {    @Override  void makan(){   System.out.println("Karyawan makan");  }    @Override  void tidur(){   System.out.println("Karyawan tidur");  }    @Override  void bergerak(){   System.out.println("Karyawan bergerak");  }  } 

public class Programmer extends Manusia{    @Override  void makan(){   System.out.println("Programmer makan");  }    @Override  void tidur(){   System.out.println("Programmer tidur");  }    @Override  void bergerak(){   System.out.println("Programmer bergerak");  }  } 

public class Professor extends Manusia {    @Override  void makan(){   System.out.println("Professor makan");  }    @Override  void tidur(){   System.out.println("Professor tidur");  }    @Override  void bergerak(){   System.out.println("Professor bergerak");  }  } 

//Class Test untuk mendemonstrasikan polymorphism public class Test {    public static void main(String[] args) {      //Mendeklarasikan array dengan tipe Manusia.   //Dengan kata lain sebagai array yang memegang objek dari   //tipe insan   Manusia [] insan = new Manusia [4];      //Perhatikan, anda sanggup menyimpan subclass apa saja dari   //tipe Manusia di dalam array Manusia.   manusia[0] = new Siswa();   manusia[1] = new Karyawan();   manusia[2] = new Programmer();   manusia[3] = new Professor();      //Sekarang, ketika anda melaksanakan loop   //terhadap array tersebut, dan memanggil method dari class Manusia   //maka setiap objek akan melaksanakan hal yang benar atau   //objek akan memakai method yang ada di classnya masing-masing!   for (int i = 0; i < manusia.length; i++){    manusia[i].makan();    manusia[i].tidur();    manusia[i].bergerak();    System.out.println();   }     }  } 

Output:

Siswa makan
Siswa tidur
Siswa bergerak

Karyawan makan
Karyawan tidur
Karyawan bergerak

Programmer makan
Programmer tidur
Programmer bergerak

Professor makan
Professor tidur
Professor bergerak

Perhatikanlah kekuatan polymorphism ini, hanya dengan sedikit kode, anda sanggup melaksanakan banyak hal. Dan teladan di atas yaitu merupakan array dari polymorphism.

Menggunakan Argumen Dan Tipe Return Polymorphic

Sesuai dengan pembahasan di atas, dengan polymorphism, anda sanggup mendeklarasikan variabel rujukan dari suatu super class, katakanlah class Manusia dan lalu menetapkan objek dari sub class contohnya class Siswa pada variabel rujukan tersebut.
Nah sekarang, apa yang terjadi kalau variabel rujukan itu yaitu merupakan argumen dari suatu method?

Perhatikan teladan isyarat simpel di bawah ini:

//Superclass public class Manusia {    void berlari(){   System.out.println("Manusia berlari");  }  } 

public class Siswa extends Manusia {    @Override  void berlari(){   System.out.println("Siswa berlari");  }   } 

public class Karyawan extends Manusia {    @Override  void berlari(){   System.out.println("Karyawan berlari");  }  }  

public class Programmer extends Manusia{    @Override  void berlari(){   System.out.println("Programmer berlari");  }  } 

public class Professor extends Manusia {    @Override  void berlari(){   System.out.println("Professor berlari");  }  } 

public class Beruang {    /*   Parameter Manusia sanggup mengambil tipe Manusia apapun sebagai argumen.   Dan ketika Beruang mengejar Manusia, maka akan memberi tahu Manusia supaya berlari.   */  void mengejar (Manusia manusia){   manusia.berlari();  }  } 

//Class Test untuk mendemonstrasikan polymorphism public class Test {    public static void main(String[] args) {      Beruang beruang = new Beruang();      Manusia [] insan = new Manusia [4];   insan [0] = new Siswa();   insan [1] = new Karyawan();   insan [2] = new Programmer();   insan [3] = new Professor();      System.out.println("Ketika beruang mengejar maka: " );      for (int i = 0; i < manusia.length ; i++){    /*     Method beruang mengejar() sanggup mendapatkan argumen dari tipe Manusia.     Selama objek yang anda pass-kan kedalam method tersebut inherit     atau sub class dari Manusia, maka method ini akan bekerja.     */    beruang.mengejar(manusia[i]);   }  }     } 

Output:
Ketika beruang mengejar maka:
Siswa berlari
Karyawan berlari
Programmer berlari
Professor berlari

Jadi, pada dikala runtime, kalau anda menulis isyarat memakai argumen polymorphic, di mana anda mendeklarasikan parameter pada method sebagai tipe super class, maka anda sanggup mem-pass-kan setiap objek dari sub class pada method tersebut.

Bagikan Artikel ini