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

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

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

Примери за валидни конструктори за клас Account са

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

Пример 2: За да разберете претоварването на конструктора в 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. Претоварен конструктор по подразбиране Java за клас Демо is Демо (). В случай, че не предоставите този конструктор, компилаторът го създава за вас и инициализира променливите към стойности по подразбиране. Можете да изберете да замените този конструктор по подразбиране и да инициализирате променливите до желаните от вас стойности, както е показано в Пример 1.

Но ако зададете параметризиран конструктор като Demo(int a) и искате да използвате конструктора по подразбиране Java Demo(), задължително е да го посочите.

С други думи, в случай че вашият претоварващ конструктор в Java е отменен и искате да използвате конструктора по подразбиране Java, трябва да се уточни.

Стъпка 5) Разкоментирайте ред # 4-8. Запазете, компилирайте и стартирайте кода.

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

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

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

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

конструктор е специален метод, който се използва за инициализиране на новосъздаден обект и се извиква веднага след като паметта е разпределена за обекта. Може да се използва за инициализиране на обектите до желани стойности или стойности по подразбиране по време на създаването на обекта. Не е задължително програмистът да напише конструктор за клас.

Ако за даден клас не е предоставен дефиниран от потребителя конструктор, компилаторът инициализира членските променливи към техните стойности по подразбиране.

  • числовите типове данни са зададени на 0
  • char типовете данни са зададени на нулев знак ('\0')
  • референтните променливи са зададени на null

  1. Той има същото име като класа
  2. Не трябва да връща дори стойност анулира

Пример 1: Създайте своя първи конструктор в Java

Стъпка 1) Въведете следната програма конструктор Java редактор.

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

Стъпка 2) Запазете, стартирайте и компилирайте програмата конструктор в Java и наблюдавайте изхода.

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

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

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

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

Стъпка 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) Стартирайте кода. Благодарение на верижното свързване на конструктора, когато се създава обектът на дъщерния клас DemoChild, първо се извиква конструкторът Demo() на родителския клас и по-късно се създава конструкторът DemoChild() на дъщерния клас.

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

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

Стъпка 3) Може да забележите, че конструкторът на родителския клас Demo е заменен. Какво ще стане, ако искате да извикате заменения конструктор Demo(int a) вместо конструктора по подразбиране Demo(), когато бъде създаден дъщерният ви обект?

В такива случаи можете да използвате ключовата дума „Супер“ за извикване на заменени конструктори на родителския клас.

Синтаксис: -

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

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

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

Изход:

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