É um dos padrões de design criacional.
Usado para criar cópias duplicadas/superficiais de um determinado objeto.
Este padrão é útil quando a criação direta de objetos é cara. Exemplo: se um objeto for criado após consultar um banco de dados grande, criar o objeto repetidamente não será econômico em termos de desempenho.
Portanto, uma vez que o objeto é criado, armazenamos o objeto em cache e, quando necessário, no futuro, o obtemos do cache em vez de criá-lo novamente no banco de dados e atualizamos o banco de dados como e quando necessário para reduzir as chamadas do banco de dados .

Nota: Teremos que usar Cloneable ou seja, uma interface de marcador para o objeto que precisa ser clonado, ele(Clonable) não contém nenhum método, sinaliza que uma classe pode ser clonada, o que significa criar uma cópia de um objeto.

Object.clone() cria uma cópia superficial por padrão
Por padrão, o método clone() executa uma cópia superficial do objeto. Isso significa que ele cria um novo objeto e copia todos os campos do objeto original para o novo objeto. No entanto, se o objeto contiver referências a outros objetos (por exemplo, matrizes, listas ou objetos personalizados), as próprias referências serão copiadas, e não os objetos reais para os quais apontam.
Como resultado, tanto o objeto original quanto o objeto clonado farão referência aos mesmos objetos para esses campos. Quaisquer alterações feitas nos objetos referenciados por meio de uma instância serão refletidas na outra.

Vamos entender isso com um exemplo de objeto Shape que pode ser clonado.

Forma

public class Shape implements Cloneable {
    private String id;
    protected String shape;

    @Override
    public String toString() {
        return "Shape [id="   id   ", shape="   shape   "]";
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getShape() {
        return shape;
    }

    @Override
    public Object clone(){
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

Aulas infantis

public class Rectangle extends Shape {

    public Rectangle(){
        shape = "Rectangle";
    }
    public void draw(){
       System.out.println("calling draw() of Rectangle shape");
    }
}

public class Circle extends Shape {
    public Circle(){
        shape = "Circle";
    }
    public void draw(){
        System.out.println("Calling draw in Circle method");
    }
}

Cache

public class ShapeCache {
    public static HashMap cache = new HashMap();

    public static Shape cloneObject(String id){
        return (Shape)cache.get(id);
    }
    public static void addShapeInCache(Shape shape){
        cache.put(shape.getId(),shape);
    }

}

Principal

public class Main {
    public static void main(String args[]){
        Shape circle = new Circle();
        circle.setId("1");
        Shape rectangle = new Rectangle();
        rectangle.setId("2");

        ShapeCache.addShapeInCache(rectangle);
        ShapeCache.addShapeInCache(circle);

        Shape copyShape1 = (Shape) ShapeCache.cache.get(circle.getId());
        Shape copyShape2 =(Shape) ShapeCache.cache.get(rectangle.getId());

        System.out.println(copyShape1);
        System.out.println(copyShape2);
    }

}

Saída:

Shape [id=1, shape=Circle]
Shape [id=2, shape=Rectangle]

Pontos-chave

• Círculo e Retângulo seguem o princípio de substituição de Liskov (princípio SOLID), que afirma que Objeto deve ser substituível por seus subtipos sem afetar a correção do código.
• Apenas uma cópia superficial do objeto Shape é criada.