Przeciążanie konstruktora w Java

Czym jest przeciążanie konstruktora w Java?

Przeciążanie konstruktora w Java To technika, w której klasa deklaruje wiele konstruktorów różniących się listą parametrów. Kompilator rozróżnia te konstruktory, analizując liczbę parametrów i ich typy danych.

Przykłady prawidłowych konstruktorów dla klasy Konto są pokazane poniżej:

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

Dlaczego potrzebujemy przeciążania konstruktorów w Java?

Przeciążanie konstruktora w Java zwiększa elastyczność i wydajność kodu, umożliwiając użycie wielu konstruktorów w klasie, z których każdy ma inną listę parametrów.

• Elastyczność w tworzeniu obiektów: Przeciążanie konstruktora pozwala inicjować obiekty na różne sposoby, w zależności od liczby lub typu parametrów.
• Code Możliwość ponownego wykorzystania: Możesz ponownie wykorzystać logikę konstruktora, wywołując jeden konstruktor z innego za pomocą to() słowo kluczowe.
• Poprawiona czytelność: Przeciążone konstruktory sprawiają, że kod jest bardziej intuicyjny, ponieważ oferują konkretne opcje dla różnych potrzeb inicjalizacji.
• Domyślna i niestandardowa inicjalizacja: Przeciążanie konstruktora umożliwia łatwe tworzenie zarówno obiektów domyślnych, jak i inicjowanych niestandardowo.

Przykład: przeciążanie konstruktora w Java

Poniższy przykład demonstruje przeciążanie konstruktora w Java używając klasy o nazwie Demo.

Krok 1) Wpisz kod w edytorze.

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

Krok 2) Zapisz, skompiluj i uruchom kod.

Krok 3) Pojawia się błąd. Spróbuj debugować błąd przed przejściem do następnego kroku przeciążania konstruktora w Java.

Krok 4) Każda klasa ma wartość domyślną Konstruktor w Java. Domyślny konstruktor dla demonstracja klasy is Próbny(). Jeżeli go nie podasz, kompilator utworzy go za Ciebie i zainicjuje zmienne wartościami domyślnymi.

Jeśli jednak określisz sparametryzowany konstruktor, taki jak Demo(int a) i chcę użyć domyślnego Próbny(), konieczne jest jego wyraźne zadeklarowanie.

Krok 5) Usuń komentarze z wierszy 4–8 kodu, a następnie zapisz, skompiluj i uruchom program ponownie, aby zaobserwować zmianę w zachowaniu.

Łańcuchowanie konstruktorów w Java

Rozważmy scenariusz, w którym klasa bazowa jest rozszerzana przez element podrzędny. Za każdym razem, gdy tworzony jest obiekt klasy podrzędnej, najpierw wywoływany jest konstruktor klasy nadrzędnej. To się nazywa Łańcuchowanie konstruktorów.

Przykład: Aby zrozumieć łączenie konstruktorów w łańcuchy z przeciążaniem konstruktorów w Java

Krok 1) Skopiuj poniższy kod do edytora.

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

Krok 2) Uruchom kod. Ze względu na łańcuch konstruktorów, gdy obiekt klasy potomnej DemoChild jest tworzony, konstruktor Próbny() najpierw wywoływany jest konstruktor klasy nadrzędnej DemoChild() Następne dziecko biegnie dalej.

Oczekiwany wynik:

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

Krok 3) Możesz zauważyć, że konstruktor nadrzędny Próbny() działa domyślnie. Aby wywołać przeciążony konstruktor Demo(int a) zamiast tego użyj słowa kluczowego "Wspaniały".

Składnia:

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

Przykład: Jeśli twój konstruktor nadrzędny wygląda tak: Demo(Nazwa ciągu, int a), określisz Super("Java”,5). Jeśli jest używane, słowo kluczowe wielki musi być pierwszą linią kodu konstruktora klasy potomnej.

Krok 4) Odkomentuj linię 26 i uruchom kod. Obserwuj wynik.

Wyjście:

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

FAQ