Copiar constructor en Java

Java Copy Constructor nos permite generar un clon exacto de un objeto existente que pertenece a la misma clase sin que la nueva copia se ve afectada por los cambios realizados en el objeto original. Al utilizar el constructor de copias, se mejora la reutilización del código. Su tamaño se reduce y no se requiere un examen de tipografía. Podemos controlar completamente la creación de objetos usando un constructor de copias. Además, el compilador Java no crea ningún constructor de copia en una clase por defecto. Sin embargo, podemos establecerlo asignando el contenido del objeto a otro.

Ejemplo 1:

Antes de continuar con la demostración del constructor de copias, tenemos el funcionamiento del constructor predeterminado en Java. Los constructores predeterminados son aquellos constructores que no toman parámetros. Tengamos el programa de constructor predeterminado a continuación:

clase pública defaultconst

DefaultConst ()

Sistema.afuera.println ("Constructor llamado porque se crea el objeto");

Public static void main (args de cadena [])

DefaultConst d = new DefaultConst ();

Definimos un programa que comienza con la construcción de la clase Java "Defaultconst". La clase "DefaultConst" se define aún más con el constructor, que se titula igual que el nombre de la clase Java. Aquí, creamos este constructor que está vacío pero contiene una declaración de impresión dentro del bloque de constructor. Luego, implementamos el método de clase Main () donde se llama a esta clase. Para esto, declaramos el objeto "D" y empleamos el ConfaualConst () allí. A partir de ahí, el defaultConst () se ejecuta.

El constructor predeterminado no ha dado un parámetro, pero la instrucción de impresión se ejecuta creando su objeto en el método main ().

Ejemplo 2:

La demostración del constructor se realiza en el ejemplo anterior. Ahora, hay un constructor de copias de ejemplo. Los constructores de copia de Java toman un objeto actual como entrada y producen una copia del objeto definido.

Clase ComplexNumber
privado doble real, img;
Public ComplexNumber (doble real, doble img)

este.real = real;
este.img = img;

ComplexNumber (ComplexNumber)

Sistema.afuera.println ("Inside a Copy Constructor");
Real = CN.real;
IMG = CN.img;

@Override public String toString ()

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


clase pública Main
Public static void main (String [] args)

ComplexNumber CN1 = nuevo ComplexNumber (3, 9);
ComplexNumber cn2 = new ComplexNumber (CN1);
ComplexNumber CN3 = CN2;
Sistema.afuera.println (CN2);

Tenemos un programa anterior donde creamos la clase de Java "ComplexNumber". La clase "ComplexNumber" contiene atributos que se declaran como "reales" e "IMG". Después de eso, definimos un constructor en la clase de "Number complejo" donde los atributos de la clase se pasan como argumentos. Luego, usamos la palabra clave "esto" para referirnos a los objetos actuales, "reales" e "img". Después de eso, empleamos el constructor de copias "complejeNumber ()" que tiene un objeto paramétrico "CN" de la clase "ComplexNumber". El constructor se declara con los objetos de la clase. Los valores de las variables de instancia se inicializan con los del objeto recibido.

A continuación, realizamos una operación de anulación de toString () en los objetos de clase "Real" e "IMG". La clase principal "compleja" se implementa con el método main (). Aquí, creamos el objeto "CN1" para invocar la clase ComplexNumber (). Establecemos los valores para las variables "reales" e "IMG" en la clase ComplexNumber (). Después de esto, declaramos el objeto "CN2" donde el constructor de copias está involucrado a medida que el "CN2" se pasa dentro de él. Luego, declaramos otro objeto "CN3" para hacer referencia al objeto "CN2". Al final, llamamos al método toString () del objeto "CN2" para imprimir los valores.

El número complejo de valores reales e imaginarios tanto para el objeto existente como para el objeto copiado es el mismo. El constructor de copias no afecta la fecha original de los objetos.

Ejemplo 3:

El constructor de copias solo se usa para crear una copia duplicada de las variables existentes de la clase. Ahora, el constructor de copias se crea para clases de tipo referenciadas. A través del constructor de copias, podemos agregar los atributos de una clase a otra clase.

empleado de clase

cadena privada Ename;
Esalario doble privado;
dirección privada Eaddress;
Empleado (String Ename, doble esalario, dirección EADD)

este.ename = ename;
este.esalario = esalario;
este.eaddress = eadd;

Empleado (Empleado EMP)

este.ename = emp.getename ();
este.esalario = EMP.getSalary ();
este.Eaddress = EMP.getEaddress ();

Dirección pública getEaddress ()
devolver eaddress;

public void setEaddress (dirección eaddress)
este.eaddress = eaddress;

public String getename ()
devolver ename;

public void setename (string ename)
este.ename = ename;

public Double getSalary ()
devolver esalario;

Public void setesalary (doble esalario)
este.esalario = esalario;


dirección de clase

int postal;
Dirección (int EMP)

este.Código postal = EMP;


clase pública

Public static void main (String [] args)

Dirección EADD = nueva dirección (100002);
Empleado emp1 = nuevo empleado ("bella", 85000.0, eadd);
Empleado clonofemp1 = nuevo empleado (EMP1);
EADD.código postal = 200003;
Sistema.afuera.println ("Empleado-1:" + Emp1.GetEaddress ().código postal);
Sistema.afuera.Imprimir ("Empleado-2:" + Clonofemp1.GetEaddress ().código postal);

El programa se establece con la clase Java "Empleado" y establecemos los atributos privados de la clase. Estos atributos incluyen la cadena Ename, Esalario de doble tipo y la dirección Eaddress. Luego, construimos el constructor parametrizado de la clase "Empleado" que toma los atributos de clase existentes como objetos de parámetros. En el constructor parametrizado, llamamos a la palabra clave K "esto" que hace referencia a la instancia actual directamente.

A continuación, definimos un constructor de copias que toma el parámetro "EMP" para hacer referencia al objeto de la clase "Empleado". Especificamos los métodos de Getter para cada uno de los objetos. Después de eso, llamamos a cada uno de los métodos de Getter y los métodos setter que controlan el valor con cada objeto de referencia de la clase. A continuación, creamos la segunda clase de un programa que es "dirección" que tiene el miembro "Código postal". Además, definimos el constructor de copias dentro de la clase que toma la referencia del objeto de clase de empleado "EMP" de tipo int. El objeto de código postal de la clase "Dirección" se establece con el objeto "EMP".

Ahora, el objeto "EMP" de la clase de empleados y el objeto "Código postal" de la clase de dirección proporcionan los mismos datos. Luego, tenemos una clase "principal" donde el método Main () se implementa para asignar los valores a los atributos dados y ejecutarlos. Llamamos a la clase Dirección () en el objeto "EADD" y establecemos el valor de Eaddress. Dentro del objeto "EMP", los valores para los otros campos de la clase de empleados también se inicializan. Además, declaramos un objeto de referencia "Clonofemp1" que apunta a un objeto "EMP1" que genera la nueva palabra clave llamada "Empleado" que usa un constructor de copias para copiar los datos del primer objeto.

Luego, alteramos el valor de la dirección que también afecta el objeto clon "EADD". La declaración de impresión muestra los resultados de cambiar el valor del objeto clon.

Se modifica la dirección del objeto de constructor de copias que se muestra en el indicador de Java:

Ejemplo 4:

El objeto copiado también se puede crear sin el constructor de copias simplemente dando el contenido de un objeto al otro. Clonar los objetos de clase sin utilizar el constructor de copias.

importar java.utilizar.Escáner;
Producto de clase pública
público int pid;
precio de flotación pública;
cadena pública pname;
Producto público ()
Producto público (int id, string pname, precio flotante)
este.pid = pid;
este.pname = pname;
este.precio = precio;

public void productView ()
Sistema.afuera.println ("ID de producto:" + esto.pid);
Sistema.afuera.println ("Nombre del producto:" + esto.pname);
Sistema.afuera.println ("Precio del producto:" + esto.precio);

public static void main (string [] args)
Escáner myscan = nuevo escáner (sistema.en);
Sistema.afuera.println ("Ingrese el nombre del producto");
Cadena pname = myscan.próximo();
Sistema.afuera.println ("Ingrese la identificación del producto");
int pid = myscan.nextInt ();
Sistema.afuera.println ("Ingrese el precio del producto");
int precio = myscan.nextInt ();
Producto producto = nuevo producto (PID, PNAME, precio);
Sistema.afuera.println ("datos del objeto original");
producto.ProductView ();
Producto producto_copy = nuevo producto ();
Product_copy.PID = producto.pid;
Product_copy.precio = producto.precio;
Product_copy.pname = producto.Pname;
Sistema.afuera.println ("datos del objeto copiado");
producto.ProductView ();

El programa se define con la clase pública del "producto" donde declaramos sus objetos que son PID, PNAME y PPRICE de un tipo diferente. Después de eso, solo creamos el constructor para la clase especificada sin argumentos. A continuación, creamos el constructor parametrizado de la clase donde todos los atributos de la clase se declaran como argumento. Dentro del constructor de clase, utilizamos la variable de referencia "esta" con los atributos de clase que se refiere al objeto actual del constructor.

Luego, tenemos la definición de la función "ProductView" de la clase "Producto" para mostrar o imprimir los valores de cada uno de los atributos de clase. Después de esto, empleamos el método Main () donde usamos la clase de escáner para obtener los valores de los atributos de la clase de "producto" para formar el usuario. Una vez que el usuario ingresa el valor del atributo, los valores originales para la instancia de clase se muestran desde la función ProductView (). Luego, creamos el objeto "Product_Copy" donde invocamos la clase "Product ()". Ahora, el producto_copy tiene el contenido de la clase de producto. Entonces, copiamos los atributos de la clase de "producto" con los nuevos objetos del producto_copy. Tanto los atributos de clase como el atributo product_copy contienen los mismos valores.

Los valores del objeto original y el objeto copiado son los mismos sin usar el constructor de copias.

Conclusión

Los constructores de copias de Java son una forma eficiente y directa de duplicar los objetos. Pueden hacer clones superficiales y profundos. Hemos dado un programa ejecutable de los constructores de copias donde se logran los diferentes escenarios. Además, los constructores de copias tienen la desventaja de ser heredados. Pero podemos evitar esta dificultad al incluir un método que desencadena el constructor de copias en la base y las clases derivadas.