Kelebihan Konstruktor masuk Java

Apa itu Constructor Overloading di Java?

Java Kelebihan konstruktor adalah teknik di mana suatu kelas dapat memiliki sejumlah konstruktor yang berbeda dalam daftar parameternya. Kompilator membedakan konstruktor ini dengan mempertimbangkan jumlah parameter dalam daftar dan tipenya.

Contoh konstruktor yang valid untuk kelas Akun adalah

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

Contoh 2: Untuk memahami Kelebihan Konstruktor di Java

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 & Jalankan Kode.

Langkah 3) Kesalahan =?. Coba dan debug kesalahan sebelum melanjutkan ke langkah berikutnya Java kelebihan beban konstruktor

Langkah 4) Setiap kelas memiliki default Konstruktor di Java. Konstruktor kelebihan beban default Java untuk Demo kelas is Demo(). Jika Anda tidak menyediakan konstruktor ini, kompiler akan membuatkannya untuk Anda dan menginisialisasi variabel ke nilai default. Anda dapat memilih untuk mengganti konstruktor default ini dan menginisialisasi variabel ke nilai yang Anda inginkan seperti yang ditunjukkan pada Contoh 1.

Tetapi jika Anda menentukan konstruktor berparametri seperti Demo(int a), dan ingin menggunakan konstruktor default Java Demo(), Anda wajib menentukannya.

Dengan kata lain, jika konstruktor Anda kelebihan beban Java diganti, dan Anda ingin menggunakan konstruktor default Java, itu perlu ditentukan.

Langkah 5) Batalkan komentar pada baris # 4-8. Simpan, Kompilasi & Jalankan kode.

Mengapa kita membutuhkan Constructor Overloading di Java?

Overloading konstruktor dalam Java memungkinkan beberapa konstruktor dalam satu kelas, yang masing-masing memiliki daftar parameter yang berbeda. Ini meningkatkan fleksibilitas dan meningkatkan efisiensi kode.

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

Pertanyaan Umum (FAQ)

class Demo{
      int  value1;
      int  value2;
      Demo(){
         value1 = 10;
         value2 = 20;
         System.out.println("Inside Constructor");
     }
 
     public void display(){
        System.out.println("Value1 === "+value1);
        System.out.println("Value2 === "+value2);
    }
 
   public static void main(String args[]){
       Demo d1 = new Demo();
      d1.display();
  }
}

Inside Constructor
Value1 === 10
Value2 === 20

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);
   }
}

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

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

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