`

Java深复制与浅复制&Clone

    博客分类:
  • java
 
阅读更多

http://zzqrj.iteye.com/blog/572562

 

 

浅复制(浅克隆) : 浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。   

     深复制(深克隆):深复制把要复制的对象所引用的对象都复制了一遍。   

    Java 中对象的克隆 , 为了获取对象的一份拷贝,我们可以利用 Object 类的 clone() 方法。必须要遵循下面三点   

     1. 在派生类中覆盖基类的 clone() 方法,并声明为 public Object 类中的 clone() 方法为 protected 的】。   

     2. 在派生类的 clone() 方法中,调用 super.clone()   

     3. 在派生类中实现Cloneable 接口。

     Object 类里的 clone 方法是浅复制(浅克隆)

浅复制:

Java代码  收藏代码
  1. public   class  CloneTest {  
  2.     public   static   void  main(String[] args)  throws  CloneNotSupportedException {  
  3.         Teacher teacher=new  Teacher();  
  4.         teacher.setAge(40 );  
  5.         teacher.setName("Teacher Zhang" );  
  6.           
  7.         Student student1=new  Student();  
  8.         student1.setAge(20 );  
  9.         student1.setName("zhangsan" );  
  10.         student1.setTeacher(teacher);  
  11.           
  12.         Student student2=(Student)student1.clone();  
  13.         System.out.println(student2.getAge());  
  14.         System.out.println(student2.getName());  
  15.         System.out.println(student2.getTeacher().getAge());  
  16.         System.out.println(student2.getTeacher().getName());  
  17.           
  18.         System.out.println("~~~~~~~~~~~~~~~~~~~~~~~" );  
  19.         System.out.println(student1.getTeacher().getAge());  
  20.         System.out.println(student1.getTeacher().getName());  
  21.           
  22.         student2.setAge(18 );  
  23.         student2.getTeacher().setAge(50 ); //浅复制针对对象的引用没有重新开辟新的空间   
  24.         student2.getTeacher().setName("Teacher Li" );     //改变值后相应的都改变   
  25.           
  26.         System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~" );  
  27.         System.out.println(student1.getAge());  
  28.         System.out.println(student1.getTeacher().getAge());  
  29.         System.out.println(student1.getTeacher().getName());  
  30.     }  
  31. }  
  32. class  Teacher{  
  33.     private   int  age;  
  34.     private  String name;  
  35.     public   int  getAge() { return  age;}  
  36.     public   void  setAge( int  age) { this .age = age;}  
  37.     public  String getName() { return  name;}  
  38.     public   void  setName(String name) { this .name = name;}  
  39. }  
  40. class  Student  implements  Cloneable{  
  41.     private   int  age;  
  42.     private  String name;  
  43.     private  Teacher teacher;  
  44.     public   int  getAge() { return  age;}  
  45.     public   void  setAge( int  age) { this .age = age;}  
  46.     public  String getName() { return  name;}  
  47.     public   void  setName(String name) { this .name = name;}  
  48.     public  Teacher getTeacher() { return  teacher;}  
  49.     public   void  setTeacher(Teacher teacher) { this .teacher = teacher;}  
  50.     public  Object clone() throws  CloneNotSupportedException{  
  51.         return   super .clone();  
  52.     }  
  53. }  
public class CloneTest {
	public static void main(String[] args) throws CloneNotSupportedException {
		Teacher teacher=new Teacher();
		teacher.setAge(40);
		teacher.setName("Teacher Zhang");
		
		Student student1=new Student();
		student1.setAge(20);
		student1.setName("zhangsan");
		student1.setTeacher(teacher);
		
		Student student2=(Student)student1.clone();
		System.out.println(student2.getAge());
		System.out.println(student2.getName());
		System.out.println(student2.getTeacher().getAge());
		System.out.println(student2.getTeacher().getName());
		
		System.out.println("~~~~~~~~~~~~~~~~~~~~~~~");
		System.out.println(student1.getTeacher().getAge());
		System.out.println(student1.getTeacher().getName());
		
		student2.setAge(18);
		student2.getTeacher().setAge(50);//浅复制针对对象的引用没有重新开辟新的空间
		student2.getTeacher().setName("Teacher Li");	//改变值后相应的都改变
		
		System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~");
		System.out.println(student1.getAge());
		System.out.println(student1.getTeacher().getAge());
		System.out.println(student1.getTeacher().getName());
	}
}
class Teacher{
	private int age;
	private String name;
	public int getAge() {return age;}
	public void setAge(int age) {this.age = age;}
	public String getName() {return name;}
	public void setName(String name) {this.name = name;}
}
class Student implements Cloneable{
	private int age;
	private String name;
	private Teacher teacher;
	public int getAge() {return age;}
	public void setAge(int age) {this.age = age;}
	public String getName() {return name;}
	public void setName(String name) {this.name = name;}
	public Teacher getTeacher() {return teacher;}
	public void setTeacher(Teacher teacher) {this.teacher = teacher;}
	public Object clone()throws CloneNotSupportedException{
		return super.clone();
	}
}

 

深复制:

Java代码  收藏代码
  1. public   class  DeepCloneTest {  
  2. public   static   void  main(String[] args)  throws  CloneNotSupportedException {  
  3.         Teacher teacher = new  Teacher();  
  4.         teacher.setAge(40 );  
  5.         teacher.setName("Teacher Zhang" );  
  6.   
  7.         Student student1 = new  Student();  
  8.         student1.setAge(20 );  
  9.         student1.setName("zhangsan" );  
  10.         student1.setTeacher(teacher);  
  11.   
  12.         Student student2 = (Student) student1.clone();  
  13.         System.out.println(student2.getAge());  
  14.         System.out.println(student2.getName());  
  15.         System.out.println(student2.getTeacher().getAge());  
  16.         System.out.println(student2.getTeacher().getName());  
  17.   
  18.         System.out.println("~~~~~~~~~~~~~~~~~~~~~~~" );  
  19.         System.out.println(student1.getTeacher().getAge());  
  20.         System.out.println(student1.getTeacher().getName());  
  21.         student2.setAge(18 );  
  22.         student2.getTeacher().setAge(50 );  //浅复制针对对象的引用没有重新开辟新的空间   
  23.         student2.getTeacher().setName("Teacher Li" );  // 改变值后相应的都改变   
  24.   
  25.         System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~" );  
  26.         System.out.println(student1.getAge());  
  27.         System.out.println(student1.getTeacher().getAge());  
  28.         System.out.println(student1.getTeacher().getName());  
  29.     }  
  30. }  
  31. class  Teacher  implements  Cloneable {  
  32.     private   int  age;  
  33.     private  String name;  
  34.   
  35.     public   int  getAge() { return  age;}  
  36.     public   void  setAge( int  age) { this .age = age;}  
  37.     public  String getName() { return  name;}  
  38.     public   void  setName(String name) { this .name = name;}  
  39.     public  Object clone()  throws  CloneNotSupportedException {  
  40.         return   super .clone();  
  41.     }  
  42. }  
  43.   
  44. class  Student  implements  Cloneable {  
  45.     private   int  age;  
  46.     private  String name;  
  47.     private  Teacher teacher;  
  48.     public   int  getAge() { return  age;}  
  49.     public   void  setAge( int  age) { this .age = age;}  
  50.     public  String getName() { return  name;}  
  51.     public   void  setName(String name) { this .name = name;}  
  52.     public  Teacher getTeacher() { return  teacher;}  
  53.     public   void  setTeacher(Teacher teacher) { this .teacher = teacher;}  
  54.     public  Object clone()  throws  CloneNotSupportedException {  
  55.         Student student = (Student) super .clone();  
  56.         student.setTeacher((Teacher) (student.getTeacher().clone()));  
  57.         return  student;  
  58.     }  
  59. }  
public class DeepCloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
		Teacher teacher = new Teacher();
		teacher.setAge(40);
		teacher.setName("Teacher Zhang");

		Student student1 = new Student();
		student1.setAge(20);
		student1.setName("zhangsan");
		student1.setTeacher(teacher);

		Student student2 = (Student) student1.clone();
		System.out.println(student2.getAge());
		System.out.println(student2.getName());
		System.out.println(student2.getTeacher().getAge());
		System.out.println(student2.getTeacher().getName());

		System.out.println("~~~~~~~~~~~~~~~~~~~~~~~");
		System.out.println(student1.getTeacher().getAge());
		System.out.println(student1.getTeacher().getName());
		student2.setAge(18);
		student2.getTeacher().setAge(50); //浅复制针对对象的引用没有重新开辟新的空间
		student2.getTeacher().setName("Teacher Li"); // 改变值后相应的都改变

		System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~");
		System.out.println(student1.getAge());
		System.out.println(student1.getTeacher().getAge());
		System.out.println(student1.getTeacher().getName());
	}
}
class Teacher implements Cloneable {
	private int age;
	private String name;

	public int getAge() {return age;}
	public void setAge(int age) {this.age = age;}
	public String getName() {return name;}
	public void setName(String name) {this.name = name;}
	public Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

class Student implements Cloneable {
	private int age;
	private String name;
	private Teacher teacher;
	public int getAge() {return age;}
	public void setAge(int age) {this.age = age;}
	public String getName() {return name;}
	public void setName(String name) {this.name = name;}
	public Teacher getTeacher() {return teacher;}
	public void setTeacher(Teacher teacher) {this.teacher = teacher;}
	public Object clone() throws CloneNotSupportedException {
		Student student = (Student) super.clone();
		student.setTeacher((Teacher) (student.getTeacher().clone()));
		return student;
	}
}

 

分享到:
评论

相关推荐

    Java深复制与浅复制.doc

    在Java编程中,复制对象是常见的操作,主要分为两种方式:浅复制(Shallow Copy)和深复制(Deep Copy)。这两种复制方式的区别在于处理对象内部引用其他对象的情况。 1. **浅复制(浅克隆)**: 浅复制是指创建一...

    java的深复制与浅复制

    ### Java的深复制与浅复制 #### 一、概述 在Java编程中,对象的复制是一个常见的需求。复制对象的目的通常是为了保留一个备份或者创建一个新的实例来避免对原始对象的修改影响到其他部分的程序逻辑。Java提供了两...

    java List 深度复制方法

    在Java中,当我们使用`clone()`方法或`System.arraycopy()`进行复制时,通常得到的是浅复制的结果。这意味着原始对象和复制对象中的引用指向内存中的同一块区域。如果List中的元素是基本类型,这种复制方式是没问题...

    31.3、深复制和浅复制clone1

    在编程领域,尤其是在Java语言中,深复制和浅复制是两个重要的概念,它们与对象的复制行为密切相关。这里我们将深入探讨这两个概念,并通过实例来解释它们的区别。 首先,让我们了解基本数据类型的复制。在Java中,...

    Java Clone深拷贝与浅拷贝的两种实现方法

    Java Clone 深拷贝与浅拷贝的两种实现方法 Java Clone 是 Java 语言中的一种复制对象的机制,它可以将一个对象的所有属性和状态复制到另一个对象中,实现对象的深拷贝和浅拷贝。下面我们将讨论 Java 中的深拷贝和浅...

    java深复制浅复制的实现源代码

    本篇文章将深入探讨Java中的深复制和浅复制概念,并通过源代码示例进行详细解析。 首先,我们理解一下深复制和浅复制的区别: 1. **浅复制(Shallow Copy)**:浅复制只是复制了对象的引用,而不是对象本身。这...

    Java深浅clone

    在本文中,我们将深入探讨Java中的浅克隆(shallow clone)和深克隆(deep clone),并结合测试代码进行分析。 首先,让我们理解`Cloneable`接口。在Java中,如果一个类想要支持`clone()`方法,它必须实现`...

    android 浅复制和深复制-Java Generic Deep Copy 篇

    本文将深入探讨Java中的浅复制和深复制,并以Android为背景,结合具体的实例讲解如何实现Java泛型深拷贝。 首先,我们要理解浅复制和深复制的概念。浅复制(Shallow Copy)是指创建一个新的对象,然后将原对象引用...

    Java中对象的深复制和浅复制详解.doc

    对象复制分为两种主要类型:浅复制(浅克隆)和深复制(深克隆)。理解这两种复制方式的区别对于优化程序性能和避免意外数据更改至关重要。 1. **浅复制(浅克隆)** 浅复制是指创建一个新对象,该对象拥有原始...

    java_clone用法

    ### Java中的`clone`方法详解:浅拷贝与深拷贝 #### 一、引言 在Java中,`clone`方法提供了一种快速复制对象的方式。它属于`Object`类的一部分,但需要显式地在子类中声明并实现`Cloneable`接口才能正常使用。本文...

    Java中的深拷贝(深复制)和浅拷贝(浅复制) 示例代码

    为了理解深拷贝(深复制)和浅拷贝(浅复制),我们需要首先了解Java对象内存的分配方式以及引用的概念。 1. **对象复制的基础** 在Java中,当我们创建一个对象时,系统会在内存中为该对象分配一块空间,存储它的...

    Java对象深复制与浅复制实例详解

    Java对象深复制与浅复制实例详解 Java对象深复制与浅复制是Java编程中两个重要的概念,它们都是对象复制的方式,但它们有着不同的实现机制和应用场景。在本文中,我们将详细介绍Java对象深复制与浅复制的概念、实现...

    java clone的小例子

    在Java编程语言中,`clone()`方法是一个非常重要的概念,特别是在对象复制和克隆方面。这个小例子将帮助初学者理解如何在Java中使用`clone()`来创建对象的副本。让我们深入探讨`clone()`方法以及它在实际编程中的...

    Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍

    在Java编程语言中,深拷贝(Deep Copy)和浅拷贝(Shallow Copy)是两种不同的对象复制方式,它们涉及到内存中数据的复制和引用的处理。理解这两种拷贝方式对于开发过程中正确管理和操作对象至关重要。 浅拷贝,又...

    Java Clone(类的复制)实例代码

    在Java中,对象的默认复制是浅复制(shallow copy),这意味着只复制对象本身,而不复制它引用的对象。要实现深复制(deep copy),需要自定义`clone()`方法。下面我们将详细探讨Java中的克隆以及提供的实例代码。 ...

    java 深克隆浅克隆

    Java提供了两种主要的克隆方式:深克隆和浅克隆。 1. 浅克隆(Shallow Clone): 浅克隆是通过调用对象的`clone()`方法来实现的,这个方法是Object类提供的。当一个对象被浅克隆时,新创建的对象将拥有原始对象的...

    java clone

    在Java中,`clone`方法主要用于创建一个现有对象的副本,这个副本与原始对象具有相同的数据值。这个方法是Object类的一个成员,因此所有的Java类都默认拥有`clone`方法。不过,需要注意的是,`clone`方法并不执行深...

    java 深克隆 浅克隆

    在Java编程语言中,克隆是一种创建对象副本的方法,它允许我们复制一个对象并得到一个与原对象相同但独立的新对象。克隆分为两种主要类型:深克隆和浅克隆。理解这两种克隆的区别是Java面向对象编程中的重要概念。 ...

    java深复制

    这与浅复制(浅克隆)形成对比,浅复制只复制对象的直接属性,而不复制其引用的对象。在处理包含复杂数据结构的对象时,深复制尤其重要,因为它确保了副本与原始对象之间的独立性,修改副本不会影响原始对象。 Java...

Global site tag (gtag.js) - Google Analytics