Kopier konstruktør i Java

Java Copy Constructor gjør oss i stand til å generere en eksakt klone av et eksisterende objekt som tilhører samme klasse uten at den nye kopien blir berørt av endringer som er gjort i det opprinnelige objektet. Ved å bruke kopikonstruktøren forbedres gjenbrukbarheten til koden. Størrelsen er redusert, og typekasting er ikke nødvendig. Vi kan kontrollere objektopprettelsen fullt ut ved hjelp av en kopikonstruktør. I tillegg oppretter ikke Java -kompilatoren noen kopikonstruktører i en klasse som standard. Vi kan imidlertid etablere det ved å tilordne objektinnholdet til et annet.

Eksempel 1:

Før vi fortsetter med kopikonstruktørdemonstrasjonen, har vi arbeidet med standardkonstruktøren i Java. Standard konstruktører er de konstruktørene som ikke tar noen parametere. La oss ha standardkonstruktørprogrammet i følgende:

Public Class StandardConst

StandardConst ()

System.ute.println ("konstruktør kalt fordi objekt opprettes");

public static void main (String args [])

StandardConst D = new StandardConst ();

Vi definerer et program som begynner med byggingen av "StandardConst" Java -klassen. "StandardConst" -klassen er ytterligere definert med konstruktøren som har tittelen den samme som navnet på Java -klassen. Her oppretter vi denne konstruktøren som er tom, men inneholder en utskriftsuttalelse i konstruktørblokken. Deretter distribuerer vi klassen Main () -metoden der denne klassen heter. For dette erklærer vi “D” -objektet og bruker standardkonst () der. Derfra blir standardkonst () utført.

Standardkonstruktøren har ikke gitt en parameter, men utskriftserklæringen utføres ved å lage objektet i Main () -metoden.

Eksempel 2:

Demonstrasjonen av konstruktøren oppnås i det tidligere eksemplet. Nå er det et eksempel på Copy Constructor. Java Copy -konstruktørene tar et nåværende objekt som inngang og produserer en kopi av det definerte objektet.

Klassekompleksnummer
privat dobbel ekte, IMG;
public ComplexNumber (Double Real, Double IMG)

dette.ekte = ekte;
dette.img = img;

ComplexNumber (ComplexNumberCn)

System.ute.println ("Inne i en kopikonstruktør");
ekte = cn.ekte;
IMG = CN.IMG;

@Override Public String ToString ()

return "(" + ekte + " +" + img + "i)";


offentlig klasse Main
public static void main (String [] args)

ComplexNumber CN1 = New ComplexNumber (3, 9);
ComplexNumber CN2 = New ComplexNumber (CN1);
ComplexNumber Cn3 = CN2;
System.ute.println (CN2);

Vi har et tidligere program der vi lager "ComplexNumber" -klassen til Java. "ComplexNumber" -klassen inneholder attributter som er erklært som "ekte" og "IMG". Etter det definerer vi en konstruktør i "ComplexNumber" -klassen der klasseattributtene blir bestått som argumenter. Deretter bruker vi "dette" nøkkelordet for å referere til gjeldende objekter, "ekte" og "img". Etter det bruker vi “ComplexNumber ()” Copy Constructor som har et parametrisk “CN” -objekt av “ComplexNumber” -klassen. Konstruktøren er erklært med objektene i klassen. Verdiene for forekomstvariablene initialiseres med de fra det mottatte objektet.

Deretter utfører vi en toString () overstyring av operasjonen på "ekte" og "IMG" klasseobjekter. Hovedklassen "ComplexNumber" er implementert med Main () -metoden. Her oppretter vi “CN1” -objektet for å påkalle ComplexNumber () -klassen. Vi setter verdiene for de "virkelige" og "IMG" -variablene i ComplexNumber () -klassen. Etter dette erklærer vi “CN2” -objektet der kopikonstruktøren er involvert da “CN2” blir passert inne i den. Deretter erklærer vi et annet “CN3” -objekt for å referere til “CN2” -objektet. Til slutt kaller vi ToString () -metoden til “CN2” -objektet for å skrive ut verdiene.

Det komplekse antallet virkelige og imaginære verdier for både det eksisterende objektet og det kopierte objektet er det samme. Kopikonstruktøren påvirker ikke den opprinnelige datoen for objektene.

Eksempel 3:

Kopikonstruktøren brukes nettopp til å lage en duplikat kopi av de eksisterende variablene i klassen. Nå er kopikonstruktøren opprettet for refererte typeklasser. Gjennom kopikonstruktøren kan vi legge til attributtene til en klasse i en annen klasse.

klasseansatt

privat streng ename;
privat dobbelt esalary;
privat adresse eaddress;
Ansatt (String Ename, Double Esalary, Adresse EADD)

dette.ename = ename;
dette.Esalary = Esalary;
dette.EADDress = EADD;

Ansatt (ansatt EMP)

dette.ename = emp.getEname ();
dette.Esalary = emp.getSalary ();
dette.EADDRESS = EMP.getEaddress ();

offentlig adresse getEaddress ()
Returner eaddress;

public void seteAddress (adresse eaddress)
dette.eaddress = eaddress;

public String getEname ()
Returner ename;

public void setName (String ename)
dette.ename = ename;

public double getesalary ()
returner esalary;

public void setesalary (dobbel esalary)
dette.Esalary = Esalary;


klasseadresse

int postnummer;
Adresse (int emp)

dette.postnummer = emp;


Offentlig klasse Main

public static void main (String [] args)

Adresse EADD = ny adresse (100002);
Ansatt EMP1 = Ny ansatt ("Bella", 85000.0, eadd);
Ansatt CloneOfEMP1 = ny ansatt (EMP1);
eadd.postnummer = 200003;
System.ute.Println ("Ansatt-1:" + EMP1.getEaddress ().postnummer);
System.ute.Print ("Ansatt-2:" + CloneOfemp1.getEaddress ().postnummer);

Programmet er etablert med "ansatt" Java -klassen, og vi setter de private attributtene til klassen. Disse attributtene inkluderer String Ename, Double Type Esalary og Adresse EADDRESS. Deretter konstruerer vi den parameteriserte konstruktøren av "ansatt" -klassen som tar de eksisterende klasseattributtene som parameterobjekter. I den parameteriserte konstruktøren kaller vi k “dette” nøkkelordet som refererer til gjeldende forekomst direkte.

Deretter definerer vi en kopikonstruktør som tar "EMP" -parameteren for å referere til gjenstanden for "ansattes" -klassen. Vi spesifiserer getter -metodene for hvert av objektene. Etter det kaller vi hver av getter -metodene og settermetoder som kontrollerer verdien mot hvert referanseobjekt i klassen. Deretter lager vi et programs andre klasse som er "adresse" som har "postnummer" -medlemmet. Vi definerer også kopikonstruktøren i klassen som tar referansen til ansattes klasseobjekt "emp" av typen int. Postnummerobjektet til "Adresse" -klassen er satt med "EMP" -objektet.

Nå gir "EMP" -objektet i ansatteklassen og "postnummer" -objektet i adresseklassen de samme dataene. Deretter har vi en "Main" -klasse der Main () -metoden er distribuert for å tilordne verdiene til de gitte attributtene og utføre dem. Vi kaller adresse () -klassen i "EADD" -objektet og setter EADDress -verdien til den. Innenfor "EMP" -objektet blir også verdiene for de andre feltene i ansatteklassen initialisert. Videre erklærer vi et referanseobjekt “CloneOfEMP1” som peker på et “Emp1” -objekt som genereres av det nye nøkkelordet kalt “Ansatt” som bruker en kopikonstruktør for å kopiere dataene fra det første objektet.

Deretter endrer vi verdien av adressen som også påvirker "EADD" -klonobjektet. Utskriftsuttalelsen viser resultatene av å endre verdien av klonobjektet.

Adressen til Copy Constructor -objektet blir endret som vises på Java -ledeteksten:

Eksempel 4:

Det kopierte objektet kan også opprettes uten kopikonstruktøren ved å bare gi innholdet i det ene objektet til det andre. La oss klone klasseobjektene uten å bruke kopikonstruktøren.

Importer Java.util.Skanner;
offentlig klasse produkt
offentlig int pid;
offentlig flytepris;
public String PName;
offentlig produkt ()
offentlig produkt (int id, streng pname, float price)
dette.PID = PID;
dette.PNAME = PNAME;
dette.Pris = pris;

public void ProductView ()
System.ute.println ("Produkt ID:" + dette.pid);
System.ute.println ("Produktnavn:" + dette.pname);
System.ute.Println ("Produktpris:" + dette.pris);

public static void main (String [] args)
Skanner myscan = ny skanner (system.i);
System.ute.println ("Skriv inn produktnavnet");
String pName = myscan.neste ();
System.ute.println ("Enter produkt -IDen");
int pid = myscan.nextInt ();
System.ute.Println ("Angi produktprisen");
int pris = myscan.nextInt ();
Produktprodukt = nytt produkt (PID, PNAME, PRIS);
System.ute.println ("Data fra det opprinnelige objektet");
produkt.ProductView ();
Produktprodukt_copy = nytt produkt ();
PRODUKT_COPY.PID = produkt.PID;
PRODUKT_COPY.Pris = produkt.pris;
PRODUKT_COPY.PNAME = Produkt.PNAME;
System.ute.println ("Data fra det kopierte objektet");
produkt.ProductView ();

Programmet er definert med den "produkt" offentlige klasse der vi erklærer dets objekter som er PID, PNAME og PPRICE av en annen type. Etter det oppretter vi bare konstruktøren for den spesifiserte klassen uten argumenter. Deretter lager vi den parameteriserte konstruktøren av klassen der alle klasseattributtene er erklært som et argument. Inne i klassekonstruktøren bruker vi "denne" referansevariabelen med klasseattributtene som refererer til konstruktørens nåværende objekt.

Deretter har vi "ProductView" -funksjonsdefinisjonen av "Produkt" -klassen for å vise eller skrive ut verdiene til hver av klasseattributtene. Etter dette bruker vi Main () -metoden der vi bruker skannerklassen for å få verdiene for "produkt" -klasseattributtene for å danne brukeren. Når brukeren har lagt inn verdien av attributtet, vises de opprinnelige verdiene for klasseforekomsten fra ProductView () -funksjonen. Deretter oppretter vi "Product_Copy" -objektet der vi påkaller "Product ()" -klassen. Nå har produkt_kopien innholdet i produktklassen. Så vi kopierer attributtene til "produkt" -klassen med de nye objektene til Product_Copy. Både klasseattributtene og produkt_copy -attributtet har de samme verdiene.

Verdiene til det opprinnelige objektet og det kopierte objektet er de samme uten å bruke kopikonstruktøren.

Konklusjon

Kopikonstruktørene av Java er en effektiv og grei måte å duplisere objektene. De kan lage både grunne og dype kloner. Vi har gitt et kjørbart program for kopikonstruktørene der de forskjellige scenariene er oppnådd. Dessuten har kopikonstruktører ulempen med å bli arvet. Men vi kan komme oss rundt denne vanskeligheten ved å inkludere en metode som utløser kopikonstruktøren i basen og avledede klasser.