Copier le constructeur en java

Le constructeur de copie Java nous permet de générer un clone exact d'un objet existant qui appartient à la même classe sans que la nouvelle copie soit affectée par les modifications apportées à l'objet d'origine. En utilisant le constructeur de copie, la réutilisabilité du code est améliorée. Sa taille est réduite et la dactylographie n'est pas requise. Nous pouvons contrôler pleinement la création d'objets à l'aide d'un constructeur de copie. De plus, le compilateur Java ne crée aucun constructeur de copie dans une classe par défaut. Cependant, nous pouvons l'établir en attribuant le contenu de l'objet à un autre.

Exemple 1:

Avant de procéder à la démonstration du constructeur de copie, nous avons le fonctionnement du constructeur par défaut en Java. Les constructeurs par défaut sont les constructeurs qui ne prennent aucun paramètre. Ayons le programme de constructeur par défaut dans ce qui suit:

classe publique DefaultConst

DefaultConst ()

Système.dehors.println ("Constructeur appelé parce que l'objet est créé");

public static void main (String args [])

DefaultConst d = new defaultConst ();

Nous définissons un programme qui commence par la construction de la classe Java «DefaultConst». La classe «DefaultConst» est en outre définie avec le constructeur qui est intitulé le même que le nom de la classe Java. Ici, nous créons ce constructeur vide mais contient une déclaration d'impression à l'intérieur du bloc du constructeur. Ensuite, nous déployons la méthode de classe main () où cette classe est appelée. Pour cela, nous déclarons l'objet «D» et utilisons le defaultConst (). À partir de là, le defaultConst () est exécuté.

Le constructeur par défaut n'a pas donné de paramètre mais l'instruction d'impression est exécutée en créant son objet dans la méthode principale ().

Exemple 2:

La démonstration du constructeur est accomplie dans l'exemple précédent. Maintenant, il y a un exemple de constructeur de copie. Les constructeurs de copie Java prennent un objet actuel en entrée et produisent une copie de l'objet défini.

classe complexNumber
Double privé Real, IMG;
Public ComplexNumber (double réel, double IMG)

ce.réel = réel;
ce.img = img;

ComplexNumber (complexNumbercn)

Système.dehors.println ("à l'intérieur d'un constructeur de copie");
réel = cn.réel;
img = cn.IMG;

@Override public String toString ()

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


classe publique Main
public static void main (String [] args)

ComplexNumber CN1 = nouveau complexNumber (3, 9);
ComplexNumber CN2 = nouveau complexNumber (CN1);
ComplexNnumber cn3 = cn2;
Système.dehors.println (cn2);

Nous avons un programme précédent où nous créons la classe «complexNumber» de Java. La classe «complexNumber» contient des attributs qui sont déclarés «réels» et «IMG». Après cela, nous définissons un constructeur dans la classe «complexNumber» où les attributs de classe sont passés comme arguments. Ensuite, nous utilisons le mot-clé «ce» pour désigner les objets actuels, «réel» et «IMG». Après cela, nous utilisons le constructeur de copie «complexNumber ()» qui a un objet «CN» paramétrique de la classe «complexNumber». Le constructeur est déclaré avec les objets de la classe. Les valeurs des variables d'instance sont initialisées avec celles de l'objet reçu.

Ensuite, nous effectuons une opération de remplacement toString () sur les objets de classe «réel» et «IMG». La classe principale «complexNumber» est implémentée avec la méthode principale (). Ici, nous créons l'objet «CN1» pour invoquer la classe complexNumber (). Nous définissons les valeurs pour les variables «réelles» et «IMG» dans la classe complexNumber (). Après cela, nous déclarons l'objet «CN2» où le constructeur de copie est impliqué comme le «CN2» est passé à l'intérieur. Ensuite, nous déclarons un autre objet «CN3» pour référencer l'objet «CN2». En fin de compte, nous appelons la méthode toString () de l'objet «CN2» pour imprimer les valeurs.

Le nombre complexe de valeurs réelles et imaginaires pour l'objet existant et l'objet copié sont les mêmes. Le constructeur de copie n'affecte pas la date d'origine des objets.

Exemple 3:

Le constructeur de copie est juste utilisé pour créer une copie en double des variables existantes de la classe. Maintenant, le constructeur de copie est créé pour les classes de type référencées. Grâce au constructeur de copie, nous pouvons ajouter les attributs d'une classe à une autre classe.

employé de classe

chaîne privée ename;
Double Esalary privé;
Adresse privée Eaddress;
Employé (String ename, double esalary, adresse EADD)

ce.ename = ename;
ce.ESALARY = ESALARY;
ce.eAddress = eadd;

Employé (Employé EMP)

ce.ename = emp.Getename ();
ce.esalary = emp.getsalary ();
ce.eaddress = emp.getEaddress ();

Adresse publique GetEaddress ()
Retour Eaddress;

public void SpeaDdress (adresse eAddress)
ce.eAddress = eAddress;

public String Getename ()
retourne ename;

public void setename (String ename)
ce.ename = ename;

public double getsalary ()
retour ESALARY;

Settesalary public public (double esalary)
ce.ESALARY = ESALARY;


adresse de classe

int post-code;
Adresse (int emp)

ce.Postcode = emp;


classe publique principale

public static void main (String [] args)

Adresse EADD = nouvelle adresse (100002);
Employé EMP1 = nouvel employé ("Bella", 85000.0, eadd);
Employé cloneofemp1 = nouvel employé (EMP1);
eadd.Code postal = 200003;
Système.dehors.println ("Employee-1:" + EMP1.getEaddress ().Code postal);
Système.dehors.Imprimer ("Employee-2:" + CloneOfEMP1.getEaddress ().Code postal);

Le programme est établi avec la classe Java «Employee» et nous définissons les attributs privés de la classe. Ces attributs incluent la chaîne ename, le double type Esalary et l'adresse EADdress. Ensuite, nous construisons le constructeur paramétré de la classe «Employee» qui prend les attributs de classe existants en tant qu'objets de paramètre. Dans le constructeur paramétré, nous appelons le mot clé K «ce» qui fait référence directement à l'instance actuelle.

Ensuite, nous définissons un constructeur de copie qui prend le paramètre «EMP» pour référencer l'objet de la classe «employé». Nous spécifions les méthodes Getter pour chacun des objets. Après cela, nous appelons chacune des méthodes Getter et des méthodes de setter qui contrôlent la valeur à chaque objet de référence de la classe. Ensuite, nous créons la deuxième classe d'un programme qui est «l'adresse» qui a le membre «Postcode». De plus, nous définissons le constructeur de copie à l'intérieur de la classe qui prend la référence de l'objet de classe des employés «EMP» de type int. L'objet de code postal de la classe «Adresse» est défini avec l'objet «EMP».

Maintenant, l'objet «EMP» de la classe des employés et l'objet «post-code» de la classe d'adresses fournissent les mêmes données. Ensuite, nous avons une classe «principale» où la méthode principale () est déployée pour attribuer les valeurs aux attributs donnés et les exécuter. Nous appelons la classe Adresse () dans l'objet «EADD» et lui définissons la valeur EADRESS. Dans l'objet «EMP», les valeurs des autres champs de la classe des employés sont également initialisées. En outre, nous déclarons un objet de référence «cloneofemp1» qui pointe vers un objet «EMP1» qui est généré par le nouveau mot-clé appelé «employé» qui utilise un constructeur de copie pour copier les données du premier objet.

Ensuite, nous modifions la valeur de l'adresse qui affecte également l'objet clone «EADD». L'instruction d'impression affiche les résultats de la modification de la valeur de l'objet clone.

L'adresse de l'objet de constructeur de copie est modifiée qui s'affiche sur l'invite Java:

Exemple 4:

L'objet copié peut également être créé sans le constructeur de copie en donnant simplement le contenu d'un objet à l'autre. Clonez les objets de classe sans utiliser le constructeur de copie.

Importer Java.user.Scanner;
Produit de classe publique
public int pid;
prix du flotteur public;
Public String pname;
produit public ()
produit public (int id, chaîne pname, prix float)
ce.pid = pid;
ce.pname = pname;
ce.prix = prix;

public void ProductView ()
Système.dehors.println ("ID de produit:" + ceci.pid);
Système.dehors.println ("Nom du produit:" +.pname);
Système.dehors.println ("Prix du produit:" +.prix);

public static void main (String [] args)
Scanner myscan = nouveau scanner (système.dans);
Système.dehors.println ("Entrez le nom du produit");
String pname = myscan.suivant();
Système.dehors.println ("Entrez l'ID du produit");
int pid = myscan.NextInt ();
Système.dehors.println ("Entrez le prix du produit");
int prix = myscan.NextInt ();
Produit produit = nouveau produit (PID, PNAME, Price);
Système.dehors.println ("Données de l'objet d'origine");
produit.ProductView ();
Product product_copy = new Product ();
Product_copy.pid = produit.pid;
Product_copy.Prix ​​= produit.prix;
Product_copy.PNAME = produit.pname;
Système.dehors.println ("Données de l'objet copié");
produit.ProductView ();

Le programme est défini avec la classe publique «produit» où nous déclarons ses objets qui sont PID, PNAME et PPRICE d'un type différent. Après cela, nous créons simplement le constructeur de la classe spécifiée sans arguments. Ensuite, nous créons le constructeur paramétré de la classe où tous les attributs de classe sont déclarés comme un argument. À l'intérieur du constructeur de classe, nous utilisons la variable de référence «cette» avec les attributs de classe qui se réfère à l'objet actuel du constructeur.

Ensuite, nous avons la définition de la fonction «ProductView» de la classe «produit» pour afficher ou imprimer les valeurs de chacun des attributs de classe. Après cela, nous utilisons la méthode principale () où nous utilisons la classe de scanner pour obtenir les valeurs des attributs de classe «produit» pour former l'utilisateur. Une fois que l'utilisateur saisit la valeur de l'attribut, les valeurs d'origine pour l'instance de classe s'affiche à partir de la fonction ProductView (). Ensuite, nous créons l'objet «Product_Copy» où nous invoquons la classe «Product ()». Maintenant, le produit_copy a le contenu de la classe de produits. Ainsi, nous copie les attributs de la classe «produit» avec les nouveaux objets du produit_copy. Les attributs de classe et l'attribut product_copy contiennent les mêmes valeurs.

Les valeurs de l'objet d'origine et de l'objet copié sont les mêmes sans utiliser le constructeur de copie.

Conclusion

Les constructeurs de copie de Java sont un moyen efficace et simple de dupliquer les objets. Ils peuvent faire des clones à la fois peu profonds et profonds. Nous avons donné un programme exécutable des constructeurs de copie où les différents scénarios sont accomplis. De plus, les constructeurs de copies ont l'inconvénient d'être hérité. Mais nous pouvons contourner cette difficulté en incluant une méthode qui déclenche le constructeur de copie dans la base et les classes dérivées.