Java Constructor

java constructor class

Prøv Instrumentet Vårt For Å Eliminere Problemer

Velg Operativsystemet Velg Et Projeksjonsprogram (Valgfritt)

Beskriv Problemet Ditt

Denne opplæringen vil diskutere Java Constructor, dens typer og konsepter som constructor overbelastning og constructor chaining med kodeeksempler:

Fra våre tidligere veiledninger vet vi at forekomsten av en klasse kalles et objekt. Et objekt av en klasse opprettes ved å bruke det 'nye' nøkkelordet. En spesiell metode kalt 'konstruktør' kalles når vi lager et objekt med et nytt nøkkelord, eller når objektet blir instantiert.

En konstruktør er definert som en blokk med kode for å initialisere klasseobjektet. Det er identisk med metoden, men det er ikke en metode. Imidlertid kan det betegnes som en 'spesiell metode' i Java.

=> Sjekk her for å se AZ av Java-opplæringsveiledninger her.

Konstruktører i Java

Hva du vil lære:

Java Constructor
Konklusjon
- Anbefalt lesing

Java-konstruktør brukes til å initialisere objektet nettopp opprettet. Et objekt må ha litt data før det brukes i programmet. Derfor bruker vi konstruktør slik at vi kan tilordne noen innledende data til objektet.

Som et enkelt eksempel, vurder en klasse ABC som vi trenger for å lage et objekt for. La oss lage et objekt ‘myObj’ for klassen ABC ved hjelp av et nytt nøkkelord.

ABC myObj = new ABC ();

Ovennevnte uttalelse skaper et objekt myObj. Når dette objektet blir opprettet, kalles en konstruktør for klasse ABC uten argument (ABC () viser at det ikke er noen argumenter for konstruktøren). Siden det ikke er noen argumenter for konstruktøren ovenfor, vil medlemsfeltene til myObj initialiseres til standardinnledningsverdiene.

For eksempel,

Numeriske datatyper som int er satt til 0.
Char data type variabel verdi er satt til null (‘ 0’) tegn.
Referanser er satt til null.

I denne veiledningen vil vi diskutere konstruktørene i detalj sammen med de forskjellige konstruktørene som brukes i Java.

Hvordan lage en konstruktør i Java

For å lage en konstruktør i Java, må vi følge visse regler som gitt nedenfor.

Klassekonstruktøren har samme navn som klassen.
Det kan ikke være en konstruktør som er endelig, abstrakt, synkronisert eller statisk. Dette er fordi Finalen fungerer som en konstant, abstrakt ikke kan instantiseres. Mens synkronisert brukes i tilfelle multitråding, og det statiske nøkkelordet brukes på klassenivå.
Vi kan bruke tilgangsmodifikatorer med konstruktørene.
En konstruktør kan ikke ha en returtype.

For eksempel,la oss definere en elev som følger:

class Student{ String name; int roll_no; }

Vi kan lage objekter av klassen ovenfor ved hjelp av det nye nøkkelordet. Mens objektet blir opprettet, kan vi initialisere to-medlemsvariablene i denne klassen ved å tilby en konstruktør. Merk at selv om vi ikke skaffer en konstruktør og bare utfører utsagnet nedenfor,

Studentstudent = ny student ();

Likevel vil Java utføre en standardkonstruktør som vil initialisere to-medlemsvariablene til systemstandardene. Nå, hvis vi vil at den opprinnelige verdien av Student.name skal være 'Keith' og roll_no skal være 27, så for å gjøre dette kan vi lage følgende konstruktormetode.

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

Når vi lager et objekt fra elevklassen med utsagnet nedenfor

Student student = new Student ();

Da vil de opprinnelige verdiene til medlemsvariablene navn og roll_no være henholdsvis Keith og 27.

Nå som en konstruktør er opprettet, når den blir kalt?

En konstruktør kalles hver gang et objekt opprettes med det nye nøkkelordet som i tilfellet ovenfor. Som allerede nevnt, hvis ingen konstruktør er gitt, gir Java en standard konstruktør som kalles når objektet opprettes ved hjelp av det nye nøkkelordet.

Konstruktøreksempel

Det følgende programmet viser et konstruktøreksempel der vi har en enkel konstruktør uten argumenter. Denne konstruktøren tilordner bare startverdier til medlemsvariablene.

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

Produksjon:

Klasse Demo Eksempel på utgang

Standardkonstruktør i Java

Standardkonstruktøren kalles også Empty Constructor . Denne konstruktøren settes inn av Java-kompilatoren i klassekoden der det ikke er noen konstruktør implementert av programmereren. Standardkonstruktør settes inn under kompilering, og derfor vises den bare i '.class' -filen og ikke i kildekoden.

Tenk på følgende Java-klasse.

kildefil (.java) klassefil (.class)

Java-klasse

I figuren ovenfor viser den første figuren kildekoden der vi ikke har spesifisert noen konstruktør. Så når vi kompilerer denne koden og .class-filen genereres, kan vi se at Java-kompilatoren har satt inn en standardkonstruktør som vist i den tilstøtende figuren (i blå farge).

Merk:

Noen ganger brukes en standardkonstruktør til å beskrive ingen arg-konstruktør i Java. Men disse to begrepene er forskjellige i virkeligheten. No-arg-konstruktør er en type konstruktør i Java som er spesifisert av programmereren. Standardkonstruktøren er konstruktøren som settes inn av Java-kompilatoren.

test case eksempel for webapplikasjon

Derfor, selv om disse to begrepene brukes om hverandre av de fleste av programmereren, er det tilrådelig å ikke forveksle disse to begrepene.

Når Java setter inn en standardkonstruktør, hvis programmet har noen variabler, tildeles de standardverdiene.

Tabellen nedenfor viser standardverdiene for hver datatype.

Type	Standardverdi
røye	u0000
Gjenstand	Referanse null
boolsk	falsk
byte	0
kort	0
int	0
lang	0L
flyte	0,0f
dobbelt	0,0d

Det følgende programmet gir 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); } }

Produksjon:

standard konstruktør - utgang

Typer konstruktører i Java

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

Typer konstruksjoner i Java

# 1) No-arg Constructor

En konstruktør uten argumenter kalles no-args eller no-argument constructor. Hvis vi ikke har en konstruktør uten argumenter, lager ikke Java-kompilatoren en standardkonstruktør for klassen.

Generelt sett, hvis vi definerer en konstruktør i klassen vår, blir ikke standardkonstruktøren satt inn av 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(); } }

Produksjon:

No-arg Constructor

I dette programmet har vi gitt en no-args konstruktør. Her skriver vi ut noen meldinger inkludert medlemsvariablene. Vi kan se i utdataene at meldingene fra konstruktøren vises som indikerer at no-args-konstruktøren er utført.

# 2) Parameterisert konstruktør

En parameterisert konstruktør har en eller flere parametere. Vi kan bruke en parameterisert konstruktør i tilfelle vi trenger å gi noen innledende verdier til medlemsvariabelen 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); } }

Produksjon:

Parameterisert konstruktør i Java

Her har vi gitt en parameterisert konstruktør som tar to argumenter, dvs. navn og id.

Inne i konstruktørlegemet tilordnes argumentene som verdier til henholdsvis medlemsvariablene navn og id.

Så når vi oppretter et nytt objekt ved hjelp av det nye nøkkelordet, overfører vi to verdier til klassenavnet etter et nytt nøkkelord. Dette indikerer at vi kaller den parameteriserte konstruktøren. Når vi viser medlemsvariablene, kan vi se at de har verdiene vi passerte mens vi opprettet objektet.

Overbelastede konstruktører i Java

Nå oppstår spørsmålet om en klasse kan ha mer enn en konstruktør, eller er det at en klasse bare kan ha en konstruktør?

Vi kan ha flere konstruktører i en klasse. En klasse kan ha så mange konstruktører i seg så lenge de er riktig overbelastet.

Så hva menes egentlig med overbelastning av konstruktører?

Constructor Overloading er en mekanisme som gjør det mulig for en klasse å ha så mange konstruktører slik at alle disse konstruktørene har forskjellige parameterlister enten det er avhengig av parametertyper eller rekkefølge av parametere.

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

Produksjon:

Overbelastet - utgang

I programmet ovenfor har vi en klasse som inneholder tre konstruktører. Den første konstruktøren er en ikke-arg-konstruktør, og deretter har vi en hver med henholdsvis ett argument og to argumenter. Da konstruktøren har en unik parameterliste, kan vi si at konstruktørene er overbelastet.

‘This ()’ Konstruktør I Java

I en klasse som inneholder flere konstruktører, hva om vi vil kalle en konstruktør fra en annen konstruktør i denne klassen?

For dette formålet bruker vi nøkkelordet “dette” inne i konstruktøren som vi vil kalle en annen konstruktør fra.

Så når en klasse har flere konstruktører, en ikke-arg-konstruktør og en parameterisert konstruktør, bruker vi ‘dette’ nøkkelordet for å kalle en parameterisert konstruktør fra ikke-arg-konstruktøren. Dette kalles også “Eksplisitt påkallelse av konstruktør”.

Hvorfor trenger vi dette nøkkelordet?

Vi trenger det fordi den eksplisitte påkallingen av konstruktører ikke er mulig direkte ved å bare bruke konstruktørnavnet.

Poeng å merke seg:

Nøkkelordet ‘dette’ skal være den første påstanden i den kallende konstruktøren.
Hvis en konstruktør har 'dette' nøkkelordet, kan det ikke ha 'super'. Dette betyr at konstruktøren kan ha 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(); } }

Produksjon:

‘Denne ()’ konstruktøren i Java

I programmet ovenfor har vi en ‘TestClass’ med to konstruktører. Vi kaller dette (“SoftwareTestingHelp”) fra no-args-konstruktøren. Dette er den eksplisitte påkallingen av den parameteriserte konstruktøren.

Copy Constructor In Java

Vi er klar over kopikonstruktøren i C ++. Kopikonstruktøren er en konstruktør som har en objektreferanse som argument, og et nytt objekt opprettes ved hjelp av dataene fra referanseobjektet.

C ++ gir en standard kopikonstruktør hvis en ikke er gitt i programmet.

Java gir også støtte for kopikonstruktør, men den gir ikke en standard kopikonstruktør.

Følgende Java-program demonstrerer kopikonstruktøren ved hjelp av det klassiske eksemplet på komplekse tall som har ekte 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; } }

Produksjon:

Kopier konstruktør i Java 7

Ovennevnte program har en 'Complex' klasse som har en parameterisert konstruktør og en kopikonstruktør. I hovedmetoden oppretter vi først et objekt c1 ved hjelp av en parameterisert konstruktør. Bruk deretter utsagnet nedenfor,

Complex c2 = new Complex (c1);

Ovennevnte uttalelse kaller kopikonstruktøren når referansen c1 overføres til konstruktøren mens den oppretter et nytt objekt c2.

Konstruktorkjetting i Java

Konstruktorkjetting er en prosess der en konstruktør kaller en annen konstruktør av samme klasse.

Selv når vi har arvet fra en baseklasse, blir konstruktøren av baseklassen påkalt først når underordnede klasseobjekt opprettes. Dette er også et eksempel på konstruktorkjetting.

I Java kan Constructor chaining oppnås ved å bruke to tilnærminger:

Innenfor samme klasse : Når vi ringer en konstruktør fra en annen konstruktør i samme klasse, så kan vi bruke dette () nøkkelordet.
Fra basisklasse: En konstruktør av basisklassen kan kalles av den avledede klassen ved hjelp av supernøkkelordet.

Hvorfor trenger vi konstruktorkjetting?

Når vi ønsker å utføre flere oppgaver i konstruktøren vår, i stedet for å utføre hver oppgave i en konstruktør, deler vi oppgavene i flere konstruktører, og deretter kaller vi konstruktører fra hverandre, noe som resulterer i konstruktorkjetting.

Nedenfor er noen av reglene som vi må følge når vi utfører konstruktorkjetting.

Konstruktorkjetting gjøres i hvilken som helst rekkefølge og vil gi de samme resultatene.
Uttrykket ‘dette’ nøkkelordet skal være det første uttrykket i konstruktøren.
Vi burde ha minst en konstruktør uten dette nøkkelordet.

Når vi har en arv i programmet vårt, kan vi også utføre konstruktorkjetting. I dette tilfellet vil underklassen ringe konstruktøren til baseklassen. Ved å gjøre denne underklassen begynner opprettelsen med initialiseringen av superklassemedlemmene.

Nå skal vi implementere konstruktorkjedingen i Java ved hjelp av ovennevnte tilnærminger.

# 1) Konstruktorkjetting innenfor 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); } }

Produksjon:

kjetting i samme klasse

Som allerede nevnt oppnår vi konstruktorkjetting innen samme klasse ved hjelp av ‘dette’ nøkkelordet. I programmet ovenfor har vi tre konstruktører, og vi kaller en konstruktør fra en annen ved hjelp av ‘dette’ nøkkelordet.

Fra basisklasse

Når en klasse arver en annen klasse, påkalles konstruktøren til overordnet klasse først når vi lager et objekt av en avledet klasse som er konstruktorkjetting.

Hvis vi eksplisitt vil kalle baseklasskonstruktøren i den avledede klassen, bør vi bruke nøkkelordet “super” for dette formålet. Ved å bruke nøkkelordet ‘super’ kan vi kalle superklassekonstruktørene i arvshierarkiet til vi når den øverste klassen.

Programmet nedenfor viser bruken av et 'super' nøkkelord for konstruktorkjetting.

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

Produksjon:

Fra basisklassen

I det ovennevnte programmet påkaller vi den parameteriserte konstruktøren for den avledede klassen med verdien “Java”. Denne konstruktøren har igjen et anrop til basisklassekonstruktøren ved hjelp av 'super (navn);' som utfører den parameteriserte konstruktøren til baseklassen.

ofte stilte spørsmål

Sp # 1) Hvordan lager du en konstruktør i Java?

Svar: Vi lager en konstruktør som en spesiell metode som har samme navn som klassenavnet. En konstruktør kan ikke ha returtype også. Den kan ha tilgangsmodifikatorer, men den kan ikke være endelig, statisk, abstrakt eller synkronisert.

test case eksempel for manuell testing

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

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

Q # 2) Hva er fordelen med en konstruktør i Java?

Svar: Ved hjelp av konstruktøren kan vi initialisere klassens medlemmer som det første øyeblikket objektet er opprettet. Constructor eliminerer behovet for å kalle normale metoder implisitt.

Vi kan utføre forskjellige oppgaver relatert til initialisering, startoppgaver osv. I konstruktøren når konstruktører påkalles i løpet av gjenstandsfasen.

Spørsmål 3) Hvorfor brukes konstruktører?

Svar: Konstruktører brukes hovedsakelig til å initialisere medlemmene i klassen og påkalles når objektet til klassen blir opprettet.

Q # 4) Kan Constructor være privat?

Svar: Ja, vi kan ha en privat konstruktør. Når konstruktøren er privat, kan klassen forhindres i å instantere.

Q # 5) Kan Constructor være endelig?

Svar: Nei, vi kan ikke ha en endelig konstruktør.

Konklusjon

I denne veiledningen har vi startet vår diskusjon om konstruktører i Java. Vi lærte det grunnleggende om konstruktøren, dets opprettelse og regler å følge. Vi diskuterte også kopikonstruktører i Java.

Standardkonstruktøren og typene konstruktører og konsepter som overbelastning av konstruktører og kjetting av konstruktører ble orientert med eksempler. Som en del av disse emnene så vi også bruken av ‘dette’ nøkkelordet i konstruktører.

=> Les gjennom Easy Java Training Series.

Java Constructor - Klasse, kopi og standardkonstruktører