Memahami Penggunaan Keyword Super Pada Pemrograman Java

Sebelumnya anda sudah mengetahui mengenai keyword this sebagai rujukan untuk objek yang dipanggil. Sedangkan keyword super akan mengacu pada superclass.

Ketika suatu sub class mendapatkan pewarisan data fields yang sanggup diakses dan method-methodnya dari superclass, apakah constructor dari super class juga akan ikut di wariskan pada sub class tersebut?

Apakah constructor dari super class sanggup dipanggil melalui sub class?

Nah, fungsi dari keyword super itu sendiri adalah:

• Memanggil constructor dari superclass


• Memanggil method dari superclass


• Mengakses variabel instance super class

Pada pembahasan kali ini akan dijelaskan mengenai fungsi dari keyword super tersebut.

a. Memanggil Conctructor Dari Superclass

Constructor dipakai untuk membentuk instance dari suatu class. Namun, tidak menyerupai properti dan method, constructor ini tidak diwariskan pada subclass.

Sehingga constructor dari subclass ini hanya sanggup dipanggil melalui constructor dari sub class dengan memakai keyword super.

Syntax nya adalah:

• super()
  Akan memanggil constructor tanpa argumen dari superclass


• super(parameter)
  Memanggil constructor dari superclass yang mempunyai argumen-argumen yang sesuai.

Pernyataan super() ataupun super(parameter) harus ditempatkan pertama kali di dalam constructor dari sub class.

Dan ini ialah satu-satunya cara untuk memanggil constructor super class melalui subclass.

Contoh:

import java.util.Date;  //Class Benda sebagai super class public class Benda {       private Date tanggalDibuat;  private String warna = "Merah";  private boolean terisiWarna;    //Constructor  public Benda(Date tanggalDibuat, String warna, boolean terisiWarna){      this.tanggalDibuat = tanggalDibuat;   this.warna = warna;   this.terisiWarna = terisiWarna;     }   //Method getter warna  public String getWarna() {   return warna;  }   //Method setter warna  public void setWarna(String warna) {   this.warna = warna;  }   //Method getter nilai boolean  //apakah terisi warna sepenuhnya atau tidak  public boolean isTerisiWarna() {   return terisiWarna;  }   //Method setter apakah terisi warna sepenuhnya atau tidak  public void setTerisiWarna(boolean terisiWarna) {   this.terisiWarna = terisiWarna;  }   //Method getter untuk tanggal dibentuk  public Date getTanggalDibuat() {   return tanggalDibuat;  }   } 

import java.util.Date;  //class Lingkaran sebagai sub class dari Benda public class Lingkaran extends Benda {    private double jari_jari;    //Method menghitung luas bulat  double hitungLuas(){   final double PHI = 3.14;   double luasLingkaran = PHI * (jari_jari * jari_jari);   return luasLingkaran;  }    //Constructor class Lingkaran  public Lingkaran(double jari_jari){   /*class Lingkaran memanggil constructor     dari superclass-nya yaitu class Benda     memakai keyword super    */   super(new Date(), "Merah", true);   this.jari_jari= jari_jari;  }    public static void main (String args []){      //Membuat objek bulat   Lingkaran bulat = new Lingkaran(5.45);      System.out.println("Tanggal bulat dibentuk ialah " + lingkaran.getTanggalDibuat()   + "\nWarna bulat ialah " + lingkaran.getWarna() + "\nApakah lingkaran"   + " terisi sepenuhnya dengan warna " + lingkaran.getWarna() +"? " + lingkaran.isTerisiWarna()   + "\nLuas bulat ialah " + lingkaran.hitungLuas());     }  } 

Contoh output:
Tanggal bulat dibentuk ialah Sun Oct 29 12:08:21 SGT 2017
Warna bulat ialah Merah
Apakah bulat terisi sepenuhnya dengan warna Merah? true
Luas bulat ialah 93.26585

Konstruktor Berantai

Suatu constructor sanggup memanggil constructor overload atau juga constructor dari super class. Jika tidak ada pemanggilan yang dilakukan secara eksplisit, maka secara otomatis compiler akan meletakkan super() pada pernyataan pertama dalam konstruktor.

Misalnya:

public class A {     //Default constructor oleh compiler  public A(){      }     /*   Equivalen dengan :   public A(){   super();   }   */     //Constructor ke-1  public A(String string){   System.out.println(string);  }    /*   Equivalen dengan :   public A(String string){   super();   System.out.println(string);   }    */   } 

Dalam perkara apapun, dikala pengkonstruksian suatu instance telah dilakukan, maka constructor-constructor dari superclass-nya yang terkait dalam rantai inheritance akan dipanggil.

Ketika suatu objek dikonstruksi pada subclass maka constructor dari subclass itu pertama-tama akan memanggil constructor dari superclass-nya sebelum melaksanakan tugasnya sendiri.

Jika superclass-nya juga inherit dari class lainnya,  maka constructor dari superclass itu akan memanggil contructor dari superclassnya juga sebelum melaksanakan tugasnya sendiri.

Proses ini terus berlanjut hingga dengan constructor yang terakhir pada hirarki inheritance, dan ini disebut constructor chaining.

Perhatikan pola dibawah ini untuk memahaminya:

public class Orang {  //Constructor  public Orang(){  System.out.println("(1) Melakukan kiprah Orang");  }  } 

//Class Siswa inherit dari class Orang public class Siswa extends Orang {  //Constructor pertama  public Siswa(){   /*    Keyword this sanggup dipakai untuk memanggil constructor    pada class yang sama    */      this("(2) Memanggil overloaded constructor dari class Siswa\n");   System.out.println("(3) Melakukan kiprah Siswa");  }    //Constructor kedua  public Siswa(String myString){   System.out.print(myString);  }  } 

//Class SiswaSLTA inherit dari class Siswa public class SiswaSLTA extends Siswa {  //Constructor  public SiswaSLTA(){   System.out.println("(4) Menjalankan kiprah Siswa SLTA");  }    //main method  public static void main(String[] args) {    //Mengkonstruksi objek Siswa SLTA    new SiswaSLTA();  } } 

Output:
(1) Melakukan kiprah Orang
(2) Memanggil overloaded constructor dari class Siswa
(3) Melakukan kiprah Siswa
(4) Menjalankan kiprah Siswa SLTA

b. Memanggil Method Milik Superclass

Keyword super sanggup dipakai sebagai rujukan method selain dari constructor dalam superclass. Syntax-nya adalah:

super.method(parameters);

Contoh:

//Class Binatang sebagai superclass public class Binatang {    void bersuara(){   System.out.println("Binatang bersuara");  }  } 

//Class Ayam inherit dari class Binatang public class Ayam extends Binatang {    void berlari(){   System.out.println("Ayam berlari");  }    void bersuara(){   System.out.println("Kukuruyuk");  }    void berperilaku(){   //memanggil method bersuara() milik class Binatang   super.bersuara();   berlari();  }    public static void main(String[] args) {      Ayam ayam = new Ayam();   ayam.berperilaku();  } } 

Output:
Binatang bersuara
Ayam berlari

Pada pola diatas Binatang dan Ayam mempunyai method yang sama, yaitu bersuara(). Jika objek Ayam memanggil method bersuara(), harusnya output yang keluar ialah "Kukuruyuk". Namun, alasannya ialah keyword super digunakan, maka method yang dipanggil ialah milik super class. Oleh alasannya ialah itu outputnya ialah "Binatang bersuara".

c. Digunakan Untuk Mengacu Secara Langsung Pada Variabel Instance Milik Super Class

Anda sanggup memakai keyword super untuk eksklusif mengakses data member atau field dari super class. Dan ini dipakai kalau supe class dan sub class mempunyai field-field yang sama.

Contoh:

public class Benda {       String warna = "Hijau";   } 

public class Kotak extends Benda {    String warna = "Kuning";    void tampilkanWarna(){      System.out.println("Warna kotak ialah " + warna);      //Mengakses variabel instance warna dari super class Benda   System.out.println("Warna benda ialah " + super.warna);  }    public static void main(String[] args) {      Kotak kotak = new Kotak();   kotak.tampilkanWarna();     }  } 

Outout:
Warna kotak ialah Kuning
Warna benda ialah Hijau

Demikianlah beberapa fungsi penggunaan keyword super pada pemrograman Java. Semoga sanggup membantu anda yang sedang mencar ilmu Java.

Bagikan Artikel ini