Vad är Constructor i Java?
CONSTRUCTOR är en speciell metod som används för att initialisera ett nyskapat objekt och kallas precis efter att minnet har tilldelats för objektet. Den kan användas för att initialisera objekten till önskade värden eller standardvärden när objektet skapas. Det är inte obligatoriskt för kodaren att skriva en konstruktör för en klass.
Om ingen användardefinierad konstruktör tillhandahålls för en klass initierar kompilatorn medlemsvariabler till dess standardvärden.
- numeriska datatyper är inställda på 0
- char datatyper är inställda på null tecken ('\ 0')
- referensvariabler är satt till null
I den här handledningen lär du dig-
- Regler för att skapa en konstruktör
- Konstruktöröverbelastning i Java
- Constructor Chaining
Regler för att skapa en Java Constructor
- Det har samma namn som klassen
- Det ska inte returnera ett värde som inte ens är ogiltigt
Exempel 1 : Skapa din första konstruktör i Java
Steg 1) Skriv följande konstruktörsprogram i Java-redigeraren.
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();}}
Steg 2) Spara, kör och kompilera konstruktörsprogrammet i Java och observera utdata.
Produktion:
Inside ConstructorValue1 === 10Value2 === 20
Konstruktöröverbelastning i Java
Java Constructor overloading är en teknik där en klass kan ha valfritt antal konstruktörer som skiljer sig åt i parameterlistan. Kompilatorn differentierar dessa konstruktörer genom att ta hänsyn till antalet parametrar i listan och deras typ.
Exempel på giltiga konstruktörer för klasskonto är
Account(int a);Account (int a,int b);Account (String a,int b);
Exempel 2 : Förstå Constructor Overloading i Java
Steg 1) Skriv koden i redigeraren.
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();}}
Steg 2) Spara, kompilera och kör koden.
Steg 3) Fel =?. Försök och felsök felet innan du fortsätter till nästa steg av Java-konstruktöröverbelastning
Steg 4) Varje klass har en standardkonstruktör i Java. Standard överbelastad konstruktör Java för klass Demo är Demo () . Om du inte tillhandahåller denna konstruktör skapar kompilatorn den åt dig och initialiserar variablerna till standardvärden. Du kan välja att åsidosätta denna standardkonstruktör och initiera variabler till önskade värden som visas i exempel 1.
Men om du anger en parametriserad konstruktör som Demo (int a) och vill använda standardkonstruktören Java Demo (), är det obligatoriskt för dig att specificera det.
Med andra ord, om din överbelastningskonstruktör i Java åsidosätts och du vill använda standardkonstruktören Java, måste den anges.
Steg 5) Kommentarrad # 4-8. Spara, kompilera och kör koden.
Constructor Chaining
Tänk på ett scenario där en basklass utökas av ett barn. Närhelst ett objekt i underklassen skapas åberopas först konstruktören för förälderklassen. Detta kallas Constructor chaining.
Exempel 3: Att förstå konstruktorkedjning
Steg 1) Kopiera följande kod till redigeraren.
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);}}
Steg 2) Kör koden. På grund av konstruktorkedjning, när objektet för underordnad klass DemoChild skapas, anropas först konstruktordemonstration () av överordnad klass och senare skapas konstruktör DemoChild () av barnet. Förväntad produktion =
Inside 1st Parent ConstructorInside the Constructor of ChildValue1 === 1Value2 === 2Value1 === 3Value2 === 4
Steg 3) Du kan observera konstruktören för föräldraklassen Demo är åsidosatt. Vad händer om du vill anropa den åsidosatta konstruktören Demo (int a) istället för standardkonstruktör Demo () när ditt underordnade objekt skapas?
I sådana fall kan du använda nyckelordet "super" för att anropa åsidosatta konstruktörer i föräldraklassen.
Syntax:-
super();--or--super(parameter list);
Exempel: Om din konstruktör är som Demo (Strängnamn, int a) kommer du att ange super ("Java", 5) Om det används måste nyckelordet super vara den första raden med kod i konstruktorn för barnklassen.
Steg 4) Avmarkera rad # 26 och kör koden. Observera utdata.
Produktion:
Inside 2nd Parent ConstructorInside the Constructor of ChildValue1 === 5Value2 === 0Value1 === 3Value2 === 4