基本类型和引用类型在内存中的保存
Java中数据类型分为两大类：基本类型和对象类型
变量也有两种类型：基本类型和引用类型
基本类型的变量保存原始值，即它代表的值就是数值本身
引用类型的变量保存引用值，"引用值"指向内存空间的地址，代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
基本类型包括：byte,short,int,long,char,float,double,boolean
引用类型包括：类类型，接口类型和数组
引用传递和值传递
值传递：
方法调用时，实际参数把它的值传递给对应的形式参数，函数接收的是原始值的一个copy，此时内存中存在两个相等的基本类型，即实际参数和形式参数，后面方法中的操作都是对形参这个值的修改，不影响实际参数的值。
引用传递：
也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，函数接收的是原始值的内存地址；
在方法执行中，形参和实参内容相同，指向同一块内存地址，方法执行中对引用的操作将会影响到实际对象。
直接看下例子
public class Test {
public static void main(String args[]) {
int number=123;
Student stu1 = new Student();
stu1.setNumber(number);
Student stu2 =stu1;
stu2.setNumber(321);
System.out.println(number);
System.out.println(stu1 == stu2);
System.out.println("学生1:" + stu1.getNumber());
System.out.println("学生2:" + stu2.getNumber());
}
static class Student{
private int number;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}
}
测试结果：
在
main方法中：number是基本类型，采用值传递，不影响实际参数的值。Student是类类型，采用引用传递，指向同一块内存地址，对引用的操作将会影响到实际对象。Student stu2 =stu1;引用传递把stu1和stu2指向内存堆中同一个对象。所以当stu2.setNumber(321);时，stu1中的number值也会发生改变
浅拷贝
想要复制一个新对象，也就是开辟一块新的内存地址，那么就要使用到拷贝
1.需要实现Clonenable接口，该接口为标记接口(不含任何方法)
2.覆盖clone()方法，访问修饰符设为public。方法中调用super.clone()方法得到需要的复制对象
public class Test {
public static void main(String args[]) {
int number=123;
Student stu1 = new Student();
stu1.setNumber(number);
Student stu2 = (Student)stu1.clone();
stu2.setNumber(321);
System.out.println(number);
System.out.println(stu1 == stu2);
System.out.println("学生1:" + stu1.getNumber());
System.out.println("学生2:" + stu2.getNumber());
}
static class Student implements Cloneable{
private int number;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public Object clone() {
Student stu = null;
try{
stu = (Student)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
return stu;
}
}
}
测试结果：
main方法中用Student stu2 = (Student)stu1.clone();代替Student stu2 =stu1;，这样才会指向不同的内存地址，stu1 == stu2为false说明指向的地址块是不同的，所以对象中number值也是不同的
深拷贝
之前在Student对象中的成员属性都是基本类型的，那如果是引用类型的呢？
先看测试代码
public class Test {
public static void main(String args[]) {
int number=123;
Address addr = new Address();
addr.setAdd("A");
Student stu1 = new Student();
stu1.setNumber(number);
stu1.setAddr(addr);
Student stu2 = (Student)stu1.clone();
stu2.setNumber(321);
addr.setAdd("B");
System.out.println(number);
System.out.println(stu1 == stu2);
System.out.println(stu1.getAddr()==stu2.getAddr());
System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
}
static class Student implements Cloneable{
private int number;
private Address addr;
public Address getAddr() {
return addr;
}
public void setAddr(Address addr) {
this.addr = addr;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public Object clone() {
Student stu = null;
try{
stu = (Student)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
return stu;
}
}
static class Address {
private String add;
public String getAdd() {
return add;
}
public void setAdd(String add) {
this.add = add;
}
}
}
测试结果：
可以看出Student对象指向不同的内存地址，但是成员属性Address对象在stu1和stu2中都是指向同一内存地址
原因是浅拷贝只是拷贝了addr变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。
所以，为了达到真正的拷贝对象，而不是纯粹引用复制。我们需要将Address类可复制化，并且修改clone方法，同时Student类也要做下修改
static class Student implements Cloneable{
private int number;
private Address addr;
public Address getAddr() {
return addr;
}
public void setAddr(Address addr) {
this.addr = addr;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public Object clone() {
Student stu = null;
try{
stu = (Student)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
stu.addr = (Address)addr.clone();
return stu;
}
}
static class Address implements Cloneable{
private String add;
public String getAdd() {
return add;
}
public void setAdd(String add) {
this.add = add;
}
@Override
public Object clone() {
Address addr = null;
try{
addr = (Address)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
return addr;
}
}
重点：
1.在Address类中实现Cloneable接口，修改clone方法
2.在Student类的clone方法中加上stu.addr = (Address)addr.clone();实现深拷贝
关于clone()
JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。
和new的区别
共同点：都是分配内存，对象都是指向不同的内存地址
不同点：new创建一个对象，clone复制一个对象。new是返回的新对象，而调用clone()方法时，拷贝对象已经包含了一些原来对象的信息，而不是对象的初始信息
复制引用(引用传递)和复制对象
引用都存放在栈区，类对象存放于堆区
从源码角度看clone()
protected native Object clone() throws CloneNotSupportedException;
在Object类的clone()是一个native方法，native方法的效率一般来说都是远高于Java中的非native方法。这也解释了为 什么要用Object中clone()方法而不是先new一个类，然后把原始对象中的信息赋到新对象中，虽然这也实现了clone功能。Java中所有的类是缺省继承Object类的，所以可以直接使用protected属性的方法
为什么要实现Cloneable接口
Cloneable接口是不包含任何方法的，其实这个接口仅仅是一个标志，而且这个标志也仅仅是针对 Object类中clone()方法的，如果实现clone()方法的类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了 super.clone()方法），那么Object的clone()方法就会抛出CloneNotSupportedException异常
内存地址
在以上测试中我都是以==去判断两个对象是否指向同一内存地址，如果要查看具体的内存地址值可以这样做
1.可以使用hashCode()方法，在不重写hashCode()的情况下，默认是返回内存地址，不同的hash值代表不同的内存地址
2.使用System.identityHashCode(Object)方法可以返回对象的内存地址,不管该对象的类是否重写了hashCode()方法
源码展示
Object类下
public native int hashCode();
System类下
public static native int identityHashCode(Object x);
拓展
String类重写了hashcode()
private int hash;
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
Java中所有类是缺省继承Object类的，所以都有资格去重写hashcode()方法
总结：
对象内部只有基本数据类型，那用 clone() 方法获取到的就是这个对象的深拷贝，
而如果对象内部还有引用数据类型，那用 clone() 方法就是一次浅拷贝操作。
浅拷贝
对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝
深拷贝
对基本数据类型进行值传递，对引用数据类型，会对引用指向的对象进行拷贝，此为深拷贝。也就是在clone()方法对其内的引用类型的变量再进行一次 clone()
