Clone使用

news2024/11/25 7:11:22

实现克隆接口:clone方法是默认是Object的方法

1)这个接口是一个标记性的接口(空接口)，他们内部都没有方法和属性，实现这个接口表示这个对象都可以进行克隆，我们调用Object对象的Object.clone()方法，如果没有实现Cloneable的类对象调用clone()就会抛出CloneNotSupportedException异常

2)我们想要一个类具备拷贝实例的功能，除了要实现Cloneable接口，还必须要重写Object类的clone()方法

3)我们可以看到Object类的clone()方法是被protected修饰的，我们需要在重写的clone()方法通过super关键字调用Object的clone()方法，

4)Cloneable接口发挥的是标记功能，自定义类型需要用户自己去标记哪些类是可以被clone的，这个标记就是去实现Cloneable接口，试下了该接口的类就表示该类创建的对象可以被克隆

想要克隆自定义类型，就要实现克隆接口public interface Cloneable(){};空接口也叫作标记接口

1.浅拷贝:我们在拷贝一个对象的时候，对对象的基本数据类型的成员变量进行拷贝，但是对引用类型的成员变量只进行引用的传递，并没有创建一个新的对象，当对引用类型的修改会影响到要拷贝的对象，简而言之，浅拷贝只是复制所拷贝的地址，而不复制他的所引用的对象

package com.example.demo;
import lombok.Data;
@Data
class Student implements Cloneable{
    public String username;
    public String password;
    public Student(String username, String password) {
        this.username = username;
        this.password = password;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class HelloWorld{
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1=new Student("李佳伟","12503487");
        Student student2= (Student) student1.clone();
        System.out.println(student1==student2);
//false,两个引用分别指向的对象的地址值不相同
    }
}
false
Student{username='李佳伟', password='12503487'}
Student{username='李佳伟', password='12503487'}

上面画的图就是克隆出来了一个新的对象和新的引用，但是由于这个对象的组成是一个基本数据类型，所以只对基本数据类型复制了一份

class Money{
    public double m=100.5;
        }
class Student implements Cloneable
{
    String name;
//实现这个接口要重写克隆方法
Money money=new Money();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Tomact {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1=new Student();
        Student student2= (Student) student1.clone();
        System.out.println(student1.money.m);
        System.out.println(student2.money.m);
        student2.money.m=199;
        System.out.println(student1.money.m);
        System.out.println(student2.money.m);
//都变成了199
    }
}

1)此时我们单纯的修改student1的username此时是不会修改student2的username的

2) 我们观察下面的代码，我们将Money类的实例引用作为了Student类的一个字段，new 一个Student类型的对象，将这个student1对象拷贝到student2对象，这里面的拷贝就是浅拷贝了，只是将student1的对象的money的引用进行拷贝了一份，此时student1和student2指向的两个不同对象的money引用指向的是同一个对象

package com.example.demo;
import lombok.Data;
@Data
class Student implements Cloneable{
    public String username;
    public String password;
    public Student(String username, String password) {
        this.username = username;
        this.password = password;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class HelloWorld{
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1=new Student("李佳伟","12503487");
        Student student2= (Student) student1.clone();
        System.out.println(student1==student2);//false
    }
}

由此看出，只是拷贝了money对象的地址，他们仍然指向的是同一个对象，此时原来的对象和新被克隆出来的对象的成员变量money指向地址的都是 0x100

下面我们来实现一个真正意义上的深拷贝:

深拷贝:

我们在拷贝对象的时候，除了对基本的数据类型的成员变量进行拷贝的时候，对引用类型的成员变量进行拷贝的时候，创建一个新的对象来进行保存引用类型的成员变量，简单来说深拷贝不光把地址新创建了一份，还会把要进行复制的对象里面的引用所指向的对象也拷贝了一份

class Money implements Cloneable{
    public double m=100.5;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return  super.clone();

    }
}
class Student implements Cloneable
{
    String name;
    //实现这个接口要重写克隆方法
    Money money=new Money();
    @Override
    protected Object clone() throws CloneNotSupportedException {

          //return super.clone();正常情况下，Person的克隆是在这里面执行
         //Student s=(Student) super.clone();
         //return s;
        //1克隆Person
        Student s= (Student) super.clone();
        //2克隆当前的Money对象
        s.money= (Money) this.money.clone();
        return s;


        // 由于下面要进行Money的克隆
    }
}

public class Tomact {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1=new Student();
        Student student2= (Student) student1.clone();
        System.out.println(student1.money.m);
        System.out.println(student2.money.m);
        student2.money.m=199;
        System.out.println(student1.money.m);
        System.out.println(student2.money.m);
        //这里面只是克隆了一个person，我们要想实现深拷贝
        //就要把Student对象中的money这个对象也克隆一份
    }
}

Java中的clone方法是一个浅拷贝，引用类型仍然在传递引用，我们可以通过继续调用clone方法，对该对象的引用类型变量在实现一次clone的方法来实现深拷贝

1)让我们的两个类都实现cloneable接口

2)在我们的Student类里面不光克隆Student对象里面的属性，还进行克隆Student类中的引用类型所指向的对象也进行克隆一份

class Money implements Cloneable{
    public int money;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Student implements Cloneable{
    public String username;
    public String password;
    public Student(String username, String password) {
        this.username = username;
        this.password = password;
    }
    Money money=new Money();
    @Override
    protected Object clone() throws CloneNotSupportedException {
       Student student=(Student)super.clone();
       student.money=(Money)money.clone();
       return student;
    }
    @Override
    public String toString() {
        return "Student{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
public class HelloWorld{
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1=new Student("李佳伟","12503487");
        Student student2= (Student) student1.clone();
        student1.money.money=999;
        System.out.println(student1.money.money);//999
        System.out.println(student2.money.money);//0
    }
}

我们拷贝简单类型是深拷贝，拷贝引用类型是浅拷贝，我们要想实现深拷贝，就要拷贝一下这个对象，只是拷贝地址值，是不能实现真正意义上的深拷贝的

1)咱们的数组的四种拷贝方法都是浅拷贝，因为我们大部分情况下是拷贝地址的，而现在是拷贝数据

2)深拷贝:如果我们拷贝完成之后，我们通过一个引用去访问去修改拷贝完成之后的值，是不会修改原来的值

3)浅拷贝:相反拷贝通过引用来进行修改，原来的值发生变化，就叫做浅拷贝

如果问数组的拷贝是什么拷贝？先问问到底是再拷贝什么？？？