1. Overiew
在实际编程中，我们经常会遇到这样一个情景：有一个对象A，存在属性方法，现在需要一个和A完全相同的新对象B，并且B的任何改动都不会影响到A中的值。那么，最常用的办法就是对A进行克隆。
2. How to Clone
在java.lang.Object中有一个clone方法，该方法的签名如下：
- protected native Object clone() throws CloneNotSupportedException;
该方法返回一个Object实例的拷贝，该实例拷贝具有：
1)拷贝对象是一个新对象而不是一个原对象引用。
2)拷贝的对象中包含的是原有对象信息，而不是对象初始化的信息(也就是说，拷贝过程没有调用构造函数)。
从第1条我们可以看出，拷贝的对象与原对象存在这样一种关系：
- 1. x.clone() != x will be true
- 2. x.clone().getClass() == x.getClass() will be true, but these are not absolute requirements
- 3. x.clone().equals(x) will be true, but these are not absolute requirements
要实现克隆，必须满足一下三点：
1)类必须实现Cloneable接口
2)类必须重载Object类中的clone()方法
3)重载的clone()方法中，必须显示调用super.clone()。
我们看一下Cloneable接口的定义:
- public interface Cloneable { }
Cloneable接口是不包含任何方法的,仅仅表示一个标志(类似Serializable接口)，而且这个标志也是针对Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了super.Clone()方法），那么Object的clone()方法就会抛出CloneNotSupportedException异常。
按照要求，我们写一个克隆类的小例子:
- public class DummyClone implements Cloneable{
-
- public Object clone(){
- DummyClone dc = null;
- try {
- dc = (DummyClone)super.clone();
- } catch (CloneNotSupportedException e) {
- e.printStackTrace();
- }
- return dc;
- }
- }
3. Shadow Clone
首先，我们来看一个例子：ClassA没有实现Cloneable接口。ClassB存在ClassA的实例，实现了Cloneable接口，并重载了clone方法。ClassC实例化一个ClassB对象，然后克隆一个对象。
- class ClassA {
-
- public int a;
-
- public void doubleA(){
- a = a * 2;
- }
-
- public ClassA(int aa){
- this.a = aa;
- }
-
- public String toString(){
- return Integer.toString(a);
- }
- }
-
- class ClassB implements Cloneable{
-
- public int b;
-
- public ClassA ca = new ClassA(11);
-
- public Object clone(){
- ClassB cb = null;
- try {
- cb = (ClassB)super.clone();
- } catch (CloneNotSupportedException e) {
- e.printStackTrace();
- }
- return cb;
- }
- }
-
- public class ClassC {
-
- public static void main(String[] args) {
- ClassB cb = new ClassB();
- cb.b = 222;
- System.out.println("before clone : cb.b = " + cb.b);
- System.out.println("before clone : cb.ca = " + cb.ca);
-
-
- ClassB cb2 = (ClassB)cb.clone();
- cb2.b = 3333;
- cb2.ca.doubleA();
- System.out.println("========================");
- System.out.println("after clone : cb.b = " + cb.b);
- System.out.println("after clone : cb.ca = " + cb.ca);
- System.out.println("========================");
- System.out.println("after clone : cb2.b = " + cb2.b);
- System.out.println("after clone : cb2.ca = " + cb2.ca);
- }
- }
输出结果如下：
- before clone : cb.b = 222
- before clone : cb.ca = 11
- ========================
- after clone : cb.b = 222
- after clone : cb.ca = 22
- ========================
- after clone : cb2.b = 3333
- after clone : cb2.ca = 22
从结果我们看到，int类型的b被完全的克隆了，而ClassA类型的ca却没有被克隆。因为克隆后cb2对b的赋值不会影响原有cb中b的值，而调用cb2.ca.doubleA()方法后，对cb2.ca的改变同时改变了cb.ca，表明cb2.ca与cb.ca仅仅指向同一个对象的不同引用。从中可以看出，调用Object类中clone()方法产生的效果是：先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容。对基本数据类型，这样的操作是没有问题的，但对非基本类型变量clone后的变量和原始对象中相应的变量指向的是同一个对象。
这就是影子克隆。影子克隆，并没有完整的完成克隆，有时候这并不是我们想要的结果。我们有时需要，就像列子中调用cb2.ca.doubleA()方法时，不会对原对象产生改变，这时候我们就需要deep clone;
4. Deep Clone
要实现深度克隆,在上面的例子基础上，我们只需要这样修改即可：
- class ClassA implements Cloneable{
-
- public int a;
-
- public void doubleA(){
- a = a * 2;
- }
-
- public ClassA(int aa){
- this.a = aa;
- }
-
- public String toString(){
- return Integer.toString(a);
- }
-
- public Object clone(){
- ClassA ca = null;
- try {
- ca = (ClassA)super.clone();
- } catch (CloneNotSupportedException e) {
- e.printStackTrace();
- }
- return ca;
- }
- }
-
- class ClassB implements Cloneable{
-
- public int b;
-
- public ClassA ca = new ClassA(11);
-
- public Object clone(){
- ClassB cb = null;
- font-size: 1em; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 38px; padding-top: 0px; padding-right: 0px; p
分享到：
相关推荐
Object Cloning 249 Interfaces and Callbacks 255 Inner Classes 258 Proxies 275 Chapter 7: Graphics Programming 281 Introducing Swing 282 Creating a Frame 285 Positioning a Frame 288 ...
Object Cloning 249 Interfaces and Callbacks 255 Inner Classes 258 Proxies 275 Chapter 7: Graphics Programming 281 Introducing Swing 282 Creating a Frame 285 Positioning a Frame 288 Displaying...
Java 中的对象克隆可以分为两种类型：浅克隆（Shallow Cloning）和深克隆（Deep Cloning）。 浅克隆是指创建一个新的对象，并将原始对象的引用类型成员变量复制到新的对象中。在浅克隆中，新的对象和原始对象共享...
Java的克隆机制通过`Object.clone()`方法实现，该方法位于`java.lang.Object`类中。 **1.2 实现要求** - **实现`Cloneable`接口**：被克隆的类必须实现`Cloneable`接口，表明该类支持克隆操作。 - **重写`clone()`...
- 整型数组如`int[]`可以转换为`Object`，但不能转换为对象数组，因为它们是不同的类型体系。 5. **枚举类（enum）**： - 枚举是一种特殊的类，用于定义一组预定义的常量。枚举类型的值可以通过直接使用等于...
在Java中，我们可以使用`java.lang.Cloneable`接口来标记一个类可以被克隆，然后通过覆盖`Object`类中的`clone()`方法来实现具体的克隆逻辑。但是，需要注意的是，`clone()`方法默认执行的是浅拷贝，即只复制对象...
public Object deepCopy() throws IOException, ClassNotFoundException { ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); ObjectOutputStream objectOutputStream = new ...
默认情况下，Java对象不支持克隆，需要实现`Cloneable`接口并覆盖`Object`类的`clone()`方法。以下是一个简单的克隆示例： ```java class Person implements Cloneable { String name; Address address; // ...
10. **自定义查询（Custom Queries）**：MAT支持SQL-like查询语言OQL（Object Query Language），用户可以通过编写查询来获取特定的信息。 使用MAT时，开发者应先在JVM中生成hprof文件（通常通过添加JVM参数或者...
在Java中，实现`Cloneable`接口并重写`Object`类的`clone()`方法是实现原型模式的标准方式。在C#中，虽然没有内置的`Cloneable`接口，但可以自定义`ICloneable`接口并实现`Clone()`方法。 在JavaScript中，可以使用...
8. **对象创建与克隆（Object Creation and Cloning）**：`ObjectUtils`和`Singleton`类提供了对象创建和克隆的辅助方法，如无参构造器创建对象，安全的单例模式实现等。 9. **类型转换（Type Conversion）**：`...
在Java编程中，克隆（Cloning）和赋值引用是两种不同的对象复制方式，它们在处理对象状态和内存管理时有着显著的区别。本文将详细探讨这两种方式，并通过示例代码来阐述它们的工作原理。 首先，让我们理解克隆的...
- 在Java中，实现原型模式可以通过实现`Cloneable`接口并重写`Object`类的`clone()`方法来完成。但是需要注意的是，`clone()`方法默认是浅拷贝，若需要实现深拷贝，需要自定义实现。 - 在Python等语言中，可以直接...
Java中的`Object`类提供了`clone()`方法，用于创建一个现有对象的副本。实现`Cloneable`接口后，才能调用`clone()`，否则会抛出`CloneNotSupportedException`。 4. **序列化与反序列化（Serialization & ...
1. **克隆（Cloning）**：Java提供了`Object`类中的`clone()`方法，允许对象复制自身。不过，要正确使用`clone()`，类必须实现`Cloneable`接口，并覆盖`clone()`方法。克隆可以快速生成一个对象的副本，作为原型的...
Fetching a Row as an Object 10.3. Zend_Db_Profiler 10.3.1. Introduction 10.3.2. Using the Profiler 10.3.3. Advanced Profiler Usage 10.3.3.1. Filter by query elapsed time 10.3.3.2. Filter by ...