引用类型传值
指针存放在局部变量表中,调用方法的时候,副本引用压栈,赋值仅改变副本的引用。但是如果直接改变副本引用的值,修改了引用地址的对象,此时方法以外的引用此地址对象当然被修改。(两个引用,同一个地址,任何修改行为2个引用同时生效)
啥意思呢,就是说引用类型在进入方法的时候是创建副本的,也就是说你修改了引用类型的引用是对外层没有任何影响的,但是你修改了引用类型被引用的值,那是会生效的。
值类型传值
值存放在局部变量表中,无论如何修改只会修改当前栈帧的值,方法执行结束对方法外不会做任何改变;此时需要改变外层的变量,必须返回主动赋值。
也就是说在方法内修改值类型是不生效的,需要有返回值才可以。
JVM操作
当一个方法刚刚开始执行的时候,这个方法的操作数栈是空的,在方法执行过程中,会有各种字节码指令往操作数栈怎里面写入和提取内容,也就是入栈和出栈操作。
方法退出的过程实际上就等同于把当前栈帧出栈,因此退出时可能执行的操作有:
- 恢复上层方法的局部变量表和操作数栈,
- 把返回值(如果有的话)压入调用者栈帧的操作数栈中,
- 调整pc计数器的值指向指令后面的一条指令
对于String类型
关于String,本质是final类型char数组,不可修改,只能赋值,在做参数传入方法修改时,其实是新建对象,必须返回重新对外面的变量赋值才会对外面的String引用生效。
引用类型会引起浅拷贝和深拷贝现象。
浅拷贝(Shallow Cop)
浅拷贝是按位拷贝对象,它会创建一个新对象,这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型,拷贝的就是基本类型的值;如果属性是内存地址(引用类型),拷贝的就是内存地址 ,因此如果其中一个对象改变了这个地址,就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝),即只复制对象空间而不复制资源。
浅拷贝的特点
- 对于基本数据类型的成员对象,因为基础数据类型是值传递的,所以是直接将属性值赋值给新的对象。基础类型的拷贝,其中一个对象修改该值,不会影响另外一个。
- 对于引用类型,比如数组或者类对象,因为引用类型是引用传递,所以浅拷贝只是把内存地址赋值给了成员变量,它们指向了同一内存空间。改变其中一个,会对另外一个也产生影响。
浅拷贝的实现
实现对象拷贝的类,需要实现 Cloneable 接口,并覆写 clone() 方法。
public class Subject {
private String name;
public Subject(String name) { this.name = name; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
@Override public String toString() { return "[Subject: " + this.hashCode() + ",name:" + name + "]"; } } public class Student implements Cloneable {
private Subject subject; private String name; private int age;
public Subject getSubject() { return subject; }
public void setSubject(Subject subject) { this.subject = subject; }
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; }
@Override public Object clone() { try { return super.clone(); } catch (CloneNotSupportedException e) { return null; } }
@Override public String toString() { return "[Student: " + this.hashCode() + ",subject:" + subject + ",name:" + name + ",age:" + age + "]"; } } public class ShallowCopy { public static void main(String[] args) { Subject subject = new Subject("yuwen"); Student studentA = new Student(); studentA.setSubject(subject); studentA.setName("Lynn"); studentA.setAge(20); Student studentB = (Student) studentA.clone(); studentB.setName("Lily"); studentB.setAge(18); Subject subjectB = studentB.getSubject(); subjectB.setName("lishi"); System.out.println("studentA:" + studentA.toString()); System.out.println("studentB:" + studentB.toString()); } } studentA:[Student: 460141958,subject:[Subject: 1163157884,name:lishi],name:Lynn,age:20] studentB:[Student: 1956725890,subject:[Subject: 1163157884,name:lishi],name:Lily,age:18]
|
浅拷贝和对象拷贝的区别
public static void main(String[] args) { Subject subject = new Subject("yuwen"); Student studentA = new Student(); studentA.setSubject(subject); studentA.setName("Lynn"); studentA.setAge(20); Student studentB = studentA; studentB.setName("Lily"); studentB.setAge(18); Subject subjectB = studentB.getSubject(); subjectB.setName("lishi"); System.out.println("studentA:" + studentA.toString()); System.out.println("studentB:" + studentB.toString()); }
|
studentA:[Student: 460141958,subject:[Subject: 1163157884,name:lishi],name:Lily,age:18] studentB:[Student: 460141958,subject:[Subject: 1163157884,name:lishi],name:Lily,age:18]
|
对象拷贝后没有生成新的对象,二者的对象地址是一样的;而浅拷贝的对象地址是不一样的。
深拷贝
通过上面的例子可以看到,浅拷贝会带来数据安全方面的隐患,例如我们只是想修改了 studentB 的 subject,但是 studentA 的 subject 也被修改了,因为它们都是指向的同一个地址。所以,此种情况下,我们需要用到深拷贝。
深拷贝,在拷贝引用类型成员变量时,为引用类型的数据成员另辟了一个独立的内存空间,实现真正内容上的拷贝。
深拷贝特点
- 对于基本数据类型的成员对象,因为基础数据类型是值传递的,所以是直接将属性值赋值给新的对象。基础类型的拷贝,其中一个对象修改该值,不会影响另外一个(和浅拷贝一样)。
- 对于引用类型,比如数组或者类对象,深拷贝会新建一个对象空间,然后拷贝里面的内容,所以它们指向了不同的内存空间。改变其中一个,不会对另外一个也产生影响。
- 对于有多层对象的,每个对象都需要实现 Cloneable 并重写 clone() 方法,进而实现了对象的串行层层拷贝。
- 深拷贝相比于浅拷贝速度较慢并且花销较大。
深拷贝实现
对于 Student 的引用类型的成员变量 Subject ,需要实现 Cloneable 并重写 clone() 方法
public class Subject implements Cloneable {
private String name;
public Subject(String name) { this.name = name; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
@Override protected Object clone() throws CloneNotSupportedException { return super.clone(); }
@Override public String toString() { return "[Subject: " + this.hashCode() + ",name:" + name + "]"; } }
|
在 Student 的 clone() 方法中,需要拿到拷贝自己后产生的新的对象,然后对新的对象的引用类型再调用拷贝操作,实现对引用类型成员变量的深拷贝
public class Student implements Cloneable {
private Subject subject; private String name; private int age;
public Subject getSubject() { return subject; }
public void setSubject(Subject subject) { this.subject = subject; }
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; }
@Override public Object clone() { try { Student student = (Student) super.clone(); student.subject = (Subject) subject.clone(); return student; } catch (CloneNotSupportedException e) { return null; } }
@Override public String toString() { return "[Student: " + this.hashCode() + ",subject:" + subject + ",name:" + name + ",age:" + age + "]"; } }
|
一样的使用方式
public class ShallowCopy { public static void main(String[] args) { Subject subject = new Subject("yuwen"); Student studentA = new Student(); studentA.setSubject(subject); studentA.setName("Lynn"); studentA.setAge(20); Student studentB = (Student) studentA.clone(); studentB.setName("Lily"); studentB.setAge(18); Subject subjectB = studentB.getSubject(); subjectB.setName("lishi"); System.out.println("studentA:" + studentA.toString()); System.out.println("studentB:" + studentB.toString()); } }
studentA:[Student: 460141958,subject:[Subject: 1163157884,name:yuwen],name:Lynn,age:20] studentB:[Student: 1956725890,subject:[Subject: 356573597,name:lishi],name:Lily,age:18]
|
由输出结果可见,深拷贝后,不管是基础数据类型还是引用类型的成员变量,修改其值都不会相互造成影响。