Java Constructor

java constructor class

Prova Vårt Instrument För Att Eliminera Problem

Välj Operativsystemet Välj Ett Projektprogram (Valfritt)

Beskriv Ditt Problem

Denna handledning diskuterar Java Constructor, dess typer och begrepp som konstruktöröverbelastning och konstruktorkedjning med kodexempel:

Från våra tidigare handledning vet vi att förekomsten av en klass kallas ett objekt. Ett objekt i en klass skapas med hjälp av det 'nya' nyckelordet. En speciell metod som kallas 'konstruktör' kallas när vi skapar ett objekt med ett nytt nyckelord eller när objektet instantieras.

En konstruktör definieras som ett kodblock för att initialisera klassobjektet. Det är identiskt med metoden men det är inte en metod. Det kan dock betecknas som en 'speciell metod' i Java.

=> Kolla här för att se A-Z av Java-utbildningar här.

Konstruktörer i Java

Vad du kommer att lära dig:

Java Constructor
Slutsats
- Rekommenderad läsning

Java-konstruktör används för att initialisera det just skapade objektet. Ett objekt måste ha lite data innan det används i programmet. Därför använder vi konstruktorn så att vi kan tilldela objektets initiala data.

Som ett enkelt exempel, överväga en klass ABC som vi behöver skapa ett objekt för. Låt oss skapa ett objekt 'myObj' för klassen ABC med ett nytt nyckelord.

ABC myObj = new ABC ();

Ovanstående uttalande skapar ett objekt myObj. När detta objekt skapas kallas en konstruktör för klass ABC utan argument (ABC () visar att det inte finns några argument för konstruktören). Eftersom det inte finns några argument för ovanstående konstruktör, kommer myObjs medlemsfält att initialiseras till sina ursprungliga initialvärden.

Till exempel,

Numeriska datatyper som int är inställda på 0.
Variabelvärdet för Char-datatyp är inställt på null (‘ 0’).
Referenser är satt till null.

I denna handledning kommer vi att diskutera konstruktörerna i detalj tillsammans med de olika konstruktörerna som används i Java.

Hur man skapar en konstruktör i Java

För att skapa en konstruktör i Java måste vi följa vissa regler enligt nedan.

Klasskonstruktören har samma namn som klassens.
Det kan inte finnas en konstruktör som är slutlig, abstrakt, synkroniserad eller statisk. Detta beror på att Finalen fungerar som en konstant, abstrakt inte kan instansieras. Medan synkroniserat används i fallet med multitrådning används det statiska nyckelordet på klassnivå.
Vi kan använda åtkomstmodifierare med konstruktörerna.
En konstruktör kan inte ha en returtyp.

Till exempel,låt oss definiera en klassstudent enligt följande:

class Student{ String name; int roll_no; }

Vi kan skapa objekt av ovanstående klass med det nya nyckelordet. Medan objektet skapas kan vi initialisera tvåmedelsvariablerna i denna klass genom att tillhandahålla en konstruktör. Observera att även om vi inte tillhandahåller en konstruktör och bara utför nedanstående uttalande,

Studentstudent = ny student ();

Ändå kör Java en standardkonstruktör som initialiserar tvåmedelsvariablerna till deras systeminställningar. Om vi nu vill att det ursprungliga värdet på Student.name ska vara “Keith” och roll_no ska vara 27, så kan vi göra följande konstruktormetod för att göra detta.

Student () { name = 'Keith'; roll_no = 27; }

När vi skapar ett objekt av studentklassen med nedanstående uttalande

Student student = new Student ();

Då kommer de ursprungliga värdena för medlemsvariablerna och roll_no att vara Keith respektive 27.

Nu när en konstruktör skapas, när kommer den att kallas?

En konstruktör anropas varje gång ett objekt skapas med det nya nyckelordet som i ovanstående fall. Som redan nämnts, om ingen konstruktör tillhandahålls, tillhandahåller Java en standardkonstruktör som anropas när objektet skapas med det nya nyckelordet.

Konstruktörsexempel

Följande program visar ett konstruktörsexempel där vi har en enkel konstruktör utan några argument. Denna konstruktör tilldelar helt enkelt initialvärden till sina medlemsvariabler.

//class definition class classDemo{ int num1; int num2; //constructor classDemo(){ num1 = 100; num2 = 250; System.out.println('Inside ClassDemo::Constructor'); } public void display(){ System.out.println('num1 = '+ num1); System.out.println('num2 = '+ num2); } } class Main{ public static void main(String args()){ classDemo cd1 = new classDemo(); //create object of ClassDemo cd1.display(); } }

Produktion:

Klass Demo Exempel utgång

Standardkonstruktör i Java

Standardkonstruktören kallas också Tom konstruktör . Denna konstruktör infogas av Java-kompilatorn i klasskoden där det inte finns någon konstruktör implementerad av programmeraren. Standardkonstruktören infogas under kompileringen och visas därför endast i '.class' -filen och inte i källkoden.

Tänk på följande Java-klass.

källfil (.java) klassfil (.class)

Java-klass

I figuren ovan visar den första figuren källkoden där vi inte har specificerat någon konstruktör. Så när vi kompilerar den här koden och .class-filen genereras kan vi se att Java-kompilatorn har infogat en standardkonstruktör som visas i den angränsande figuren (i blå färg).

Notera:

Ibland används en standardkonstruktör för att beskriva konstruktion utan arg i Java. Men dessa två termer skiljer sig åt i verkligheten. No-arg-konstruktör är en typ av konstruktör i Java som specificeras av programmeraren. Standardkonstruktören är konstruktorn som infogas av Java-kompilatorn.

vilken ide är bäst för python

Därför, även om dessa två termer används omväxlande av de flesta av programmeraren, är det tillrådligt att inte förväxla dessa två termer.

När Java infogar en standardkonstruktör, om programmet har några variabler, tilldelas de standardvärdena.

Tabellen nedan visar standardvärdena för varje datatyp.

Typ	Standardvärde
röding	u0000
Objekt	Referens null
booleska	falsk
byte	0
kort	0
int	0
lång	0L
flyta	0,0f
dubbel	0,0d

Följande program ger ett exempel på en standardkonstruktör i Java.

class Main { int num; boolean flag; public static void main(String() args) { // A default constructor is called Main obj = new Main(); System.out.println('num:default value = ' + obj.num); System.out.println('flag:default value = ' + obj.flag); } }

Produktion:

standardkonstruktör - utdata

Typer av konstruktörer i Java

Det finns två typer av konstruktörer i Java som visas nedan.

Typer av konstruktörer i Java

# 1) No-arg konstruktör

En konstruktör utan argument kallas no-args eller no-argument constructor. Om vi inte har en konstruktör utan några argument skapar Java-kompilatorn inte en standardkonstruktör för klassen.

I allmänhet, om vi definierar en konstruktör i vår klass, infogas inte standardkonstruktören av Java-kompilatorn.

Nedan ges ett exempel på No-arg Constructor

import java.io.*; class DemoClass { int num; String name; // no-args Constructor called when object is created DemoClass() { System.out.println('DemoClass::Constructor called'); System.out.println('Initial member variable values:'); System.out.println('num = ' + num + ' name = ' + name); } } class Main{ public static void main (String() args) { // this will invoke no-args Constructor DemoClass dc1 = new DemoClass(); } }

Produktion:

No-arg Constructor

I det här programmet har vi tillhandahållit en konstruktör utan args. Här skriver vi ut några meddelanden inklusive medlemsvariablerna. Vi kan se i utgången att meddelandena från konstruktorn visas som indikerar att konstruktionen utan args körs.

# 2) Parameteriserad konstruktör

En parametrerad konstruktör har en eller flera parametrar. Vi kan använda en parametrerad konstruktör om vi behöver skicka några initialvärden till medlemsvariabeln i klassen.

import java.io.*; class DemoClass { // data members of the class. String name; int id; // parameterized constructor called when object is created DemoClass(String name, int id) { this.name = name; this.id = id; } } class Main { public static void main (String() args) { // this will invoke the parameterized constructor. DemoClass dc1 = new DemoClass('Java', 1); System.out.println('Tutorial Name :' + dc1.name + ', Id :' + dc1.id); } }

Produktion:

Parameteriserad konstruktör i Java

Här har vi tillhandahållit en parametrerad konstruktör som tar två argument, dvs namn och id.

Inuti konstruktörens kropp tilldelas argumenten som värden till medlemsvariabelns namn respektive id.

Sedan i huvudmetoden när vi skapar ett nytt objekt med det nya nyckelordet, skickar vi två värden till klassnamnet efter ett nytt nyckelord. Detta indikerar att vi ringer till den parametrerade konstruktorn. När vi visar medlemsvariablerna kan vi se att de har de värden som vi skickade när vi skapade objektet.

Överbelastade konstruktörer i Java

Nu uppstår frågan om en klass kan ha mer än en konstruktör eller är det att en klass bara kan ha en konstruktör?

Vi kan ha flera konstruktörer i en klass. En klass kan ha så många konstruktörer i sig så länge de är ordentligt överbelastade.

Så vad menas exakt med överbelastning av konstruktörer?

Constructor Overloading är en mekanism som gör det möjligt för en klass att ha så många konstruktörer så att alla dessa konstruktörer har olika parametrar, antingen beroende på parametertyper eller parametrar.

Nedanstående program visar Constructor Overloading.

//class with multiple constructors class DemoClass{ int val1; int val2; //no args Constructor DemoClass(){ val1 = 10; val2 = 20; System.out.println('DemoClass:: No argument Constructor'); } //Overloaded Constructor DemoClass(int num1){ val1 = num1; val2 = num1; System.out.println('DemoClass:: Overloaded Constructor with one argument'); } //Overloaded DemoClass(int num1,int num2){ val1 = num1; val2 = num2; System.out.println('DemoClass:: Overloaded Constructor with two arguments'); } public void display(){ System.out.println('val1 === '+val1 + ' ; val2 === '+val2 ); } } class Main{ public static void main(String args()){ DemoClass d1 = new DemoClass(); //object with no-args Constructor d1.display(); DemoClass d2 = new DemoClass(10); //object with 1 arg Constructor d2.display(); DemoClass d3 = new DemoClass(20,40); //object with 2 arg Constructor d3.display(); } }

Produktion:

Överbelastad - utdata

I programmet ovan har vi en klass som innehåller tre konstruktörer. Den första konstruktören är en konstruktör utan arg, och sedan har vi en med vardera ett argument respektive två argument. Eftersom konstruktören har en unik parameterlista kan vi säga att konstruktörerna är överbelastade.

'Denna ()' konstruktör i Java

I en klass som innehåller flera konstruktörer, vad händer om vi vill kalla en konstruktör från en annan konstruktör i den här klassen?

För detta ändamål använder vi nyckelordet 'detta' inuti konstruktören som vi vill kalla en annan konstruktör från.

Så när en klass har flera konstruktörer, en konstruktör utan arg och en parameteriserad konstruktör, använder vi 'detta' nyckelord för att anropa en parametrerad konstruktör från konstruktionen utan arg. Detta kallas också ”Explicit anrop av konstruktören”.

Varför behöver vi det här nyckelordet?

Vi behöver det eftersom den uttryckliga anropet av konstruktörer inte är möjligt direkt genom att bara använda konstruktörens namn.

Poäng att notera:

Nyckelordet ”detta” bör vara det första uttalandet i den anropande konstruktören.
Om en konstruktör har 'detta' nyckelord kan det inte ha 'super'. Detta innebär att konstruktören kan ha antingen super eller detta.

class TestClass { TestClass() { //calling Parameterized Constructor this('SoftwareTestingHelp'); System.out.println('TestClass::No-args Constructor'); } TestClass(String str) { System.out.println('TestClass:: Parameterized Constructor(String):' + str); } } class Main{ public static void main(String() args) { TestClass obj = new TestClass(); } }

Produktion:

I programmet ovan har vi en ”TestClass” med två konstruktörer. Vi kallar detta (“SoftwareTestingHelp”) från konstruktören no-args. Detta är den uttryckliga anropet av den parametrerade konstruktorn.

Kopiera konstruktör i Java

Vi känner till kopikonstruktören i C ++. Kopikonstruktören är en konstruktör som har en objektreferens som ett argument och ett nytt objekt skapas med hjälp av referensobjektets data.

C ++ tillhandahåller en standardkopiekonstruktör om en inte finns i programmet.

Java ger också stöd för kopikonstruktör, men det ger inte en standardkopiekonstruktör.

Följande Java-program visar kopikonstruktören med hjälp av det klassiska exemplet på komplexa nummer som har verkliga och imaginära komponenter.

class Complex { private double real, imaginary; // parametrized constructor public Complex(double real, double imaginary) { System.out.println('Complex:: parametrized constructor'); this.real = real; this.imaginary = imaginary; } // copy constructor Complex(Complex c) { System.out.println('Complex::Copy constructor called'); real = c.real; imaginary = c.imaginary; } // Overriding the toString of Object class @Override public String toString() { return '(' + real + ' + ' + imaginary + 'i)'; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(1, 5); //calls parametrized constructor System.out.println('C1 = ' + c1); // copy constructor called Complex c2 = new Complex(c1); System.out.println('C2 = ' + c2); // this is a simple assignment operator Complex c3 = c2; } }

Produktion:

Kopiera konstruktören i Java 7

Ovanstående program har en klass 'Komplex' som har en parametrerad konstruktör och en kopiekonstruktör. I huvudmetoden skapar vi först ett objekt c1 med hjälp av en parametrerad konstruktor. Använd sedan nedanstående uttalande,

Complex c2 = new Complex (c1);

Ovanstående uttalande anropar kopiekonstruktören när referensen c1 skickas till konstruktören medan den skapar ett nytt objekt c2.

Konstruktorkedjning i Java

Konstruktorkedjning är en process där en konstruktör kallar en annan konstruktör av samma klass.

Även när vi har ärvt från en basklass åberopas basklassens konstruktör först när barnklassobjektet skapas. Detta är också ett exempel på konstruktorkedjning.

I Java kan Constructor chaining uppnås med två metoder:

Inom samma klass : När vi ringer en konstruktör från en annan konstruktör av samma klass kan vi använda detta () nyckelord.
Från basklass: En konstruktör av basklassen kan anropas av den härledda klassen med hjälp av supernyckelordet.

Varför behöver vi konstruktionskedjning?

När vi vill utföra flera uppgifter i vår konstruktör, istället för att utföra varje uppgift i en konstruktör, delar vi upp uppgifterna i flera konstruktörer, och sedan kallar vi konstruktörer från varandra vilket resulterar i konstruktorkedjning.

Nedan följer några av de regler som vi måste följa när vi utför konstruktorkedjning.

Konstruktorkedjning sker i valfri ordning och kommer att ge samma resultat.
Uttrycket 'detta' nyckelord ska vara det första uttrycket i konstruktören.
Vi borde ha minst en konstruktör utan detta nyckelord.

När vi har ett arv i vårt program kan vi också utföra konstruktorkedjning. I det här fallet kommer underklassen att ringa konstruktorn för basklassen. Genom att göra denna underklass börjar skapandet av objekt med initialiseringen av superklassmedlemmarna.

Nu kommer vi att implementera konstruktorkedjningen i Java med hjälp av ovanstående metoder.

# 1) Konstruktörkedjning inom samma klass

class DemoClass { // No args constructor DemoClass() { System.out.println('DemoClass::No args constructor'); } // parameterized constructor DemoClass(int val1) { // calls default constructor this(); System.out.println('DemoClass::Constructor with 1 argument: ' + val1); } // parameterized constructor DemoClass(int val1, int val2) { // invokes parameterized constructor with 1 argument this(5); System.out.print('DemoClass::constructor with 2 arguments:'); System.out.println('Product of 2 arguments = ' + val1 * val2); } } class Main{ public static void main(String args()) { // call parameterized constructor with 2 arguments new DemoClass(10, 15); } }

Produktion:

kedja inom samma klass

Som redan nämnts uppnår vi konstruktorkedjning inom samma klass med 'detta' nyckelord. I ovanstående program har vi tre konstruktörer och vi kallar en konstruktör från en annan med 'detta' nyckelord.

Från basklass

När en klass ärver en annan klass åberopas konstruktorn för moderklassen först när vi skapar ett objekt av en härledd klass som är konstruktorkedjning.

Om vi uttryckligen vill kalla basklasskonstruktören i den härledda klassen, bör vi använda nyckelordet 'super' för detta ändamål. Med hjälp av 'super' nyckelordet kan vi kalla superklasskonstruktörerna i arvshierarkin tills vi når den översta klassen.

Nedanstående program visar användningen av ett ”super” -nyckelord för konstruktorkedjning.

class BaseClass { String name; // no args constructor BaseClass() { this(''); System.out.println('BaseClass::No-argument constructor'); } // Parameterized constructor BaseClass(String name) { this.name = name; System.out.println('BaseClass::Parameterized constructor'); } } class DerivedClass extends BaseClass { // No-argument constructor DerivedClass() { System.out.println('DerivedClass::No-argument constructor'); } // parameterized constructor DerivedClass(String name) { super(name); // invokes Parameterized constructor of BaseClass System.out.println('DerivedClass::Parameterized constructor'); } } class Main { public static void main(String args()) { // invokes DerivedClass parameterized constructor DerivedClass obj = new DerivedClass('Java'); } }

Produktion:

Från basklass

I ovanstående program åberopar vi den parametrerade konstruktorn för den härledda klassen med värdet “Java”. Denna konstruktör har i sin tur ett samtal till basklasskonstruktören med hjälp av 'super (namn);' som kör den parametrerade konstruktorn för basklassen.

Vanliga frågor

F # 1) Hur skapar du en konstruktör i Java?

Svar: Vi skapar en konstruktör som en speciell metod som har samma namn som klassens namn. En konstruktör kan inte ha en returtyp också. Den kan ha åtkomstmodifierare men den kan inte vara slutlig, statisk, abstrakt eller synkroniserad.

Om ABC är en klass kan vi definiera dess konstruktör som

ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructor

F # 2) Vad är fördelen med en konstruktör i Java?

Svar: Med hjälp av konstruktören kan vi initialisera klassmedlemmarna som det första när objektet skapas. Constructor eliminerar behovet av att anropa normala metoder implicit.

sömnfunktion i c ++

Vi kan utföra olika uppgifter relaterade till initialisering, startuppgifter etc. i konstruktören när konstruktörer åberopas under skapandet av objektet.

F # 3) Varför används konstruktörer?

Svar: Konstruktörer används främst för att initialisera medlemmarna i klassen och anropas när objektet för klassen skapas.

F # 4) Kan konstruktören vara privat?

Svar: Ja, vi kan ha en privat konstruktör. När konstruktören är privat kan klassen förhindras från att initieras.

F # 5) Kan konstruktören vara slutlig?

Svar: Nej, vi kan inte ha en slutkonstruktör.

Slutsats

I denna handledning har vi börjat vår diskussion om konstruktörer i Java. Vi lärde oss grunderna för konstruktören, dess skapande och regler att följa. Vi diskuterade också kopikonstruktörer i Java.

Standardkonstruktören och typer av konstruktörer och begrepp som konstruktöröverbelastning och konstruktorkedjning informerades med exempel. Som en del av dessa ämnen såg vi också användningen av 'detta' nyckelord i konstruktörer.

=> Läs igenom Easy Java Training Series.

Java Constructor - Klass-, kopierings- och standardkonstruktörer