Es ist eines der kreativen Designmuster.
Wird verwendet, um Duplikate/flache Kopien des angegebenen Objekts zu erstellen.
Dieses Muster ist nützlich, wenn die direkte Erstellung von Objekten kostspielig ist. Beispiel: Wenn ein Objekt nach der Abfrage einer großen Datenbank erstellt wird, ist die wiederholte Erstellung des Objekts hinsichtlich der Leistung nicht wirtschaftlich.
Sobald das Objekt erstellt ist, speichern wir es zwischen, und wenn wir dasselbe Objekt in der Zukunft benötigen, holen wir es aus dem Cache, anstatt es erneut aus der Datenbank zu erstellen, und aktualisieren die Datenbank nach Bedarf, um die Datenbankaufrufe zu reduzieren .

Hinweis: Wir müssen Cloneable verwenden, d Objekt.

Object.clone()-Methode erstellt standardmäßig eine flache Kopie
Standardmäßig führt die Methode clone() eine flache Kopie des Objekts durch. Das bedeutet, dass ein neues Objekt erstellt und alle Felder vom Originalobjekt in das neue Objekt kopiert werden. Wenn das Objekt jedoch Verweise auf andere Objekte enthält (z. B. Arrays, Listen oder benutzerdefinierte Objekte), werden die Verweise selbst kopiert, nicht die tatsächlichen Objekte, auf die sie verweisen.
Dadurch verweisen sowohl das Original als auch das geklonte Objekt für diese Felder auf dieselben Objekte. Alle Änderungen, die über eine Instanz an den referenzierten Objekten vorgenommen werden, werden in der anderen widergespiegelt.

Lassen Sie uns dies anhand eines Beispiels eines Shape-Objekts verstehen, das geklont werden kann.

Form

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;
    }
}

Untergeordnete Klassen

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);
    }

}

Hauptsächlich

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);
    }

}

Ausgabe:

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

Wichtige Punkte

• Sowohl Kreis als auch Rechteck folgen dem Liskov-Substitutionsprinzip (SOLID-Prinzip), das besagt, dass Objekte durch ihre Untertypen ersetzbar sein sollten, ohne die Richtigkeit des Codes zu beeinträchtigen.
• Es wird nur eine flache Kopie des Shape-Objekts erstellt.