在JAVA中克隆的用途是什么？在哪里经常使用克隆？

我曾经使用过编程，并且理解克隆意味着复制一个对象。但是，我不知道它主要在什么环境下使用，在哪里使用？我的意思是，它似乎在哪里被使用

public abstract class GeometricObject { 
    private String color = "white";
    private boolean filled;

    //Default constructor
    protected GeometricObject(){

    }
    //Constructing a Geometric object
    protected GeometricObject(String color, boolean filled){
        this.color = color;
        this.filled = filled;
    }
    //Getter method for color
    public String getColor(){
        return color;
    }
    //set method for color
    public void setColor(String color){
        this.color = color;
    }
    //Getter method for filled
    public boolean isFilled(){
        return filled;
    }
    //setter method for filled
    public void setFilled(boolean filled){
        this.filled = filled;
    }
    //Abstract method for getting Area
    public abstract double getArea();

    //Abstract method for getting perimeter
    public abstract double getPerimeter();

}

public class Octagon extends GeometricObject implements Comparable<Octagon> , Cloneable {
    private double sides;
    //Default constructor
    public Octagon(){

    }

    /**New Octagon Object**/
    public Octagon(double side){
        this.sides = side;
    }

    /**Getter method**/
    public double getSide(){
        return sides;
    }

    /**Setter method**/
    public void setSide(double side){
        this.sides = side;
    }


    @Override
    public double getArea() {
        double area = (2*(1+(Math.sqrt(2)))*sides*sides);
        // TODO Auto-generated method stub
        return area;
    }

    @Override
    public double getPerimeter() {
        double perimeter = sides * 8;
        return perimeter;
    }

    @Override
    public int compareTo(Octagon o) {
        if(getArea()>o.getArea())
            return 1;
        else if(getArea()<o.getArea())
            return -1;
        else 
            return 0;
    }
    @Override
     public Object clone() {
            try {
              return super.clone();
            }
            catch (CloneNotSupportedException ex) {
              return null;
            }
          }
}

public class Test {

    public static void main(String[] args) {
        /**Creating a new Ocatgon object of having side value 5**/
        Octagon oct = new Octagon(7);
        //getting Area of new octagon
        System.out.println("The area of Octagon with side 5.0 is (A): "+ oct.getArea());
        /**Getting perimeter of new Octagon**/
        System.out.println("The perimeter of Octagon with side 5.0 is (P): "+ oct.getPerimeter());
        /*
         * Creating a new object using clone method and 
         * copy of oct whose side is 5
        */
        Octagon octagon1 = (Octagon)oct.clone();

        /*
         * comparing the two objects i.e.  using compareTo method.
         */
        int i= oct.compareTo(octagon1);
        if(i<0){
            System.out.println("Clone Octagon is grater than original octagon");
        }else if(i>0)
            System.out.println("Clone octagon is smaller than original octagon");
        else
            System.out.println("Clone octagon is Equal to original octagon");   
    }
}

公共抽象类GeometricObject{
私有字符串color=“白色”；
私有布尔填充；
//默认构造函数
受保护的几何对象（）{
}
//构造几何对象
受保护的几何对象（字符串颜色，布尔填充）{
这个颜色=颜色；
这个.填充的=填充的；
}
//彩色吸气剂法
公共字符串getColor（）{
返回颜色；
}
//设置颜色的方法
公共void setColor（字符串颜色）{
这个颜色=颜色；
}
//吸气剂填充法
公共布尔值已填充（）{
填写报税表；
}
//填充的setter方法
公共空集合填充（布尔填充）{
这个.填充的=填充的；
}
//获取面积的抽象方法
公共抽象双getArea（）；
//求周长的抽象方法
公共抽象双GetPermiture（）；
}
公共类八角形扩展GeometricObject实现了可比较、可克隆的{
私人两面；
//默认构造函数
公共八角形（）{
}
/**新八角形物体**/
公共八角形（双面）{
这个边=边；
}
/**吸气剂法**/
公共双getSide（）{
返回侧；
}
/**塞特法**/
公共空隙设置侧（双面）{
这个边=边；
}
@凌驾
公共区域（）{
双面积=（2*（1+（数学sqrt（2）））*边*边）；
//TODO自动生成的方法存根
返回区；
}
@凌驾
公共双边界{
双周长=侧面*8；
返回周长；
}
@凌驾
公共整数比较（八角形o）{
如果（getArea（）>o.getArea（））
返回1；
else if（getArea（）要
clone
一个
对象
你的类应该实现
Cloneable
接口，你应该重写对象类中的
clone
方法，这很奇怪，clone方法应该在Cloneable接口上。你对clone方法的实现和使用克隆对象是正确的。我假设你不是获取对象的概念
复制
。例如

您有一个八角形对象
octagon octagon1=new Octagen（）；

您的参考值为
Octagon octagon2=octagon1；

即使
octagon1
和
octagon2
是两个不同的变量，它们仍在同一对象上保持引用。如果使用任何变量对对象进行更改，则更改将影响这两个变量，因为它们引用的是同一对象

octagon2.setSide(2);
octagon1.getSide(); //will return 2.

通过克隆对象，您不会出现上述问题

 Octagon oct = new Octagon(7);
 Octagon octagon1 = (Octagon)oct.clone();

octagon1.setSide(3);
oct.getSide(); //will not return 3 because they are not referring to the same object.

你的代码和这个问题有什么关系？我自己也做过这个编程。我想问的问题是，克隆主要在哪里使用。只是看不到代码。给我举个例子说明你为什么使用克隆？可能的重复。你能解释一下为什么你（和许多其他人）使用克隆吗当它的名字实际上是，真的，诚实的，严肃的，不是首字母缩略词时，就称它为JAVA？至于
clone（）
use的例子，请参见javadoc：这意味着对象将被复制而不会干扰原始对象。我希望我现在就得到了它。非常感谢，伙计！！