Kelebihan Konstruktor masuk Java

Apa itu Constructor Overloading? Java?

Kelebihan Konstruktor masuk Java adalah teknik di mana sebuah kelas mendeklarasikan beberapa konstruktor yang berbeda dalam daftar parameternya. Kompilator membedakan konstruktor-konstruktor ini dengan menganalisis jumlah parameter dan tipe datanya.

Contoh konstruktor yang valid untuk kelas Akun ditunjukkan di bawah ini:

Account(int a);
Account (int a,int b);
Account (String a,int b);

Mengapa Kita Membutuhkan Overloading Konstruktor? Java?

Kelebihan Konstruktor masuk Java Meningkatkan fleksibilitas dan efisiensi kode dengan memungkinkan beberapa konstruktor dalam sebuah kelas, masing-masing dengan daftar parameter yang berbeda.

• Fleksibilitas dalam Pembuatan Objek: Overloading konstruktor memungkinkan Anda menginisialisasi objek dengan berbagai cara, tergantung pada jumlah atau jenis parameter.
• Code Dapat digunakan kembali: Anda dapat menggunakan kembali logika konstruktor dengan memanggil satu konstruktor dari konstruktor lain menggunakan ini() kata kunci.
• Peningkatan Keterbacaan: Konstruktor yang kelebihan beban (overloaded constructors) membuat kode lebih intuitif dengan menawarkan opsi spesifik untuk berbagai kebutuhan inisialisasi.
• Inisialisasi Default dan Kustom: Overloading Konstruktor memungkinkan Anda membuat objek dengan inisialisasi default maupun kustom dengan mudah.

Contoh: Overloading Konstruktor di Java

Contoh berikut mendemonstrasikan Overloading Konstruktor dalam Java menggunakan kelas bernama Demo.

Langkah 1) Ketikkan kode di editor.

class Demo{
      int  value1;
      int  value2;
      /*Demo(){
       value1 = 10;
       value2 = 20;
       System.out.println("Inside 1st Constructor");
     }*/
     Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Constructor");
    }
    Demo(int a,int b){
    value1 = a;
    value2 = b;
    System.out.println("Inside 3rd Constructor");
   }
   public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
    Demo d1 = new Demo();
    Demo d2 = new Demo(30);
    Demo d3 = new Demo(30,40);
    d1.display();
    d2.display();
    d3.display();
 }
}

Langkah 2) Simpan, kompilasi, dan jalankan kode tersebut.

Langkah 3) Terjadi kesalahan. Cobalah untuk memperbaiki kesalahan tersebut sebelum melanjutkan ke langkah berikutnya dalam Overloading Konstruktor. Java.

Langkah 4) Setiap kelas memiliki default Konstruktor di Java. Konstruktor default untuk Demo kelas is Demo()Jika Anda tidak menyediakannya, kompiler akan membuatnya untuk Anda dan menginisialisasi variabel ke nilai default.

Namun, jika Anda menentukan konstruktor berparameter seperti Demo(int a) dan ingin menggunakan pengaturan default Demo(), maka wajib untuk menyatakannya secara eksplisit.

Langkah 5) Hapus tanda komentar pada baris kode 4-8, kemudian simpan, kompilasi, dan jalankan program lagi untuk mengamati perubahan perilakunya.

Rantai Konstruktor dalam Java

Pertimbangkan skenario dimana kelas dasar diperluas oleh seorang anak. Setiap kali objek kelas anak dibuat, konstruktor kelas induk dipanggil terlebih dahulu. Ini disebut Rantai konstruktor.

Contoh: Untuk memahami penggabungan konstruktor dengan kelebihan beban konstruktor dalam Java

Langkah 1) Salin kode berikut ke editor.

class Demo{
   int  value1;
   int  value2;
    Demo(){
      value1 = 1;
      value2 = 2;
      System.out.println("Inside 1st Parent Constructor");
   }
   Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Parent Constructor");
   }
  public void display(){
     System.out.println("Value1 === "+value1);
     System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
     DemoChild d1 = new DemoChild();
     d1.display();
  }
}
class DemoChild extends Demo{
    int value3;
    int value4;
    DemoChild(){
    //super(5);
     value3 = 3;
     value4 = 4;
    System.out.println("Inside the Constructor of Child");
    }
    public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
      System.out.println("Value1 === "+value3);
      System.out.println("Value2 === "+value4);
   }
}

Langkah 2) Jalankan kodenya. Karena adanya penggabungan konstruktor, ketika objek dari kelas turunan DemoChild dibuat, konstruktor Demo() dari kelas induk dipanggil terlebih dahulu dan konstruktor DemoChild() Anak itu berlari selanjutnya.

Output yang Diharapkan:

Inside 1st Parent Constructor
Inside the Constructor of Child
Value1 === 1
Value2 === 2
Value1 === 3
Value2 === 4

Langkah 3) Anda mungkin mengamati bahwa konstruktor induk Demo() berjalan secara default. Untuk memanggil konstruktor yang kelebihan beban. Demo(int a) Sebaliknya, gunakan kata kunci "super".

sintaks:

super();
--or--
super(parameter list);

Contoh: Jika konstruktor induk Anda seperti ini Demo(String Name, int a), Anda akan menentukan super("Java”,5). Jika digunakan, kata kuncinya super Ini harus menjadi baris kode pertama dalam konstruktor kelas turunan.

Langkah 4) Hapus tanda komentar pada baris 26 dan jalankan kodenya. Amati hasilnya.

Keluaran:

Inside 2nd Parent Constructor
Inside the Constructor of Child
Value1 === 5
Value2 === 0
Value1 === 3
Value2 === 4

Pertanyaan Umum Demo Slot