Java Constructor

java constructor class

Prøv Vores Instrument Til At Fjerne Problemer

Vælg Operativsystemet Vælg Et Projektionsprojekt (Valgfrit)

Beskriv Dit Problem

Denne vejledning diskuterer Java Constructor, dens typer og koncepter som overbelastning af konstruktører og kæde af konstruktører med kodeeksempler:

Fra vores tidligere tutorials ved vi, at forekomsten af en klasse kaldes et objekt. Et objekt i en klasse oprettes ved hjælp af det 'nye' nøgleord. En speciel metode kaldet 'konstruktør' kaldes, når vi opretter et objekt med et nyt nøgleord, eller når objektet instantieres.

En konstruktør er defineret som en blok kode for at initialisere klasseobjektet. Det er identisk med metoden, men det er ikke en metode. Det kan dog betegnes som en 'speciel metode' i Java.

=> Tjek her for at se AZ af Java-træningsvejledninger her.

Konstruktører i Java

Hvad du vil lære:

Java Constructor
Konklusion
- Anbefalet læsning

Java-konstruktør bruges til at initialisere det netop oprettede objekt. Et objekt skal have nogle data, før det bruges i programmet. Derfor bruger vi konstruktør, så vi kan tildele nogle indledende data til objektet.

Som et simpelt eksempel, overvej en klasse ABC, som vi har brug for for at oprette et objekt. Lad os oprette et objekt 'myObj' til klassen ABC ved hjælp af et nyt nøgleord.

ABC myObj = new ABC ();

Ovenstående udsagn skaber et objekt myObj. Når dette objekt oprettes, kaldes en konstruktør til klasse ABC uden argument (ABC () viser, at der ikke er argumenter for konstruktøren). Da der ikke er nogen argumenter for ovenstående konstruktør, initialiseres medlemsfelterne i myObj til deres standardindledende værdier.

For eksempel,

Numeriske datatyper som int er indstillet til 0.
Char-datatypevariabelværdien er indstillet til null (' 0') tegn.
Referencer er sat til null.

I denne vejledning vil vi diskutere konstruktørerne detaljeret sammen med de forskellige konstruktører, der bruges i Java.

Sådan oprettes en konstruktør i Java

For at oprette en konstruktør i Java skal vi følge visse regler som angivet nedenfor.

Klassekonstruktøren har samme navn som klassens.
Der kan ikke være en konstruktør, der er endelig, abstrakt, synkroniseret eller statisk. Dette er fordi Finalen fungerer som en konstant, abstrakt ikke kan instantieres. Mens synkroniseret bruges i tilfælde af multitrådning, og det statiske nøgleord bruges på klasseniveau.
Vi kan bruge adgangsmodifikatorer sammen med konstruktørerne.
En konstruktør kan ikke have en returtype.

For eksempel,lad os definere en klasse-elev som følger:

class Student{ String name; int roll_no; }

Vi kan oprette objekter af ovenstående klasse ved hjælp af det nye nøgleord. Mens objektet oprettes, kan vi initialisere to-medlemsvariablerne i denne klasse ved at tilvejebringe en konstruktør. Bemærk, at selvom vi ikke leverer en konstruktør og bare udfører nedenstående udsagn,

Studerende = ny studerende ();

Stadig vil Java udføre en standardkonstruktør, der initialiserer to-medlemsvariablerne til deres systemstandarder. Hvis vi nu ønsker, at den oprindelige værdi af Student.name skal være 'Keith' og roll_no skal være 27, så for at gøre dette kan vi oprette følgende konstruktormetode.

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

Når vi opretter et objekt fra eleverklassen med nedenstående udsagn

Student student = new Student ();

Derefter er de oprindelige værdier for medlemsvariablerne navn og roll_no henholdsvis Keith og 27.

Nu hvor en konstruktør oprettes, hvornår kaldes den?

En konstruktør kaldes hver gang, når et objekt oprettes med det nye nøgleord som i ovenstående tilfælde. Som nævnt leverer Java en standardkonstruktør, som kaldes, når objektet oprettes ved hjælp af det nye nøgleord, hvis der ikke er nogen konstruktør.

Konstruktøreksempel

Det følgende program viser et konstruktøreksempel, hvor vi har en simpel konstruktør uden argumenter. Denne konstruktør tildeler simpelthen indledende værdier til sine 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:

Klassedemo Eksempel på output

Standardkonstruktør i Java

Standardkonstruktøren kaldes også den tomme konstruktør . Denne konstruktør indsættes af Java-kompilatoren i klassekoden, hvor der ikke er nogen konstruktør implementeret af programmøren. Standardkonstruktør indsættes under kompilering, og derfor vises den kun i '.class' -filen og ikke i kildekoden.

Overvej følgende Java-klasse.

kildefil (.java) klassefil (.class)

Java-klasse

I ovenstående figur viser den første figur kildekoden, hvor vi ikke har specificeret nogen konstruktør. Så når vi kompilerer denne kode, og .class-filen genereres, kan vi se, at Java-compileren har indsat en standardkonstruktør som vist i den tilstødende figur (i blå farve).

Bemærk:

Nogle gange bruges en standardkonstruktør til at beskrive no-arg-konstruktør i Java. Men disse to udtryk er forskellige i virkeligheden. No-arg-konstruktør er en type konstruktør i Java, der er specificeret af programmøren. Standardkonstruktøren er den konstruktør, der indsættes af Java-kompilatoren.

bedste filgendannelsessoftware windows 10

Derfor, selv om disse to udtryk bruges ombytteligt af de fleste af programmørerne, anbefales det ikke at forveksle disse to udtryk.

Når Java indsætter en standardkonstruktør, hvis programmet har nogen variabler, tildeles de standardværdierne.

Nedenstående tabel viser standardværdierne for hver datatype.

Type	Standard værdi
char	u0000
Objekt	Reference null
boolsk	falsk
byte	0
kort	0
int	0
lang	0L
flyde	0,0f
dobbelt	0,0d

Det følgende program giver et eksempel 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:

standard konstruktør - output

Typer af konstruktører i Java

Der er to typer konstruktører i Java som vist nedenfor.

Typer af konstruktører i Java

# 1) No-arg konstruktør

En konstruktør uden argumenter kaldes no-args eller no-argument constructor. Hvis vi ikke har en konstruktør uden argumenter, opretter Java-compileren ikke en standardkonstruktør til klassen.

Generelt, hvis vi definerer en konstruktør i vores klasse, indsættes standardkonstruktøren ikke af Java-kompilatoren.

Nedenfor er et eksempel 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 konstruktør

I dette program har vi leveret en konstruktør uden args. Her udskriver vi nogle meddelelser inklusive medlemsvariabler. Vi kan se i output, at meddelelserne fra konstruktøren vises, hvilket indikerer, at konstruktionen uden args udføres.

# 2) Parametreret konstruktør

En parameteriseret konstruktør har en eller flere parametre. Vi kan bruge en parameteriseret konstruktør, hvis vi har brug for at videregive nogle indledende værdier til medlemsvariablen 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:

Parameteriseret konstruktør i Java

Her har vi leveret en parameteriseret konstruktør, der tager to argumenter, dvs. navn og id.

Inde i konstruktørorganet tildeles argumenterne som værdier til henholdsvis medlemsvariablerne navn og id.

Så i hovedmetoden, når vi opretter et nyt objekt ved hjælp af det nye nøgleord, sender vi to værdier til klassens navn efter et nyt nøgleord. Dette indikerer, at vi kalder den parametriserede konstruktør. Når vi viser medlemsvariablerne, kan vi se, at de har de værdier, som vi passerede, mens vi oprettede objektet.

Overbelastede konstruktører i Java

Nu opstår spørgsmålet, om en klasse kan have mere end en konstruktør, eller er det, at en klasse kun kan have en konstruktør?

Vi kan have flere konstruktører i en klasse. En klasse kan have så mange konstruktører, så længe de er ordentligt overbelastede.

Så hvad menes der nøjagtigt med overbelastning af konstruktører?

Constructor Overloading er en mekanisme, der gør det muligt for en klasse at have så mange konstruktører, så alle disse konstruktører har forskellige parameterlister, uanset om de er afhængige af parametertyper eller rækkefølge for parametre.

Nedenstående program demonstrerer konstruktøroverbelastning.

//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:

Overbelastet - output

typer af test i softwaretest

I ovenstående program har vi en klasse, der indeholder tre konstruktører. Den første konstruktør er en ikke-arg konstruktør, og så har vi en hver med henholdsvis et argument og to argumenter. Da konstruktøren har en unik parameterliste, kan vi sige, at konstruktørerne er overbelastede.

'Denne ()' konstruktør i Java

I en klasse, der indeholder flere konstruktører, hvad hvis vi vil kalde en konstruktør fra en anden konstruktør i denne klasse?

Til dette formål bruger vi nøgleordet 'dette' inde i konstruktøren, hvorfra vi vil kalde en anden konstruktør.

Så når en klasse har flere konstruktører, en no-arg konstruktør og en parameteriseret konstruktør, bruger vi 'dette' nøgleord til at kalde en parameteriseret konstruktør fra no-args konstruktøren. Dette kaldes også “Eksplicit påkaldelse af konstruktør”.

Hvorfor har vi brug for dette nøgleord?

Vi har brug for det, fordi den eksplicitte påkaldelse af konstruktører ikke er mulig direkte ved kun at bruge konstruktørnavnet.

Punkter at bemærke:

Nøgleordet 'dette' skal være den første sætning i den kaldende konstruktør.
Hvis en konstruktør har 'dette' nøgleord, kan det ikke have 'super'. Dette betyder, at konstruktøren kan have enten super eller dette.

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 ovenstående program har vi en 'TestClass' med to konstruktører. Vi kalder dette (“SoftwareTestingHelp”) fra no-args-konstruktøren. Dette er den eksplicitte påkaldelse af den parametriserede konstruktør.

Kopi konstruktør i Java

Vi er opmærksomme på kopikonstruktøren i C ++. Kopikonstruktøren er en konstruktør, der har en objektreference som et argument, og et nyt objekt oprettes ved hjælp af dataene fra referenceobjektet.

C ++ giver en standardkopiekonstruktør, hvis der ikke findes en i programmet.

Java yder også support til copy constructor, men det giver ikke en standard copy constructor.

Det følgende Java-program demonstrerer kopikonstruktøren ved hjælp af det klassiske eksempel på komplekse tal, der har ægte og imaginære 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:

Kopi konstruktør i Java 7

Ovenstående program har en 'Complex' klasse, der har en parametreret konstruktør og en kopikonstruktør. I hovedmetoden opretter vi først et objekt c1 ved hjælp af en parametreret konstruktør. Brug derefter nedenstående udsagn,

Complex c2 = new Complex (c1);

Ovenstående erklæring kalder kopikonstruktøren, når referencen c1 sendes til konstruktøren, mens der oprettes et nyt objekt c2.

Konstruktorkædning i Java

Constructor chaining er en proces, hvor en konstruktør kalder en anden konstruktør af samme klasse.

Selv når vi har arvet fra en basisklasse, kaldes konstruktøren af baseklassen først, når underordnet klasseobjekt oprettes. Dette er også et eksempel på konstruktorkædning.

I Java kan Constructor chaining opnås ved hjælp af to tilgange:

Inden for samme klasse : Når vi ringer til en konstruktør fra en anden konstruktør af samme klasse, kan vi bruge dette () nøgleord.
Fra basisklasse: En konstruktør af basisklassen kan kaldes af den afledte klasse ved hjælp af super-nøgleordet.

Hvorfor har vi brug for konstruktionskædning?

Når vi ønsker at udføre flere opgaver i vores konstruktør, nedbryder vi opgaverne i flere konstruktører i stedet for at udføre hver opgave i en konstruktør, og derefter kalder vi konstruktører fra hinanden, hvilket resulterer i konstruktorkæding.

Nedenfor er nogle af de regler, som vi skal følge, når vi udfører konstruktorkæde.

Constructor chaining udføres i en hvilken som helst rækkefølge og vil give de samme resultater.
Udtrykket 'dette' nøgleord skal være det første udtryk i konstruktøren.
Vi burde have mindst en konstruktør uden dette nøgleord.

Når vi har en arv i vores program, kan vi også udføre konstruktorkæde. I dette tilfælde vil underklassen kalde konstruktøren af basisklassen. Ved at gøre denne underklasse begynder oprettelsen af objekter med initialiseringen af superklassemedlemmerne.

Nu implementerer vi konstruktorkæden i Java ved hjælp af ovenstående fremgangsmåder.

# 1) Konstruktorkæden inden for samme klasse

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:

kæde inden for samme klasse

Som allerede nævnt opnår vi konstruktorkæding inden for samme klasse ved hjælp af 'dette' nøgleord. I ovenstående program har vi tre konstruktører, og vi kalder en konstruktør fra en anden ved hjælp af 'dette' nøgleord.

Fra basisklasse

Når en klasse arver en anden klasse, kaldes konstruktøren af overordnede klasse først, når vi opretter et objekt af en afledt klasse, som er konstruktorkæding.

Hvis vi eksplicit vil kalde baseklassekonstruktøren i den afledte klasse, skal vi bruge nøgleordet 'super' til dette formål. Ved hjælp af 'super' nøgleordet kan vi kalde superklassekonstruktørerne i arvshierarkiet, indtil vi når den øverste klasse.

Nedenstående program demonstrerer brugen af et 'super' nøgleord til konstruktorkæde.

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:

Fra basisklasse

I ovenstående program påkalder vi den parametriserede konstruktør for den afledte klasse med værdien “Java”. Denne konstruktør har igen et opkald til baseklassekonstruktøren ved hjælp af 'super (navn);' som udfører den parametriserede konstruktør af baseklassen.

Ofte stillede spørgsmål

Q # 1) Hvordan opretter du en konstruktør i Java?

Svar: Vi opretter en konstruktør som en speciel metode, der har samme navn som klassens navn. En konstruktør kan ikke også have en returtype. Det kan have adgangsmodifikatorer, men det kan ikke være endeligt, statisk, abstrakt eller synkroniseret.

Hvis ABC er en klasse, kan vi definere dens konstruktør som

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

Q # 2) Hvad er fordelen ved en konstruktør i Java?

Svar: Ved hjælp af konstruktøren kan vi initialisere klassemedlemmerne som det første i det øjeblik objektet oprettes. Constructor eliminerer behovet for at kalde normale metoder implicit.

Vi kan udføre forskellige opgaver relateret til initialisering, startopgaver osv. I konstruktøren, da konstruktører påberåbes i løbet af objektoprettelsesfasen.

Q # 3) Hvorfor bruges konstruktører?

Svar: Konstruktører bruges hovedsageligt til at initialisere klassens medlemmer og påberåbes, når klassens objekt oprettes.

Spørgsmål nr. 4) Kan konstruktør være privat?

Svar: Ja, vi kan have en privat konstruktør. Når konstruktøren er privat, kan klassen forhindres i at blive instantierende.

Spørgsmål nr. 5) Kan konstruktør være endelig?

Svar: Nej, vi kan ikke have en endelig konstruktør.

Konklusion

I denne vejledning har vi startet vores diskussion om konstruktører i Java. Vi lærte de grundlæggende om konstruktøren, dens oprettelse og regler, der skal følges. Vi diskuterede også kopikonstruktører i Java.

Standardkonstruktøren og typer af konstruktører og koncepter som konstruktøroverbelastning og konstruktorkæde blev orienteret med eksempler. Som en del af disse emner så vi også brugen af 'dette' nøgleord i konstruktører.

=> Læs gennem Easy Java Training Series.

Java Constructor - klasse-, kopi- og standardkonstruktører