Kopieren Sie den Konstruktor in Java
Beispiel 1:
Bevor wir mit der Demonstration des Kopierkonstruktors fortfahren, haben wir die Arbeit des Standardkonstruktors in Java. Die Standardkonstruktoren sind die Konstrukteure, die keine Parameter entgegennehmen. Lassen Sie uns das Standardkonstruktorprogramm in Folgendes haben:
öffentliche Klasse StandardConstDefaultConst ()
System.aus.println ("Konstruktor genannt, weil Objekt erstellt wird");
öffentliche statische Leere Main (String args [])
DefaultConst d = new DefaultConst ();
Wir definieren ein Programm, das mit der Konstruktion der Java -Klasse „DefaultConst“ beginnt. Die Klasse „DefaultConst“ wird weiter mit dem Konstruktor definiert, der den Namen der Java -Klasse berechtigt hat. Hier erstellen wir diesen Konstruktor, der leer ist, aber eine Druckanweisung im Konstruktorblock enthält. Dann stellen wir die Klasse main () ein, bei der diese Klasse aufgerufen wird. Dafür deklarieren wir das "D" -Objekt und verwenden dort den DefaultConst () dort. Von dort aus wird der Standardconst () ausgeführt.
Der Standardkonstruktor hat keinen Parameter angegeben, aber die Druckanweisung wird ausgeführt, indem sein Objekt in der Main () -Methode erstellt wird.
Beispiel 2:
Die Demonstration des Konstruktors wird im vorherigen Beispiel erreicht. Jetzt gibt es einen Beispielkopiekonstruktor. Die Java -Kopiekonstruktoren nehmen ein aktuelles Objekt als Eingabe und erstellen eine Kopie des definierten Objekts.
Klasse ComplexNumberprivat doppelt real, img;
Public ComplexNumber (doppelte echte, doppelte IMG)
Das.real = real;
Das.img = img;
Komplexnummer (Komplexnummer)
System.aus.println ("Innerhalb eines Kopierkonstruktors");
real = cn.real;
IMG = CN.img;
@Override Public String toString ()
return "(" + real + " +" + img + "i)";
Hauptklasse Haupt
öffentliche statische Leere Main (String [] Args)
ComplexNumber CN1 = NEU COMPLECTNUMBER (3, 9);
ComplexNumber CN2 = New ComplexNumber (CN1);
Komplexnummer cn3 = cn2;
System.aus.println (cn2);
Wir haben ein früheres Programm, in dem wir die „Komplexnummer“ -Klasse von Java erstellen. Die Klasse „ComplexNumber“ enthält Attribute, die als „real“ und „img“ deklariert werden. Danach definieren wir einen Konstruktor in der Klasse „ComplexNumber“, bei der die Klassenattribute als Argumente übergeben werden. Dann verwenden wir das Schlüsselwort "This", um auf die aktuellen Objekte "Real" und "IMG" zu verweisen,. Danach verwenden wir den Konstruktor „ComplexNumber ()“, der über ein parametrisches „CN“ -Djekt der Klasse „ComplexNumber“ verfügt. Der Konstruktor wird mit den Objekten der Klasse deklariert. Die Werte der Instanzvariablen werden mit denen aus dem empfangenen Objekt initialisiert.
Als Nächst. Die Hauptklasse „Komplexnummer“ wird mit der Main () -Methode implementiert. Hier erstellen wir das "CN1" -Objekt, um die Komplexnummer () -Klasse aufzurufen. Wir setzen die Werte für die Variablen „Real“ und „IMG“ in der Klasse ComplexNumber (). Danach deklarieren wir das „CN2“ -Objekt, an dem der Kopierkonstruktor beteiligt ist, wenn der „CN2“ darin weitergeleitet wird. Dann deklarieren wir ein weiteres "CN3". Am Ende nennen wir die Methode toString () des „CN2“ -Fjekts, um die Werte zu drucken.
Die komplexe Anzahl realer und imaginärer Werte sowohl für das vorhandene als auch für das kopierte Objekt sind dasselbe. Der Kopierkonstruktor wirkt sich nicht auf das ursprüngliche Datum der Objekte aus.
Beispiel 3:
Der Kopierkonstruktor wird nur verwendet, um eine doppelte Kopie der vorhandenen Variablen der Klasse zu erstellen. Jetzt wird der Kopierkonstruktor für referenzierte Typklassen erstellt. Über den Kopierkonstruktor können wir die Attribute einer Klasse einer anderen Klasse hinzufügen.
Klassenangestellterprivate String ENNAME;
privates doppeltes Esalary;
private Adresse eaddress;
Mitarbeiter (String Ename, doppelter Esalary, Adresse EADD)
Das.Ename = EName;
Das.Esalary = Esalary;
Das.eaddress = eadd;
Mitarbeiter (Mitarbeiter EMP)
Das.Ename = emp.GetEname ();
Das.Esalary = emp.Getesalary ();
Das.eaddress = emp.GETEADDRESS ();
öffentliche Adresse getaderAddress ()
Eaddress zurückgeben;
public void seteaddress (Adresse eaddress)
Das.eaddress = eaddress;
public String getename ()
ENAME zurückgeben;
public void setEname (String Ename)
Das.Ename = EName;
public double getesalary ()
Rückkehr Esalary;
public void setesalary (doppelte Esalary)
Das.Esalary = Esalary;
Klassenadresse
int Postleitzahl;
Adresse (int emp)
Das.postcode = emp;
Hauptklasse Haupt
öffentliche statische Leere Main (String [] Args)
Adresse EADD = neue Adresse (100002);
Mitarbeiter EMP1 = neuer Mitarbeiter ("Bella", 85000.0, eadd);
Mitarbeiter kloneofemp1 = neuer Mitarbeiter (EMP1);
eadd.Postleitzahl = 200003;
System.aus.println ("Mitarbeiter-1:" + EMP1.GETEADDRESS ().Postleitzahl);
System.aus.print ("Mitarbeiter-2:" + kloneofemp1.GETEADDRESS ().Postleitzahl);
Das Programm wird mit der Java -Klasse „Mitarbeiter“ eingerichtet und wir setzen die privaten Attribute der Klasse. Diese Attribute umfassen den String Ename, den doppelten Typ Esalary und die Adresse eaddress. Anschließend konstruieren wir den parametrisierten Konstruktor der Klasse „Mitarbeiter“, der die vorhandenen Klassenattribute als Parameterobjekte nimmt. Im parametrisierten Konstruktor nennen wir das Keyword von K „dieses“, das die aktuelle Instanz direkt verweist.
Als Nächst. Wir geben die Getter -Methoden für jedes der Objekte an. Danach rufen wir jede der Getter -Methoden und Setter -Methoden auf, die den Wert gegen jedes Referenzobjekt der Klasse steuern. Als nächstes erstellen wir die zweite Klasse eines Programms, die "Adresse" ist, die das Mitglied "Postleitzahl" hat. Außerdem definieren wir den Kopierkonstruktor in der Klasse, der die Referenz des Employee Class -Objekts „EMP“ des Typs int nimmt. Das Postleitungsobjekt der "Adress" -Kläufe wird mit dem "EMP" -Objekt festgelegt.
Jetzt liefert das „EMP“ -Opjekt der Mitarbeiterklasse und das Objekt „Postleitzahl“ der Adressklasse die gleichen Daten. Dann haben wir eine Hauptklasse, in der die main () -Methode bereitgestellt wird, um die Werte den angegebenen Attributen zuzuweisen und sie auszuführen. Wir nennen die Adresse () Klasse () im „EADD“ -Objekt und setzen den Eaddress -Wert darauf. Innerhalb des „EMP“ -Objekts werden die Werte für die anderen Felder der Mitarbeiterklasse ebenfalls initialisiert. Darüber hinaus deklarieren wir ein Referenzobjekt "Cloneofemp1", das auf ein „EMP1“ -Objekt verweist, das vom neuen Schlüsselwort „Mitarbeiter“ generiert wird, das einen Kopierkonstruktor verwendet, um die Daten aus dem ersten Objekt zu kopieren.
Dann ändern wir den Wert der Adresse, die auch das EADD -Klonobjekt beeinflusst. Die Druckanweisung zeigt die Ergebnisse der Änderung des Wertes des Klonobjekts an.
Die Adresse des Copy Constructor -Objekts wird geändert, der in der Java -Eingabeaufforderung angezeigt wird:
Beispiel 4:
Das kopierte Objekt kann auch ohne den Kopierkonstruktor erstellt werden. Lassen Sie uns die Klassenobjekte klonen, ohne den Kopierkonstruktor zu verwenden.
Java importieren.Util.Scanner;PUBLIC CLASSE PRODUKT
public int pid;
öffentlicher Schwimmerpreis;
öffentliche String -Pname;
public product ()
Öffentliches Produkt (int ID, String Pname, Float Price)
Das.PID = PID;
Das.pname = pname;
Das.Preis = Preis;
public void productView ()
System.aus.println ("Produkt -ID:" + dies.pid);
System.aus.println ("Produktname:" + dies.pname);
System.aus.println ("Produktpreis:" + dies.Preis);
public static void main (String [] args)
Scanner myscan = neuer Scanner (System.In);
System.aus.println ("den Produktnamen eingeben");
String pname = myscan.nächste();
System.aus.println ("die Produkt -ID eingeben");
int pid = myscan.NextInt ();
System.aus.println ("den Produktpreis eingeben");
int price = myscan.NextInt ();
Produktprodukt = neues Produkt (PID, Pname, Preis);
System.aus.println ("Daten des ursprünglichen Objekts");
Produkt.productView ();
Product product_copy = new Product ();
product_copy.PID = Produkt.PID;
product_copy.Preis = Produkt.Preis;
product_copy.Pname = Produkt.pname;
System.aus.println ("Daten des kopierten Objekts");
Produkt.productView ();
Das Programm ist mit der öffentlichen Klasse „Produkt“ definiert, in der wir seine Objekte deklarieren, die PID, PNAME und PPRICE eines anderen Typs sind. Danach erstellen wir nur den Konstruktor für die angegebene Klasse ohne Argumente. Als nächstes erstellen wir den parametrisierten Konstruktor der Klasse, bei dem alle Klassenattribute als Argument deklariert werden. Innerhalb des Klassenkonstruktors verwenden wir die Referenzvariable „this“ mit den Klassenattributen, die sich auf das aktuelle Objekt des Konstruktors beziehen.
Anschließend haben wir die Funktion "productView" -Funktion der "Produkt" -Klasse zum Anzeigen oder Drucken der Werte der einzelnen Klassenattribute. Danach verwenden wir die Main () -Methode, bei der wir die Scannerklasse verwenden, um die Werte für die Attribute der „Produkt“ -Klass zu erhalten, um den Benutzer zu bilden. Sobald der Benutzer den Wert des Attributs eingibt, werden die ursprünglichen Werte für die Klasseninstanz aus der Funktion productView () angezeigt. Dann erstellen wir das Objekt „product_copy“, in dem wir die Klasse „Product ()“ aufrufen. Jetzt hat die product_copy den Inhalt der Produktklasse. Daher kopieren wir die Attribute der „Produkt“ -Klasse mit den neuen Objekten der product_copy. Sowohl die Klassenattribute als auch das Product_Copy -Attribut enthält die gleichen Werte.
Die Werte des ursprünglichen Objekts und des kopierten Objekts sind gleich, ohne den Kopierkonstruktor zu verwenden.
Abschluss
Die Kopiekonstruktoren von Java sind eine effiziente und unkomplizierte Möglichkeit, die Objekte zu duplizieren. Sie können sowohl flache als auch tiefe Klone machen. Wir haben ein ausführbares Programm der Kopierkonstruktoren gegeben, in denen die verschiedenen Szenarien durchgeführt werden. Darüber hinaus haben Kopiekonstruktoren den Nachteil, vererbt zu werden. Aber wir können diese Schwierigkeit umgehen, indem wir eine Methode einbeziehen, die den Kopierkonstruktor in die Basis und abgeleitete Klassen auslöst.