Copiar Construtor em Java

Java Cópia Construtor nos permite gerar um clone exato de um objeto existente que pertence à mesma classe sem que a nova cópia seja afetada pelas alterações feitas no objeto original. Ao utilizar o construtor de cópias, a reutilização do código é aprimorada. Seu tamanho é reduzido e a TypeCasting não é necessária. Podemos controlar completamente a criação de objetos usando um construtor de cópias. Além disso, o compilador Java não cria nenhum construtores de cópia em uma classe por padrão. No entanto, podemos estabelecê -lo atribuindo o conteúdo do objeto a outro.

Exemplo 1:

Antes de prosseguir com a demonstração do construtor de cópias, temos o funcionamento do construtor padrão em java. Os construtores padrão são os construtores que não recebem parâmetros. Vamos fazer com que o programa de construtor padrão a seguir:

Classe pública DefaultConst

DefaultConst ()

Sistema.fora.println ("Construtor chamado porque o objeto é criado");

public static void main (string args [])

DefaultConst d = new DefaultConst ();

Definimos um programa que começa com a construção da classe Java "DefaultConst". A classe "DefaultConst" é definida ainda mais com o construtor, que tem o mesmo que o nome da classe Java. Aqui, criamos este construtor que está vazio, mas contém uma declaração de impressão dentro do bloco construtor. Em seguida, implantamos o método da classe Main () em que esta classe é chamada. Para isso, declaramos o objeto "d" e empregamos o padrão de. A partir daí, o defaultconst () é executado.

O construtor padrão não forneceu um parâmetro, mas a declaração de impressão é executada criando seu objeto no método principal ().

Exemplo 2:

A demonstração do construtor é realizada no exemplo anterior. Agora, há um exemplo de construtor de cópia. Os construtores de cópia Java tomam um objeto atual como entrada e produzem uma cópia do objeto definido.

classe ComplexNumber
duplo privado real, img;
Public ComplexNumber (Double Real, Double IMG)

esse.real = real;
esse.img = img;

ComplexNumber (ComplexNumbercn)

Sistema.fora.println ("dentro de um construtor de cópia");
real = cn.real;
img = cn.img;

@Override public string tostring ()

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


classe pública principal
public static void main (string [] args)

ComplexNumber cn1 = new ComplexNumber (3, 9);
ComplexNumber cn2 = new ComplexNumber (CN1);
ComplexNumber cn3 = cn2;
Sistema.fora.println (cn2);

Temos um programa anterior em que criamos a classe "ComplexNumber" de Java. A classe "ComplexNumber" contém atributos declarados como "reais" e "img". Depois disso, definimos um construtor na classe "ComplexNumber", onde os atributos da classe são passados ​​como argumentos. Em seguida, usamos a palavra -chave "isto" para referir -se aos objetos atuais, "real" e "img". Depois disso, empregamos o construtor de cópias "ComplexNumber ()", que possui um objeto "CN" paramétrico da classe "ComplexNumber". O construtor é declarado com os objetos da classe. Os valores das variáveis ​​de instância são inicializados com os do objeto recebido.

Em seguida, realizamos uma operação de substituição do ToString () nos objetos de classe "Real" e "IMG". A classe principal do “complexo Number” é implementada com o método principal (). Aqui, criamos o objeto "CN1" para invocar a classe ComplexNumber (). Definimos os valores para as variáveis ​​"reais" e "img" na classe ComplexNumber (). Depois disso, declaramos o objeto "CN2" onde o construtor de cópias está envolvido à medida que o "CN2" é passado dentro dele. Em seguida, declaramos outro objeto "CN3" para referenciar o objeto "CN2". No final, chamamos o método ToString () do objeto "CN2" para imprimir os valores.

O número complexo de valores reais e imaginários para o objeto existente e o objeto copiado são os mesmos. O construtor de cópias não afeta a data original dos objetos.

Exemplo 3:

O construtor de cópias é usado apenas para criar uma cópia duplicada das variáveis ​​existentes da classe. Agora, o construtor de cópias é criado para classes de tipo referenciado. Através do construtor de cópias, podemos adicionar os atributos de uma classe a outra classe.

funcionário da classe

Private String Ename;
duplo privado eSalary;
EADDRESS DE ENDEREÇO ​​PRIVADO;
Funcionário (string ename, duplo esalary, endereço EADD)

esse.ename = ename;
esse.Esalarário = Esalário;
esse.eaddress = eadd;

Funcionário (funcionário EMP)

esse.ename = emp.getename ();
esse.esalary = emp.getesalary ();
esse.eaddress = emp.getAddress ();

endereço público getAddress ()
retornar eaddress;

public void SeteAddress (ENDEREÇO ​​EADDRESS)
esse.eaddress = eaddress;

public string getename ()
retornar ename;

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

public duplo getesalary ()
retornar Esalarário;

public void Setesalary (duplo esalary)
esse.Esalarário = Esalário;


Endereço da classe

Int Código postal;
Endereço (Int EMP)

esse.Código postal = EMP;


Principal de classe pública

public static void main (string [] args)

Endereço EADD = novo endereço (100002);
Funcionário emp1 = novo funcionário ("bella", 85000.0, Eadd);
Funcionário cloneofemp1 = novo funcionário (EMP1);
Eadd.Código postal = 200003;
Sistema.fora.println ("funcionário-1:" + emp1.getAddress ().código postal);
Sistema.fora.print ("Empregado-2:" + cloneofemp1.getAddress ().código postal);

O programa é estabelecido com a classe Java "funcionário" e definimos os atributos privados da classe. Esses atributos incluem a string ename, o tipo duplo esalary e o endereço Eaddress. Em seguida, construímos o construtor parametrizado da classe "funcionário", que leva os atributos da classe existente como objetos de parâmetro. No construtor parametrizado, chamamos a palavra -chave K "essa" que faz referência à instância atual diretamente.

Em seguida, definimos um construtor de cópia que leva o parâmetro "EMP" para referenciar o objeto da classe "funcionário". Especificamos os métodos getter para cada um dos objetos. Depois disso, chamamos cada um dos métodos getter e métodos que controlam o valor em cada objeto de referência da classe. Em seguida, criamos a segunda classe de um programa, que é "endereço", que possui o membro do "código postal". Além disso, definimos o construtor de cópias dentro da classe, que leva a referência do objeto de classe dos funcionários "Emp" do Type Int. O objeto Post -Code da classe "endereço" é definido com o objeto "EMP".

Agora, o objeto "EMP" da classe de funcionários e o objeto "Código postal" da classe de endereço fornecem os mesmos dados. Em seguida, temos uma classe "principal" em que o método principal () é implantado para atribuir os valores aos atributos dados e executá -los. Chamamos a classe Endereço () no objeto "Eadd" e definimos o valor Eaddress para ele. Dentro do objeto "EMP", os valores para os outros campos da classe de funcionários também são inicializados. Além disso, declaramos um objeto de referência "cloneofemp1" que aponta para um objeto "EMP1" que é gerado pela nova palavra -chave chamada "funcionário", que usa um construtor de cópia para copiar os dados do primeiro objeto.

Em seguida, alteramos o valor do endereço, o que também afeta o objeto "EADD". A declaração de impressão exibe os resultados da alteração do valor do objeto clone.

O endereço do objeto Cópia do Construtor é modificado, exibido no prompt Java:

Exemplo 4:

O objeto copiado também pode ser criado sem o construtor de cópias, simplesmente dando o conteúdo de um objeto para o outro. Vamos clonar os objetos da classe sem utilizar o construtor de cópias.

importar java.util.Scanner;
Public class Product
public int pid;
preço de flutuação pública;
public string pname;
public Product ()
produto público (int id, string pname, preço float)
esse.pid = pid;
esse.pname = pname;
esse.preço = preço;

public void ProductView ()
Sistema.fora.println ("ID do produto:" + this.pid);
Sistema.fora.println ("Nome do produto:" + this.pname);
Sistema.fora.println ("Preço do produto:" + this.preço);

public static void main (string [] args)
Scanner MyScan = New Scanner (sistema.em);
Sistema.fora.println ("Digite o nome do produto");
String pname = myscan.próximo();
Sistema.fora.println ("Digite o ID do produto");
int pid = myscan.nextInt ();
Sistema.fora.println ("Digite o preço do produto");
int price = myscan.nextInt ();
Produto Produto = novo produto (PID, Pname, Price);
Sistema.fora.println ("dados do objeto original");
produtos.ProductView ();
Produto product_copy = new Product ();
Product_copy.PID = Produto.pid;
Product_copy.preço = produto.preço;
Product_copy.pname = produto.pname;
Sistema.fora.println ("dados do objeto copiado");
produtos.ProductView ();

O programa é definido com a classe pública de "produto", onde declaramos seus objetos que são PID, Pname e Pprice de um tipo diferente. Depois disso, apenas criamos o construtor para a classe especificada sem argumentos. Em seguida, criamos o construtor parametrizado da classe, onde todos os atributos de classe são declarados como um argumento. Dentro do construtor de classe, utilizamos a variável de referência "essa" com os atributos de classe que se refere ao objeto atual do construtor.

Em seguida, temos a definição da função "ProductView" da classe "Produto" para exibir ou imprimir os valores de cada um dos atributos da classe. Depois disso, empregamos o método Main () em que usamos a classe Scanner para obter os valores dos atributos da classe "Produto" para formar o usuário. Uma vez que o usuário insira o valor do atributo, os valores originais para a instância da classe são exibidos da função ProductView (). Em seguida, criamos o objeto "Product_copy", onde invocamos a classe "Product ()". Agora, o produto_copy tem o conteúdo da classe de produto. Então, copiamos os atributos da classe "Produto" com os novos objetos do produto_copy. Os atributos da classe e o atributo product_copy mantêm os mesmos valores.

Os valores do objeto original e do objeto copiado são os mesmos sem usar o construtor de cópias.

Conclusão

Os construtores de cópia do Java são uma maneira eficiente e direta de duplicar os objetos. Eles podem fazer clones rasos e profundos. Demos um programa executável dos construtores de cópias onde os diferentes cenários são realizados. Além disso, os construtores de cópias têm a desvantagem de ser herdado. Mas podemos contornar essa dificuldade, incluindo um método que desencadeia o construtor de cópias na base e classes derivadas.