Object 上的 clone 方法创建对象的精确副本，声明为：
protected native Object clone() throws CloneNotSupportedException;
为什么是native？
【问题讨论】：
native”和“为什么将这个方法声明为native”之间存在巨大差异？
clone 方法通过调用 super.clone() 创建一个克隆，这将调用 Object 的 clone 方法，它 必须是原生的，才能创建 new 和相等的对象。
基本上，因为clone() 方法做了一些您在Java 语言中无法做到的事情：它克隆对象的状态，包括其实际的类指定。
Java 中的克隆机制基于每个类调用超类的clone 方法，一直到Object。然后 Object 使用这个“神奇的”原生 clone 方法来复制原始对象，包括它的实际类。
想一想：
class A implements Cloneable {
public A clone() {
A obj = (A) super.clone();
// Do some deep-copying of fields
return obj;
}
}
class B extends A {
public B clone() {
B obj = (B) super.clone();
// Do some deep-copying of fields not known to A
return obj;
}
}
现在假设您有一个B 类型的对象，并在其上调用clone。您期望得到一个B 对象，其类在内部被识别为B，而不是Object。 B不知道A中所有内容的实现，因此需要调用A的clone方法。但是如果A 在Java 语言中实现clone 而不是调用super.clone()，那么它将返回的对象必须是A。它不能使用new B()（假设在创建 A 时 B 是未知的）。
它可以通过反射做一些事情，但它如何知道调用哪个构造函数以便正确填充所有最终字段？
所以诀窍是A 自己不会这样做，它会调用super.clone()，这会一直追溯到Object，它使用一个逐字节执行的本机方法复制原始对象，调整新的堆位置。因此，新对象神奇地变成了B 对象，并且类型转换不会失败。
那为什么不返回Object呢？因为那不会是克隆。当您调用clone 时，您希望得到一个具有相同状态（字段）和相同类（被覆盖和添加的方法）的对象。如果它返回一个内部类指定为Object 的对象，您将只能访问Object 提供的内容，例如toString()，并且您将无法从另一个B 访问其私有字段对象，或将其分配给B 类型变量。
【讨论】：
B 类的源代码中并且你得到一个B 类型的对象并克隆它，你就可以访问它的所有私有字段。
查看克隆文档：
否则，此方法会创建 this 类的新实例 对象并完全使用对象的内容初始化其所有字段 这个对象的对应字段，就像通过赋值一样；内容 的字段本身没有被克隆。
使用本机代码可以非常有效地完成此操作，因为必须直接复制一些内存。在这方面它与System.arrayсopy 类似，后者也是原生的。详情看这个问题：Is it possible to find the source for a Java native method?
请注意，通常您应该避免使用 Object.clone()，而是使用例如复制构造函数，请参阅 How do I copy an object in Java?
【讨论】：
它是原生的，因为一些系统类的Clone()方法是用C++编写的以提高性能。
【讨论】：
clone() 是原生的，因为操作依赖于底层平台，也就是操作系统。 以下是一些有助于掌握实际情况的事实： 1.JVM用C++实现 2. C++要求你在目标平台/OS上编译代码 3. clone() 操作发生在内存中 4.那部分内存由JVM控制（一个C++程序） 5.一个类被编译成bytecode = text（忽略下面所有冗长的细节，它们只是为了说明） 所以，这个：
public static void main(String[] args) {
int a = 1;
int b = 2;
int c = calc(a, b);
}
static int calc(int a, int b) {
return (int) Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2));
}
变成这样：
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: (0x0009) ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=4, args_size=1
0: iconst_1
1: istore_1
2: iconst_2
3: istore_2
4: iload_1
5: iload_2
6: invokestatic #2 // Method calc:(II)I
9: istore_3
10: return
static int calc(int, int);
descriptor: (II)I
flags: (0x0008) ACC_STATIC
Code:
stack=6, locals=2, args_size=2
0: iload_0
1: i2d
2: ldc2_w #3 // double 2.0d
5: invokestatic #5 // Method java/lang/Math.pow:(DD)D
8: iload_1
9: i2d
10: ldc2_w #3 // double 2.0d
13: invokestatic #5 // Method java/lang/Math.pow:(DD)D
16: dadd
17: invokestatic #6 // Method java/lang/Math.sqrt:(D)D
20: d2i
21: ireturn
我知道这很长，但它非常清楚地说明了为什么 clone() 比“new”更快 - 只是将对象的状态作为二进制字符串抓取并复制它而无需任何“思考”/检查。
要了解有关字节码的更多信息，请查看this article in DZone。 请记住....计算机科学中的一切都是假的，包括类对象，因为它们只是将相关结构和函数组合在一起的另一种抽象，可能除了硬件:)，大多数人实际上认为属于计算机工程，而不是 CS。
【讨论】：