Copia costruttore in java

Il costruttore di copia Java ci consente di generare un clone esatto di un oggetto esistente che appartiene alla stessa classe senza che la nuova copia sia influenzata dalle modifiche apportate all'oggetto originale. Utilizzando il costruttore di copie, la riusabilità del codice è migliorata. Le sue dimensioni sono ridotte e non è richiesto. Possiamo controllare completamente la creazione di oggetti usando un costruttore di copie. Inoltre, il compilatore Java non crea costruttori di copie in una classe per impostazione predefinita. Tuttavia, possiamo stabilirlo assegnando il contenuto dell'oggetto a un altro.

Esempio 1:

Prima di procedere con la dimostrazione del costruttore di copie, abbiamo il funzionamento del costruttore predefinito in Java. I costruttori predefiniti sono quei costruttori che non prendono parametri. Facciamo il programma di costruttore predefinito nel seguente:

Classe pubblica DefaultConst

DefaultConst ()

Sistema.fuori.println ("costruttore chiamato perché l'oggetto è creato");

Public Static Void Main (String Args [])

DefaultConst d = new defaultConst ();

Definiamo un programma che inizia con la costruzione della classe Java "DefaultConst". La classe "DefaultConst" è ulteriormente definita con il costruttore che è intitolato Lo stesso del nome della classe Java. Qui, creiamo questo costruttore che è vuoto ma contiene un'istruzione di stampa all'interno del blocco del costruttore. Quindi, distribuiamo il metodo Class Main () in cui si chiama questa classe. Per questo, dichiariamo l'oggetto "d" e utilizziamo defaultconst () lì. Da lì, viene eseguito defaultConst ().

Il costruttore predefinito non ha fornito un parametro ma l'istruzione di stampa viene eseguita creando il suo oggetto nel metodo principale ().

Esempio 2:

La dimostrazione del costruttore è realizzata nell'esempio precedente. Ora c'è un costruttore di copie di esempio. I costruttori di copia Java prendono un oggetto corrente come input e producono una copia dell'oggetto definito.

Class ComplexNumber
Private Double Real, IMG;
Public ComplexNumber (Double Real, Double IMG)

Questo.reale = reale;
Questo.img = img;

ComplexNumber (complexNumbercn)

Sistema.fuori.println ("all'interno di un costruttore di copie");
reale = cn.vero;
img = cn.IMG;

@Override Public String toString ()

restituire "(" + reale + " +" + img + "i)";


Classe pubblica Main
public static void main (string [] args)

ComplexNumber CN1 = Nuovo complesso Number (3, 9);
ComplexNumber CN2 = new ComplexNumber (CN1);
ComplexNumber CN3 = CN2;
Sistema.fuori.println (CN2);

Abbiamo un programma precedente in cui creiamo la classe di Java "complesso". La classe "ComplexNumber" contiene attributi che sono dichiarati "reali" e "IMG". Successivamente, definiamo un costruttore nella classe "complesso" in cui gli attributi della classe vengono passati come argomenti. Quindi, utilizziamo la parola chiave "questa" per fare riferimento agli oggetti attuali, "reale" e "img". Successivamente, utilizziamo il costruttore di copie "complessoNumber ()" che ha un oggetto parametrico "CN" della classe "complesso number". Il costruttore viene dichiarato con gli oggetti della classe. I valori delle variabili di istanza vengono inizializzati con quelli dell'oggetto ricevuto.

Successivamente, eseguiamo un'operazione di sovraccarico ToString () sugli oggetti di classe "Real" e "IMG". La classe principale "ComplexNumber" è implementata con il metodo principale (). Qui, creiamo l'oggetto "CN1" per invocare la classe complessoNumber (). Impostamo i valori per le variabili "reali" e "img" nella classe complesso number (). Successivamente, dichiariamo l'oggetto "CN2" in cui il costruttore di copia è coinvolto quando il "CN2" viene passato al suo interno. Quindi, dichiariamo un altro oggetto "CN3" per fare riferimento all'oggetto "CN2". Alla fine, chiamiamo il metodo ToString () dell'oggetto "CN2" per stampare i valori.

Il numero complesso di valori reali e immaginari sia per l'oggetto esistente che per l'oggetto copiato sono gli stessi. Il costruttore di copie non influisce sulla data originale degli oggetti.

Esempio 3:

Il costruttore di copie viene appena utilizzato per creare una copia duplicata delle variabili esistenti della classe. Ora, il costruttore di copie viene creato per le classi di tipo referenziate. Attraverso il costruttore di copie, possiamo aggiungere gli attributi di una classe a un'altra classe.

dipendente di classe

stringa privata ename;
Double Esalary privato;
Indirizzo privato Eaddress;
Employee (String Ename, Double Esalary, Indirizzo EADD)

Questo.ename = ename;
Questo.Esalary = Esalary;
Questo.eaddress = eadd;

Dipendente (dipendente EMP)

Questo.ename = emp.getEname ();
Questo.Esalary = emp.getSalary ();
Questo.eaddress = emp.getEaddress ();

Indirizzo pubblico getEADdress ()
restituire Eaddress;

public void seteAddress (indirizzo eaddress)
Questo.eaddress = eaddress;

public String getEname ()
restituire ename;

public void setename (stringen ename)
Questo.ename = ename;

public double getSalary ()
restituire Esalary;

public void setaSalary (doppio esalario)
Questo.Esalary = Esalary;


Indirizzo di classe

Int Codice postale;
Indirizzo (int emp)

Questo.PostCode = EMP;


Classe pubblica Main

public static void main (string [] args)

Indirizzo EADD = nuovo indirizzo (100002);
Dipendente EMP1 = nuovo dipendente ("Bella", 85000.0, EADD);
Employee CloneOFemp1 = nuovo dipendente (EMP1);
eadd.Codice postale = 200003;
Sistema.fuori.println ("Employee-1:" + EMP1.getEaddress ().codice postale);
Sistema.fuori.Print ("Employee-2:" + CloneOFemp1.getEaddress ().codice postale);

Il programma è istituito con la classe Java "dipendente" e abbiamo impostato gli attributi privati ​​della classe. Questi attributi includono la stringa ename, il doppio tipo eSalary e l'indirizzo eaddress. Quindi, costruiamo il costruttore parametrizzato della classe "dipendente" che prende gli attributi di classe esistenti come oggetti dei parametri. Nel costruttore parametrizzato, chiamiamo la parola chiave K "questa" che fa riferimento direttamente all'istanza corrente.

Successivamente, definiamo un costruttore di copie che porta il parametro "EMP" per fare riferimento all'oggetto della classe "dipendente". Specifichiamo i metodi getter per ciascuno degli oggetti. Successivamente, chiamiamo ciascuno dei metodi getter e metodi di setter che controllano il valore su ciascun oggetto di riferimento della classe. Successivamente, creiamo la seconda classe di un programma che è "indirizzo" che ha il membro "codice postale". Inoltre, definiamo il costruttore di copie all'interno della classe che prende il riferimento dell'oggetto della classe dei dipendenti "EMP" di tipo int. L'oggetto postale della classe "indirizzo" è impostato con l'oggetto "EMP".

Ora, l'oggetto "EMP" della classe dei dipendenti e l'oggetto "codice postale" della classe di indirizzi forniscono gli stessi dati. Quindi, abbiamo una classe "principale" in cui il metodo principale () viene distribuito per assegnare i valori agli attributi dati ed eseguirli. Chiamiamo la classe dell'indirizzo () nell'oggetto "EADD" e impostiamo il valore Eaddress su di esso. All'interno dell'oggetto "EMP", i valori per gli altri campi della classe dei dipendenti sono anche inizializzati. Inoltre, dichiariamo un oggetto di riferimento "cloneofemp1" che indica un oggetto "EMP1" che viene generato dalla nuova parola chiave chiamata "dipendente" che utilizza un costruttore di copie per copiare i dati dal primo oggetto.

Quindi, modifichiamo il valore dell'indirizzo che influisce anche l'oggetto clone "EADD". L'istruzione di stampa visualizza i risultati della modifica del valore dell'oggetto clone.

Viene modificato l'indirizzo dell'oggetto del costruttore di copie che viene visualizzato sul prompt Java:

Esempio 4:

L'oggetto copiato può anche essere creato senza il costruttore di copie semplicemente dando il contenuto di un oggetto all'altro. Cloniamo gli oggetti di classe senza utilizzare il costruttore di copie.

Importa Java.util.Scanner;
Prodotto di classe pubblica
public int pid;
Prezzo di galleggiamento pubblico;
pname di stringa pubblica;
Public Product ()
Prodotto pubblico (int ID, string pname, prezzo float)
Questo.pid = pid;
Questo.pname = pname;
Questo.prezzo = prezzo;

public void ProductView ()
Sistema.fuori.println ("ID prodotto:" + questo.PID);
Sistema.fuori.println ("Nome prodotto:" + questo.pname);
Sistema.fuori.println ("prezzo del prodotto:" + questo.prezzo);

public static void main (string [] args)
Scanner myscan = new scanner (sistema.In);
Sistema.fuori.println ("immettere il nome del prodotto");
String pname = myscan.Prossimo();
Sistema.fuori.println ("immettere l'ID prodotto");
int pid = myscan.NextInt ();
Sistema.fuori.println ("immettere il prezzo del prodotto");
int prezzo = myscan.NextInt ();
Prodotto prodotto = nuovo prodotto (PID, pname, prezzo);
Sistema.fuori.println ("dati dell'oggetto originale");
Prodotto.ProductView ();
Product Product_Copy = new Product ();
Product_Copy.PID = Prodotto.PID;
Product_Copy.prezzo = prodotto.prezzo;
Product_Copy.pname = prodotto.pname;
Sistema.fuori.println ("dati dell'oggetto copiato");
Prodotto.ProductView ();

Il programma è definito con la classe pubblica del "prodotto" in cui dichiariamo i suoi oggetti che sono PID, PNAME e PPRICE di un tipo diverso. Dopodiché, creiamo solo il costruttore per la classe specificata senza argomenti. Successivamente, creiamo il costruttore parametrizzato della classe in cui tutti gli attributi della classe sono dichiarati come un argomento. All'interno del costruttore di classe, utilizziamo la variabile di riferimento "questo" con gli attributi di classe che si riferisce all'oggetto corrente del costruttore.

Quindi, abbiamo la definizione della funzione "ProductView" della classe "Product" per visualizzare o stampare i valori di ciascuno degli attributi di classe. Successivamente, utilizziamo il metodo principale () in cui utilizziamo la classe scanner per ottenere i valori per gli attributi della classe "prodotto" per formare l'utente. Una volta che l'utente inserisce il valore dell'attributo, i valori originali per l'istanza di classe vengono visualizzati dalla funzione ProductView (). Quindi, creiamo l'oggetto "Product_Copy" in cui invochiamo la classe "Product ()". Ora, Product_Copy ha il contenuto della classe di prodotti. Quindi, copiamo gli attributi della classe "Product" con i nuovi oggetti di Product_Copy. Sia gli attributi di classe che l'attributo Product_Copy contengono gli stessi valori.

I valori dell'oggetto originale e dell'oggetto copiato sono gli stessi senza usare il costruttore di copie.

Conclusione

I costruttori di copie di Java sono un modo efficiente e diretto per duplicare gli oggetti. Possono fare cloni sia poco profondi che profondi. Abbiamo fornito un programma eseguibile dei costruttori di copie in cui vengono realizzati i diversi scenari. Inoltre, i costruttori di copie hanno lo svantaggio di essere ereditati. Ma possiamo aggirare questa difficoltà includendo un metodo che innesca il costruttore di copie nella base e le classi derivate.