> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/ud4-elementos-da-programacion-orientada-a-obxectos/a-clase-object/clone.md).
# clone()
O método `clone()`:copy: en Java permite crear unha copia exacta dun obxecto. Está definido na clase `Object`:copy: e proporciona unha clonación superficial (***shallow copy***) do obxecto.
```java
protected Object clone() throws CloneNotSupportedException
```
* Lanza `CloneNotSupportedException`:copy: se a clase non implanta `Cloneable`:copy:.
* Usa unha **copia superficial** (***shallow copy***), é dicir, copia os valores dos atributos pero non duplica os obxectos referenciados.
Para que unha clase poida ser clonada correctamente, debe seguir estes pasos:
* **Implantar a interface `Cloneable`**:copy:.
* **Sobrescribir `clone()`**:copy: **facéndoo `public`**:copy:.
* **Chamar `super.clone()`**:copy: dentro de `clone()`:copy:. `super.clone()`:copy: fai unha copia superficial de todos os atributos do obxecto (valores en tipos primitivos e referencias para obxectos). Isto significa que:
* **Os atributos de tipos primitivos** (`int`, `double`:copy:, `boolean`:copy:, etc.) **cópiase correctamente**, xa que son valores almacenados directamente na memoria.
* **Os atributos que son obxectos** (`String`:copy:, `List`, `Array`, `Map`, etc.) **copian só a referencia ao obxecto, non crean un novo obxecto.** Se o obxecto orixinal cambia, a copia tamén se verá afectada.
* **(Opcional) Realizar unha clonación profunda (`deep copy`**:copy:**) se hai obxectos mutables**.
Dentro do noso exemplo concreto con direccións, persoas e estudiantes, o método clone quedaría da seguinte forma:
```java
public class Direcion implements Cloneable {
//...
@Override
public Direccion clone() throws CloneNotSupportedException {
return (Direccion) super.clone();
}
}
```
## Composición
Cando un obxecto conten a outro, se o queremos clonar facendo unha clonación profunda, debemos clonar cada un dos obxectos que o compoñen:
```java
public class Persona implements Cloneable {
//...
@Override
public Persona clone() throws CloneNotSupportedException {
Persona persona = (Persona) super.clone();
Direcion direccion = (Direcion) this.direcion.clone();
persona.setDirecion(direcion);
return persona;
}
}
```
## Herencia
No caso da herdanza, dependerá de que atributos contén a nosa clase herdada. Neste caso, como o que conten é un String que é inmutable, chega con facer unha copia superficial
```java
package Object;
import java.util.Objects;
public class Estudiante extends Persona implements Cloneable {
//...
@Override
public Estudiante clone() throws CloneNotSupportedException {
return (Estudiante) super.clone();
}
}
```
{% hint style="warning" %}
Se a clase **Estudiante** contivese obxectos mutables, sería necesario realizar a clonación obxecto a obxecto
{% endhint %}
## Problemas do método clone
O método clone(), ainda que existe, ten alguns inconvenientes:
* **Copia superficial por defecto**: `clone()` non garante unha copia profunda e pode provocar referencias compartidas.
* **Deseño confuso**: `Cloneable` é unha interface marcadora sen métodos, e o control faise en tempo de execución.
* **Problemas coa herdanza**: todas as clases da xerarquía deben redefinir correctamente `clone()`.
* **Difícil mantemento**: cambios na clase obrigan a revisar e adaptar o método `clone()`.
## Alternativas ao método clone()
A utilización de Cloneable e clone() é considerdo un antipatrón en Java "moderno" por alguns autores.
Unha alternativa ao método `clone()` é crear **constructores copia** ou **métodos factoría (`copyOf`)**, que permiten crear unha nova instancia dun obxecto copiando explicitamente os seus atributos, evitando os problemas asociados a `Cloneable:`
### Constructor de copia
```java
// Constructor copia: crea un novo obxecto a partir doutro existente
public Direccion(Direccion otra) {
this.calle = otra.calle;
this.numero = otra.numero;
this.localidad = otra.localidad;
}
```
### Método factoría copyOf(...)
```java
// Método factoría copyOf: forma clara e lexible de facer unha copia
public static Direccion copyOf(Direccion otra) {
return new Direccion(otra);
}
```
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://educacion.gitbook.io/programacion/ud4-elementos-da-programacion-orientada-a-obxectos/a-clase-object/clone.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.