A kivitelező túlterhelése Java

Mi a konstruktor túlterhelése Java?

Java A konstruktor túlterhelés egy olyan technika, amelyben egy osztálynak tetszőleges számú konstruktora lehet, amelyek paraméterlistában különböznek egymástól. A fordító ezeket a konstruktorokat a listában szereplő paraméterek számának és típusának figyelembevételével különbözteti meg.

Példák a Fiók osztály érvényes konstruktoraira:

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

Példa 2: A Constructor Overloading megértéséhez Java

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, fordítsa le és futtassa a kódot.

Step 3) Hiba =?. Próbálja meg kijavítani a hibát, mielőtt továbblépne a következő lépésre Java konstruktor túlterhelés

Step 4) Minden osztálynak van alapértelmezett értéke Konstruktor be Java. Alapértelmezett túlterhelt konstruktor Java mert osztályú Demo is Demó(). Abban az esetben, ha nem adja meg ezt a konstruktort, a fordító létrehozza azt, és az alapértelmezett értékekre inicializálja a változókat. Dönthet úgy, hogy felülbírálja ezt az alapértelmezett konstruktort, és inicializálja a változókat a kívánt értékekre az 1. példában látható módon.

De ha megad egy paraméterezett konstruktort, mint például a Demo(int a), és az alapértelmezett konstruktort szeretné használni Java Demo(), kötelező megadni.

Más szóval, abban az esetben, ha túlterheli a konstruktort Java felül van írva, és az alapértelmezett konstruktort szeretné használni Java, pontosítani kell.

Step 5) Megjegyzés: 4-8. sor. Mentse, fordítsa le és futtassa a kódot.

Miért van szükségünk Constructor Overloadingra? Java?

A kivitelező túlterhelése Java több konstruktőrt tesz lehetővé egy osztályban, mindegyiknek más paraméterlistája van. Növeli a rugalmasságot és javítja a kód hatékonyságát.

• Rugalmasság az objektumok létrehozásában: A konstruktor túlterhelése lehetővé teszi az objektumok különböző módokon történő inicializálását, a paraméterek számától vagy típusától függően.
• A kód újrafelhasználhatósága: A konstruktor logikáját újra felhasználhatja, ha meghív egy konstruktort egy másikból a this() kulcsszó használatával.
• Továbbfejlesztett olvashatóság: A túlterhelt konstruktorok segítenek a kód intuitívabbá tételében azáltal, hogy specifikus konstruktor opciókat kínálnak a különböző inicializálási igényekhez.
• Alapértelmezett és egyéni inicializálás: A konstruktor túlterhelése lehetővé teszi az alapértelmezett és egyedi inicializált objektumok egyszerű létrehozását.

GYIK

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