web-dev-qa-db-fra.com

Pourquoi avons-nous besoin du constructeur de copie et quand devrions-nous utiliser le constructeur de copie dans java

Je passais par les constructeurs de copie, j'ai parcouru les liens dans la pile au-dessus du flux et d'autres aussi. Mais je ne suis pas clair sur les points suivants.

  1. Pourquoi avons-nous besoin d'un constructeur de copie
  2. Quand avons-nous besoin d'un constructeur de copie

Je veux dire quelle est la situation ou le scénario exact dont nous aurions besoin pour utiliser Copy Constructor. Quelqu'un peut-il expliquer avec un exemple ou indiquer des liens afin que je puisse les parcourir et les comprendre en clair.

Voici les liens que j'ai parcourus pour comprendre ce qu'est un constructeur de copie.

http://www.programmerinterview.com/index.php/Java-questions/how-copy-constructors-work/

https://deepeshdarshan.wordpress.com/2013/12/05/copy-constructors-in-Java/

Le deuxième lien explique "pourquoi" et "où" le constructeur de copie doit être utilisé. Mais je ne suis toujours pas clair là-dessus.

Ci-dessous est ma classe Employee.Java

package com.test;

/**
 * @author avinashd
 *
 */
public class Employee {

    private String rollNo;
    private String name;

    //constructor
    public Employee(String rollNo, String name){

        this.rollNo = rollNo;
        this.name = name;
    }

    //copy constructor
    public Employee(Employee employee){

    this.rollNo = employee.rollNo;
    this.name = employee.name;

    }

    public String getRollNo() {
        return rollNo;
    }

    public void setRollNo(String rollNo) {
        this.rollNo = rollNo;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Le constructeur de copie est utilisé pour créer et copier exactement un objet avec les mêmes valeurs qu'un objet existant.

Supposons par exemple que nous avons un employé dont les valeurs sont rollNo: 1 et name: avinash. Le constructeur de copie créerait un objet similaire avec des valeurs telles que rollNo: 1 et name: avinash. Mais les deux sont deux objets différents et les modifications apportées aux valeurs de on object n'affecteront pas un autre objet.

La question ici est

Quand nous avons un constructeur tel que

public Employee(String rollNo, String name){
    this.rollNo = rollNo;
    this.name = name;
}

pour créer un objet. Nous pouvons appeler le même constructeur pour créer un autre objet. Mais pourquoi devons-nous appeler le constructeur de copie. Quand devons-nous l'appeler?. S'il vous plaît, expliquez

javacopy-constructor
33
Avinash Reddy

Il y a 2 bonnes raisons d'utiliser un constructeur de copie au lieu que le constructeur passe tous les paramètres:

  1. lorsque vous avez un objet complexe avec de nombreux attributs, il est beaucoup plus simple d'utiliser le constructeur de copie
  2. si vous ajoutez un attribut à votre classe, vous changez simplement le constructeur de copie pour prendre en compte ce nouvel attribut au lieu de changer chaque occurrence de l'autre constructeur
34
Serge Ballesta

Les constructeurs de copie, par convention, devraient fournir une copie complète des objets. Comme déjà mentionné par d'autres réponses, la principale commodité offerte par les constructeurs de copie est lorsque votre objet devient trop complexe. Notez que Java.lang.Cloneable fournit une déclaration (presque) similaire.

Mais il y a un certain nombre d'avantages à utiliser des constructeurs de copie sur l'interface Cloneable.

  1. Cloneable en tant qu'interface ne fournit aucune méthode. Pour qu'il soit efficace, vous devez toujours remplacer la méthode clone de Java.lang.Object. C'est tout à fait une utilisation contre-intuitive d'une interface.

  2. clone renvoie un Object. Pour qu'il soit utile, vous devez toujours transtyper. Cela est gênant et peut entraîner des erreurs d'exécution.

  3. La méthode clone est mal documentée. Pour clone, les choses peuvent être gâchées si vous avez des champs finaux pointant vers des objets mutables.

  4. Plus important encore, les constructeurs de copie peuvent accepter et copier en profondeur des instances de sous-classes. OMI, c'est là que les constructeurs de copie brillent vraiment.

Il y a plus d'avantages (voir Joshua Bloch Effective Java 2e) mais ce sont les points que j'ai trouvés les plus pertinents pour ce sur quoi j'ai travaillé jusqu'à présent.

[1] Rien dans le langage Java fournit en fait une construction par défaut pour la copie en profondeur. Tout au plus, les objets peuvent simplement dire aux programmeurs qu'ils peuvent être copiés en profondeur, par exemple, en implémentant Cloneable ou fournir un constructeur de copie.

34
skytreader

Que faire si vous voulez avoir une autre instance Employee avec exactement les mêmes valeurs que celle que vous avez déjà?.

Voulez-vous appeler?

setName(oldEmployee.getName())..
setRollNumber(oldEmployee.getRollNumber())..
etc..

Au lieu de cela, utilisez ceci

Employee copyOfEmployeeOne=new Employee(employeeOneInstance);
// no need of a sequence of setters..
5
TheLostMind

Un autre cas serait le stockage de valeurs "historiques" d'objets.

Vous avez donc un seul objet, mais chaque fois que vous changez son état, vous voulez l'ajouter à ArrayList ou à la structure de données qui vous convient le mieux, au lieu de faire une copie manuelle des données, vous utilisez simplement "constructeur de copie" avant toute modification.

2
zubergu

Les constructeurs de copie nous offrent de nombreux avantages par rapport à la méthode Object.clone () car ils

  1. Ne nous forcez pas à implémenter une interface ou à lever une exception.
  2. Ne nécessite aucune conversion.
  3. Ne nous obligez pas à dépendre d'un mécanisme de création d'objet inconnu.
  4. N'exigez pas de la classe parent de suivre un contrat ou de mettre en œuvre quoi que ce soit.
  5. Permettez-nous de modifier les derniers champs.
  6. Permettez-nous d'avoir un contrôle complet sur la création d'objets, nous pouvons y écrire notre logique d'initialisation.

En savoir plus sur Java Cloning - Copy Constructor versus Cloning

2
Naresh Joshi

Grâce au constructeur de copie, nous pouvons faire du clonage sans utiliser des choses beaucoup plus complexes comme l'implémentation de l'interface Cloneable et la méthode de clonage de remplacement. De plus, nous n'avons pas à nous soucier spécialement du clonage en profondeur.

Mais les points à noter sont:

1.Lorsque nous implémentons Cloneable, c'est une indication aux autres classes/utilisateurs que les objets de cette classe peuvent être clonables. Sans cela, les autres classes peuvent ne pas avoir d'informations explicites sur le clonage.

2.Si nous rendons notre constructeur de copie privé, nous pouvons restreindre le clonage de l'objet de cette classe. Ensuite, ce constructeur de copie ne peut être utilisé que pour initialiser les objets nouvellement créés dans la classe locale plutôt que pour le clonage dans une autre classe.

3.Lorsque vous ne voulez pas rendre votre classe clonable mais si vous avez écrit un constructeur de copie avec un spécificateur d'accès public, cela conduit à l'insécurité que d'autres classes peuvent créer des objets de votre classe.

0
Srikant M

Copy Constructors implémente un mécanisme de clonage superficiel et profond, mais les principaux avantages de l'utilisation du constructeur de copie par rapport au clonage (à l'aide de l'interface Cloneable) sont les suivants:

  1. Nous n'avons pas besoin de casse de type en utilisant la méthode Object.clone ().
  2. Nous serons en mesure de modifier les champs finaux à des fins de copie, contrairement à nous ne pouvons pas modifier ou accéder aux champs finaux en cas de mécanisme Object.clone ().
  3. Il nous permet d'avoir un contrôle complet sur la création d'objets, nous pouvons y écrire notre logique d'initialisation.
  4. Si nous voulons cloner un objet de notre classe qui contient une variable de référence d'une autre classe dépendante, nous n'avons pas besoin d'implémenter la méthode clone de cette classe. En initialisant simplement notre constructeur de copie, nous pouvons y parvenir.
0
BinDev