A kivitelező túlterhelése Java

Mi a konstruktor túlterhelése? Java?

A kivitelező túlterhelése Java egy olyan technika, amelyben egy osztály több konstruktort deklarál, amelyek paraméterlistájukban különböznek egymástól. A fordítóprogram a paraméterek számának és adattípusainak elemzésével különbözteti meg ezeket a konstruktorokat.

Példák érvényes konstruktorokra osztályhoz Fiók alább láthatók:

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

Miért van szükség konstruktor túlterhelésre? Java?

A kivitelező túlterhelése Java Javítja a rugalmasságot és a kód hatékonyságát azáltal, hogy több konstruktort tesz lehetővé egy osztályban, mindegyiket más paraméterlistával.

• Rugalmasság az objektumok létrehozásában: A Constructor Overloading lehetővé teszi az objektumok inicializálását különböző módokon, a paraméterek számától és típusától függően.
• Code Újrahasználhatóság: A konstruktor logikáját újra felhasználhatja úgy, hogy egy konstruktort egy másikból hív meg a következő használatával: ez() kulcsszó.
• Továbbfejlesztett olvashatóság: A túlterhelt konstruktorok intuitívabbá teszik a kódot azáltal, hogy specifikus beállításokat kínálnak a különböző inicializálási igényekhez.
• Alapértelmezett és egyéni inicializálás: A Constructor Overloading lehetővé teszi mind az alapértelmezett, mind az egyéni inicializálású objektumok egyszerű létrehozását.

Példa: Konstruktor túlterhelése a Java

A következő példa a konstruktor túlterhelését mutatja be a következőben: Java nevű osztály használatával Demó.

Step 1) Írja be a kódot a szerkesztőbe.

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

Step 2) Mentse el, fordítsa le és futtassa a kódot.

Step 3) Hiba jelenik meg. Próbálja meg kijavítani a hibát, mielőtt a Konstruktor túlterhelésének következő lépésére lépne a következő részben. Java.

Step 4) Minden osztálynak van alapértelmezett értéke Konstruktor be JavaAz alapértelmezett konstruktor a következőhöz: osztályú Demo is Demó()Ha nem adod meg, a fordítóprogram létrehozza helyetted, és inicializálja a változókat az alapértelmezett értékekre.

Ha azonban paraméteres konstruktort adsz meg, mint például a Demo(int a) és az alapértelmezett beállítást szeretné használni Demó(), kötelező explicit módon deklarálni.

Step 5) Töröld ki a kommentet a kód 4-8. soraiból, majd mentsd el, fordítsd le, és futtasd újra a programot a viselkedésbeli változás megfigyeléséhez.

Konstruktor láncolása Java

Tekintsünk egy olyan forgatókönyvet, amelyben az alaposztályt egy gyermek bővíti ki. A gyermekosztály objektumának létrehozásakor először a szülőosztály konstruktora kerül meghívásra. Ezt nevezik Konstruktor láncolás.

Példa: A konstruktor láncolásának megértése a konstruktor túlterhelésével Java

Step 1) Másolja be a következő kódot a szerkesztőbe.

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

Step 2) Futtassa a kódot. A konstruktor láncolása miatt, amikor a gyermekosztály objektuma DemoChild létrejön, a konstruktor Demó() a szülő osztály komponensét hívjuk meg először, majd a konstruktort. DemoChild() a gyermek fut legközelebb.

Várható teljesítmény:

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

Step 3) Megfigyelheted, hogy a szülő konstruktor Demó() alapértelmezés szerint fut. A túlterhelt konstruktor meghívásához Demo(int a) ehelyett használd a kulcsszót "szuper".

Syntax:

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

Példa: Ha a szülő konstruktorod ilyen Demo(String név, int a), akkor megadod szuper("Java”,5). Ha használjuk, akkor a kulcsszót szuper a gyermekosztály konstruktorának első kódsorában kell lennie.

Step 4) Töröld ki a 26. sort a megjegyzésből, és futtasd a kódot. Figyeld meg a kimenetet.

output:

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

GYIK