Претоварване на конструктора в Java

Какво е претоварване на конструктора в Java?

Претоварване на конструктора в Java е техника, при която един клас декларира множество конструктори, които се различават по списъка с параметри. Компилаторът разграничава тези конструктори, като анализира броя на параметрите и техните типове данни.

Примери за валидни конструктори за клас Акаунт са показани по-долу:

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

Защо ни е необходимо претоварване на конструктора в Java?

Претоварване на конструктора в Java подобрява гъвкавостта и ефективността на кода, като позволява няколко конструктора в един клас, всеки с различен списък с параметри.

• Гъвкавост при създаване на обекти: Претоварването на конструктора ви позволява да инициализирате обекти по различни начини, в зависимост от броя или типа на параметрите.
• Code Повторна употреба: Можете да използвате повторно логиката на конструктора, като извикате един конструктор от друг, използвайки това() ключова дума.
• Подобрена четливост: Претоварените конструктори правят кода по-интуитивен, като предлагат специфични опции за различни нужди от инициализация.
• Инициализация по подразбиране и по избор: Претоварването на конструктора ви позволява лесно да създавате както обекти по подразбиране, така и такива, инициализирани по поръчка.

Пример: Претоварване на конструктора в Java

Следният пример демонстрира претоварване на конструктора в Java използвайки клас с име Демонстрация.

Стъпка 1) Въведете кода в редактора.

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

Стъпка 2) Запазете, компилирайте и изпълнете кода.

Стъпка 3) Появява се грешка. Опитайте да отстраните грешката, преди да преминете към следващата стъпка - претоварване на конструктора в Java.

Стъпка 4) Всеки клас има стойност по подразбиране Конструктор в JavaКонструкторът по подразбиране за клас Демо is Демо ()Ако не го предоставите, компилаторът го създава вместо вас и инициализира променливите със стойности по подразбиране.

Ако обаче зададете параметризиран конструктор като Демо(int a) и искате да използвате настройката по подразбиране Демо (), задължително е да се декларира изрично.

Стъпка 5) Разкоментирайте редове 4-8 от кода, след което запазете, компилирайте и стартирайте програмата отново, за да наблюдавате промяната в поведението.

Верижно свързване на конструктори Java

Помислете за сценарий, при който базов клас се разширява от дете. Всеки път, когато се създава обект от дъщерния клас, първо се извиква конструкторът на родителския клас. Това се нарича Верижно свързване на конструктори.

Пример: За да разберете верижното свързване на конструктори с претоварване на конструктори в Java

Стъпка 1) Копирайте следния код в редактора.

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

Стъпка 2) Изпълнете кода. Поради верижното свързване на конструктори, когато обектът на дъщерния клас ДемоДете е създаден, конструкторът Демо () на родителския клас се извиква първо и конструкторът ДемоДете() на детето тича следващото.

Очакван резултат:

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

Стъпка 3) Може да забележите, че родителският конструктор Демо () изпълнява се по подразбиране. За да извикате претоварения конструктор Демо(int a) вместо това използвайте ключовата дума „Супер“.

Синтаксис:

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

Пример: Ако вашият родителски конструктор е като Демо(Име на низ, int a), ще уточните супер(“Java“,5). Ако се използва, ключовата дума супер трябва да е първият ред код в конструктора на дъщерния клас.

Стъпка 4) Разкоментирайте ред 26 и изпълнете кода. Наблюдавайте резултата.

Изход:

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

Въпроси и Отговори