package clone; //本例子阐释了clone的魅力,影子克隆
class UnCloneA {
private int i;
public UnCloneA(int ii) {
i = ii;
}
public void doublevalue() {
i *= 2;
}
public String toString() {
return Integer.toString(i); //把整数转换为字符串
}
}
class CloneB implements Cloneable{ //实现了克隆接口 Cloneable
public int aInt;
public UnCloneAA unCA = new UnCloneAA(111);
public Object clone(){ //重写clone方法
CloneB o = null;
try{
o = (CloneB)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return o;
}
}
public class CloneMain影子克隆 {
public static void main(String[] a){
CloneB b1 = new CloneB();
b1.aInt = 11;
System.out.println("before clone,b1.aInt = "+ b1.aInt);
System.out.println("before clone,b1.unCA = "+ b1.unCA);
CloneB b2 = (CloneB)b1.clone(); //b1的克隆
b2.aInt = 22;
b2.unCA.doublevalue();
System.out.println("=================================");
System.out.println("after clone,b1.aInt = "+ b1.aInt);
System.out.println("after clone,b1.unCA = "+ b1.unCA); //已经被改变了
System.out.println("=================================");
System.out.println("after clone,b2.aInt = "+ b2.aInt);
System.out.println("after clone,b2.unCA = "+ b2.unCA);
}
}
/** RUN RESULT:
* before clone,b1.aInt = 11 before clone,b1.unCA = 111
* =================================
* after clone,b1.aInt = 11 after clone,b1.unCA = 222
* =================================
* after clone,b2.aInt = 22 after clone,b2.unCA = 222 */
package clone;
class UnCloneAA implements Cloneable{
private int i;
public UnCloneAA(int ii) {
i = ii;
}
public void doublevalue() {
i *= 2;
}
public String toString() {
return Integer.toString(i);
}
public Object clone(){ //深度克隆这个类也要重写这个方法
UnCloneAA o = null;
try{
o = (UnCloneAA)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return o;
}
}
class CloneBB implements Cloneable{
public int aInt;
public UnCloneAA unCAA = new UnCloneAA(111);
public Object clone(){
CloneBB o = null;
try{
o = (CloneBB)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
o.unCAA = (UnCloneAA)unCAA.clone(); //深度克隆必加的一句
return o;
}
}
public class CloneMain深度克隆 {
public static void main(String[] a){
CloneBB b1 = new CloneBB();
b1.aInt = 11;
System.out.println("before clone,b1.aInt = "+ b1.aInt);
System.out.println("before clone,b1.unCA = "+ b1.unCAA);
CloneBB b2 = (CloneBB)b1.clone(); //克隆
b2.aInt = 22;
b2.unCAA.doublevalue();
System.out.println("=================================");
System.out.println("after clone,b1.aInt = "+ b1.aInt);
System.out.println("after clone,b1.unCA = "+ b1.unCAA);
System.out.println("=================================");
System.out.println("after clone,b2.aInt = "+ b2.aInt);
System.out.println("after clone,b2.unCA = "+ b2.unCAA);
}
}
/*before clone,b1.aInt = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 111
=================================
after clone,b2.aInt = 22
after clone,b2.unCA = 222
*/
package clone;
class UnCloneAAA implements Cloneable{
private int i;
public UnCloneAAA(int ii) {
i = ii;
}
public void doublevalue() {
i *= 2;
}
public String toString() {
return Integer.toString(i);
}
public Object clone(){
UnCloneAAA o = null;
try{
o = (UnCloneAAA)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return o;
}
}
class CloneBBB implements Cloneable{
public int aInt;
public UnCloneAAA unCAAA = new UnCloneAAA(111);
public Object clone(){
CloneBBB o = null;
try{
o = (CloneBBB)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
o.unCAAA = (UnCloneAAA)unCAAA.clone();
return o;
}
}
public class CloneMain完美克隆 {
public static void main(String[] a){
CloneBBB b1 = new CloneBBB();
b1.aInt = 11;
System.out.println("before clone,b1.aInt = "+ b1.aInt);
System.out.println("before clone,b1.unCA = "+ b1.unCAAA);
CloneBBB b2 = (CloneBBB)b1.clone();
b2.aInt = 22;
b2.unCAAA.doublevalue();
System.out.println("=================================");
System.out.println("after clone,b1.aInt = "+ b1.aInt);
System.out.println("after clone,b1.unCA = "+ b1.unCAAA);
System.out.println("=================================");
System.out.println("after clone,b2.aInt = "+ b2.aInt);
System.out.println("after clone,b2.unCA = "+ b2.unCAAA);
}
}
/*before clone,b1.aInt = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 111
=================================
after clone,b2.aInt = 22
after clone,b2.unCA = 222
*/
分享到:
相关推荐
在Java中,克隆分为浅克隆和深克隆。浅克隆只是复制对象的引用,而深克隆则会创建对象以及所有嵌套对象的新副本。 2. **浅克隆**:通过实现`Cloneable`接口并重写`Object`类的`clone()`方法,可以实现浅克隆。浅...
在编程领域,尤其是在Java语言中,对象的复制是常见的操作,这涉及到两个主要概念:浅拷贝(浅复制、浅克隆)和深拷贝(深复制、深克隆)。这两个概念是理解对象生命周期和内存管理的关键部分。下面将详细阐述它们的...
浅克隆和深克隆在Java对象中的应用 在Java编程语言中,克隆(Clone)是一种常见的对象复制机制。克隆可以分为浅克隆(Shallow Clone)和深克隆(Deep Clone)两种。浅克隆仅复制对象的引用,而深克隆则完全复制对象...
在Java中,深度克隆是一种用于创建对象副本的方法,它可以确保复制出的新对象与原对象之间没有任何引用关系,也就是说,新对象中的所有成员变量(包括引用类型)都是原对象对应成员变量的副本。这种特性使得深度克隆...
在Java中,对象克隆可以通过实现`Cloneable`接口并覆盖`Object`类中的`clone()`方法来完成。`Cloneable`接口本身不包含任何方法,只是一个标记接口,表明该类的对象可以被克隆。`Object`类的`clone()`方法会创建一个...
在Java中,克隆分为两种类型:浅克隆(Shallow Clone)和深克隆(Deep Clone)。浅克隆创建的新对象只复制了原对象的引用,这意味着如果原对象中包含可变的引用类型,如数组或复杂的数据结构,那么新对象和原对象会...
Java提供了三种方式来实现克隆:浅克隆、深克隆和使用Serializable实现深克隆。下面我们将对这三种方式进行详细的分析和实例讲解。 浅克隆(浅复制) 浅克隆是指将一个对象的所有成员变量值复制到另一个对象中,但...
在Java中,克隆有两种方式:浅克隆和深克隆。浅克隆只复制对象本身,而不复制对象引用的对象,因此如果对象中包含其他对象的引用,那么这些引用的对象不会被复制。而深克隆不仅复制对象本身,还会递归复制对象引用的...
为了解决这个问题,可以使用序列化和反序列化的方法实现深复制,或者使用第三方库如Apache Commons Lang的`SerializationUtils.clone()`方法。 另外,提到“实现java类之间的多对多联系”,在Java中,多对多关系...
- **导入语句**:包含了反射相关的包(如`java.lang.reflect`),集合操作包(如`java.util`),以及第三方库Apache Commons BeanUtils中的`BeanUtilsBean`类,用于处理JavaBean属性。 ##### 2. **类定义与注释** `...
为了实现深克隆,可以使用如下方式: ```java Teacher p = stu.getP(); Teacher p1 = (Teacher) p.clone(); stu.setP(p1); ``` 这段代码展示了如何通过克隆对象内部的引用类型对象来实现深克隆。 #### 三、`...
在Java中,浅复制可以通过`Object`类的`clone()`方法实现。但是,`clone()`方法默认的是浅复制,且需要被克隆的对象实现`Cloneable`接口。以下是一个简单的例子: ```java public class MyClass implements ...
在 Java 中,Cloneable 接口用于标识一个类可以被克隆,clone 方法用于克隆对象的内容。浅复制是指仅复制对象的引用,而深复制是指复制对象的内容。 在本实验中,我们创建了一个类 CloneableCircle,继承自 Circle...
在Java中,克隆主要涉及到`Object`类中的`clone()`方法,以及两种不同的克隆类型:浅克隆和深克隆。 一、克隆的原理与应用 `clone()`方法的工作原理是在堆上创建一个新的对象,这个新对象的内存分配与源对象相同,...
本文将深入探讨Java中的引用以及对象的克隆机制,包括浅拷贝和深拷贝的区别及其应用场景。 #### 二、Java中的引用 在Java中,当使用`new`关键字创建一个对象时,实际上创建的是一个指向该对象的引用。例如,以下...
实例055 Java对象的浅克隆 80 实例056 Java对象的深克隆 82 实例057 序列化与对象克隆 84 实例058 深克隆效率的比较 87 第7章 面向对象进阶 89 实例059 经理与员工的差异 90 实例060 重写父类中的方法 92 实例061 ...