一、浅拷贝:
(1) 对于数据类型是基本数据类型的成员变量,浅拷贝会直接进行值传递,也就是将该属性复制一份给新的对象。因为是两份不同的数据,所以对其中一的对象的成员变量值进行修改,不会影响另一个对象拷贝得到的数据。
(2) 对于数据类型是引用类型的成员变量,比如说成员变量是某个数组,某个类的对象等,那么浅拷贝会进行引用传递,也就是只是将该成员变量的引用指(内存地址)复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下,在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
实现浅拷贝主要有以下两种方式:
-
通过拷贝构造方法
public class CopyConstructor {
public static void main(String[] args) {
Age a = new Age(20);
Person p1 = new Person(a,"宁采臣");
Person p2 = new Person(p1);
System.out.println("p1是"+p1);
System.out.println("p2是"+p2);
//修改p1的各属性值,观察p2得到各属性值是否跟随变化
p1.setName("聂小倩");
a.setAge(18);
System.out.println("修改后的p1是"+p1);
System.out.println("修改后的p2是"+p2);
}
}
class Person{
private Age age;
private String name;
public Person(Age age,String name){
this.age = age;
this.name = name;
}
//拷贝构造方法
public Person(Person p){
this.name = p.name;
this.age = p.age;
}
public void setName(String name) {
this.name = name;
}
public String toString(){
return this.name + " " + this.age;
}
}
class Age{
private int age;
public Age(int age){
this.age = age;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return this.age;
}
public String toString(){
return getAge()+"";
}
}
输出结果:
结果分析:这里对Person类选择了两个具有代表性的属性值:一个是引用传递类型;另一个是字符串类型(属于常量)。
通过拷贝构造方法进行了浅拷贝,各属性值成功复制。其中,p1值传递部分的属性值发生变化时,p2不会随之改变;而引用传递部分属性值发生变化时,p2也随之改变。
要注意:如果在拷贝构造方法中,对引用数据类型变量逐一开辟新的内存空间,创建新的对象,也可以实现深拷贝。而对于一般的拷贝构造,则一定是浅拷贝。
-
通过重写clone()方法进行浅拷贝
Object类是类结构的根类,其中有一个方法为protected Object clone() throw CloneNotSupportedException,这个方法就是进行的浅拷贝。有了这个浅拷贝的模板,就可以通过调用clone()方法来实现对象的浅拷贝,但是需要注意:
(1)Object类虽然有这个方法,但是这个方法是受保护的(被projected修饰),所以是无法直接使用。
(2)使用clone方法的类必须实现Cloneable接口,否则会抛出异常CloneNotSupportedException。
(3)对于以上两点,解决方法是,在使用clone方法的类中重写了clone()方法,通过super.clone()调用Object类中的原clone方法
实例代码如下:
对Student类的对象进行拷贝,直接重写clone()方法,通过调用clone方法完成浅复制。
public class ShallowCopy {
public static void main(String[] args) {
Age a = new Age(18);
Student stu1 = new Student("宁采臣",a,174);
//通过调用重写后的clone方法进行浅拷贝
Student stu2 =(Student)stu1.clone();
System.out.println(stu1.toString());
System.out.println(stu2.toString());
//尝试修改stu1中的各属性,观察stu2的属性有没有变化
stu1.setName("聂小倩");
//修改age这个引用类型的成员变量的值
a.setAge(20);
//stu1.setaAge(new Age(20));使用这种方式修改age属性值的话,stu2是不会跟着改变的。因为创建了一个新的Age类对象而不是改变原对象的实例值
stu1.setLength(158);
System.out.println(stu1.toString());
System.out.println(stu2.toString());
}
}
/*
*创建年龄类
*/
class Age{
//年龄类的成员变量(属性)
private int age;
//构造方法
public Age(int age){
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return this.age+"";
}
}
/*
*创建学生类
*/
class Student implements Cloneable{
//学生类的成员变量(属性),其中一个属性为类的对象
private String name;
private Age aage;
private int length;
//构造方法,其中一个参数为另一个类的对象
public Student(String name,Age a,int length){
this.name = name;
this.aage = a;
this.length = length;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Age getAge() {
return aage;
}
public void setAge(Age age) {
this.aage = age;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
//设置输出的字符串形式
@Override
public String toString() {
return "姓名是:"+this.getName()+",年龄为:"+this.getAge().toString()+",长度是:"+this.getLength();
}
//重写Object类的clone方法
public Object clone(){
Object obj = null;
try {
obj = super.clone();
} catch (CloneNotSupportedException e){
e.printStackTrace();
}
return obj;
}
}
输出结果:
分析结果:
基本数据类型是值传递,所以修改值后不会影响另一个对象的该属性值;引用数据类型是地址传递(引用传递),所以修改值后另一个对象的该属性值会同步被修改。
String类型非常特殊,所以额外设置了一个字符串类型的成员变量来进行说明。首先,String类型属于引用数据类型,不属于基本数据类型,但是String类型的数据是存放在常量池中的,也就是无法修改的!也就是说,当将name属性从“宁采臣”改为“聂小倩"后,并不是修改了这个数据的值,而是把这个数据的引用从指向”宁采臣“这个常量改为了指向”聂小倩“这个常量。在这种情况下,另一个对象的name属性值仍然指向”宁采臣“不会受到影响。
二、深拷贝:
深拷贝是一个整个独立的对象拷贝,深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。
简而言之,深拷贝把要复制的对象所引用的对象都复制了一遍。
实例代码:
package com.test;
public class DeepCopy {
public static void main(String[] args) throws CloneNotSupportedException {
Teacher2 teacher = new Teacher2();
teacher.setName("riemann");
teacher.setAge(27);
Student3 student1 = new Student3();
student1.setName("edgar");
student1.setAge(18);
student1.setTeacher(teacher);
Student3 student2 = (Student3) student1.clone();
System.out.println("拷贝后");
System.out.println(student2.getName());
System.out.println(student2.getAge());
System.out.println(student2.getTeacher().getName());
System.out.println(student2.getTeacher().getAge());
System.out.println("修改老师的信息后-------------");
// 修改老师的信息
teacher.setName("Games");
System.out.println(student1.getTeacher().getName());
System.out.println(student2.getTeacher().getName());
}
}
class Teacher2 implements Cloneable {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Student3 implements Cloneable {
private String name;
private int age;
private Teacher2 teacher;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Teacher2 getTeacher() {
return teacher;
}
public void setTeacher(Teacher2 teacher) {
this.teacher = teacher;
}
public Object clone() throws CloneNotSupportedException {
// 浅复制时:
// Object object = super.clone();
// return object;
// 改为深复制:
Student3 student = (Student3) super.clone();
// 本来是浅复制,现在将Teacher对象复制一份并重新set进来
student.setTeacher((Teacher2) student.getTeacher().clone());
return student;
}
}
输出结果:
拷贝后
edgar
18
riemann
27
修改老师的信息后-------------
Games
riemann
结果分析:
两个引用student1和student2指向不同的两个对象,两个引用student1和student2中的两个teacher引用指向的是两个对象,但对teacher对象的修改只能影响student1对象,所以说是深拷贝。