Java中的浅拷贝与深拷贝 + Serializable的传送链接

Java中的等号赋值

Java的内存处理分为堆和栈，将基本变量（int , long, String变量值）存储在栈中，将对象指向堆的地址放在栈中，这就是说，如果对基本类型做等号赋值，就直接在栈中开辟内存空间存储，但对对象却只是重新开辟空间存储之前对象的地址。
如下代码给出说明

class Test
{
    public static void main(String arg[])
    {
        String s = "Brother Xiang";
        String t = s;
        t = t + " is very handsome!";
        System.out.println(s);//输出为Brother Xiang
        System.out.println(t);//输出为Brother Xiang is very handsome!
    }
}

说明将s， t 对应不同的String对象，修改t时不会影响s的值，以下为对对象的赋值

class Student
{
    private String name;
    private int age;

    public Student(String name, int age)
    {
        this.name = name;
        this.age = age;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public String toString()
    {
        StringBuilder s = new StringBuilder();
        s.append("Name: " + name + "  " + "Age: " + age);
        return s.toString();
    }
}

class Test
{
    public static void main(String arg[])
    {
        Student student1 = new Student("Bob", 14);
        Student student2 = student1;
        student2.setName("Jhon");

        System.out.print("student1: ");
        System.out.println(student1);
        System.out.print("student2: ");
        System.out.println(student2);
    }
}

执行结果为

可以看出，修改student2同时也修改了student1，这说明只赋值了对对象的引用

Java中浅拷贝与深拷贝

Java当中浅拷贝和深拷贝都是对于对象级别的来说的，浅拷贝和深拷贝的不同由如下代码就能看出

浅拷贝与深拷贝的简单形式

//浅拷贝只在Student类上加上Cloneable接口
//深拷贝则需要在Address类与Student类加上Cloneable接口

class Address
{
    private String province;
    private String city;
    public Address(String province, String city)
    {
        this.province = province;
        this.city = city;
    }
    public void setProvince(String province)
    {
        this.province = province;
    }
    public void setCity(String city)
    {
        this.city = city;
    }
    public String toString()
    {
        StringBuilder s = new StringBuilder();
        s.append("Location at: " + province + " " + city);
        return s.toString();
    }
}

class Student  implements Cloneable
{
    private String name;
    private int age;
    private Address address;

    public Student(String name, int age, Address address)
    {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public Address getAddress()
    {
        return address;
    }

    public String toString()
    {
        StringBuilder s = new StringBuilder();
        s.append("Name: " + name + "  " + "Age: " + age + "  "+ address);
        return s.toString();
    }

    public Student clone()
    {
        Student temp = null;
        try
        {
            temp = (Student)super.clone();  
        }
        catch(CloneNotSupportedException e)
        {
            e.printStackTrace();
        }
        return temp;
    }
}

class Test
{
    public static void main(String arg[])
    {
        Address address = new Address("GuangDong", "GuangZhou");
        Student student1 = new Student("Bob", 14, address);
        Student student2 = student1.clone();

        student2.setName("Jhon");
        Address student2_address = student2.getAddress();
        student2_address.setProvince("GuiZhou");
        student2_address.setCity("GuiYang");

        System.out.print("student1: ");
        System.out.println(student1);
        System.out.print("student2: ");
        System.out.println(student2);
    }
}
//它们两个具体区别在于，浅拷贝通过address访问Address类中方法时，student2的address发生改变，student1也发生改变，而深拷贝却不会发生改变，本代码仅给出浅拷贝的实现方式。

输出结果如下：

对对象的名字和地址进行改变时，其值也相应发生了改变，

浅拷贝与深拷贝的Serializable形式

传送门（转载链接）：快乐燕子会飞——java serializable深入了解