cloneable接口

最新推荐文章于 2024-07-20 23:55:03 发布
最新推荐文章于 2024-07-20 23:55:03 发布
阅读量759 收藏 14
点赞数 18
分类专栏： java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44794897/article/details/140286075
版权

Cloneable 接口是 Java 标准库中的一个标记接口，用于指示一个类的对象能够被合法地克隆。克隆是指创建一个对象的副本，即一个新的对象，其内容与原对象相同。Cloneable 接口本身没有方法，它只是一个标记，表示实现这个接口的类支持克隆操作。

Cloneable 接口的用途

Cloneable 接口的主要用途是与 Object 类中的 clone() 方法配合使用：

  1. 表示类支持克隆：

    • 如果一个类实现了 Cloneable 接口，那么表示该类的对象可以被克隆。
    • clone() 方法在调用时会检查对象是否实现了 Cloneable 接口。如果没有实现，则会抛出 CloneNotSupportedException 异常。

  2. 支持浅克隆：

    • Object 类的 clone() 方法通过直接复制对象的字段来实现浅克隆。
    • 如果对象的字段是基本数据类型或不可变对象（如 String），那么浅克隆已经足够。
    • 如果对象的字段是可变对象（如数组或自定义对象），则需要实现深克隆。

Cloneable 接口的实现原理

实现 Cloneable 接口并使用 clone() 方法通常需要以下步骤：

  1. 实现 Cloneable 接口：

    • 类需要实现 Cloneable 接口，表示该类支持克隆操作。

  2. 重写 clone() 方法：

    • 在类中重写 clone() 方法，并调用 super.clone() 方法来执行实际的克隆操作。

  3. 处理异常：

    • clone() 方法需要处理 CloneNotSupportedException 异常。

  4. 可选：实现深克隆：

    • 如果需要实现深克隆，需在 clone() 方法中手动克隆可变对象的字段。

示例代码

以下是一个实现 Cloneable 接口并支持克隆操作的简单示例：

class Person implements Cloneable {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 调用 Object 类的 clone() 方法
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }

    public static void main(String[] args) {
        try {
            Person person1 = new Person("Alice", 30);
            Person person2 = (Person) person1.clone(); // 克隆对象

            System.out.println(person1);
            System.out.println(person2);

            System.out.println("person1 == person2: " + (person1 == person2)); // false
            System.out.println("person1.equals(person2): " + person1.equals(person2)); // true
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中：

  • Person 类实现了 Cloneable 接口，并重写了 clone() 方法。
  • 在 clone() 方法中调用了 super.clone()，这会调用 Object 类的 clone() 方法，创建一个新的 Person 对象，其字段值与原对象相同。
  • 克隆操作后，person1 和 person2 是两个不同的对象，但它们的内容是相同的。

深克隆示例

如果类中包含可变对象，需要实现深克隆，如下所示：

class Address implements Cloneable {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

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

    @Override
    public String toString() {
        return "Address{city='" + city + "'}";
    }
}

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

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();
        cloned.address = (Address) address.clone(); // 深克隆地址
        return cloned;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", address=" + address + "}";
    }

    public static void main(String[] args) {
        try {
            Address address = new Address("New York");
            Person person1 = new Person("Alice", 30, address);
            Person person2 = (Person) person1.clone();

            System.out.println(person1);
            System.out.println(person2);

            person2.address.setCity("San Francisco");

            System.out.println("After modifying address:");
            System.out.println(person1);
            System.out.println(person2);

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

在这个深克隆示例中：

  • Address 类也实现了 Cloneable 接口，并重写了 clone() 方法。
  • 在 Person 类的 clone() 方法中，不仅克隆了 Person 对象本身，还克隆了其包含的 Address 对象，确保 Person 对象的深克隆。

通过实现 Cloneable 接口和重写 clone() 方法，Java 对象可以支持浅克隆或深克隆，根据具体需求灵活处理对象的复制。

深克隆（Deep Copy）和浅克隆（Shallow Copy）是两种不同的对象复制方式。它们的主要区别在于复制的深度，即对于引用类型字段（如对象、数组等）的处理方式不同。

深浅克隆

浅克隆

浅克隆是指创建一个新对象，这个新对象的所有字段都与原对象的字段值相同。但对于引用类型字段，新对象只是复制了引用，而不是引用指向的实际对象。换句话说，浅克隆后的新对象和原对象共享同一个引用对象。

示例

假设有一个 Person 类，包含一个引用类型字段 Address：

class Address {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

class Person implements Cloneable {
    private String name;
    private Address address;

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 浅克隆
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', address=" + address.getCity() + "}";
    }
}

测试浅克隆：

public class ShallowCloneTest {
    public static void main(String[] args) {
        try {
            Address address = new Address("New York");
            Person person1 = new Person("Alice", address);
            Person person2 = (Person) person1.clone();

            System.out.println("Before modification:");
            System.out.println(person1);
            System.out.println(person2);

            person2.getAddress().setCity("San Francisco");

            System.out.println("After modification:");
            System.out.println(person1);
            System.out.println(person2);

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

Before modification:
Person{name='Alice', address=New York}
Person{name='Alice', address=New York}
After modification:
Person{name='Alice', address=San Francisco}
Person{name='Alice', address=San Francisco}

可以看到，修改 person2 的地址会影响 person1，这是因为浅克隆只是复制了引用，两个对象共享同一个 Address 实例。

深克隆

深克隆是指创建一个新对象，这个新对象的所有字段都与原对象的字段值相同。对于引用类型字段，新对象会创建一个新的实例，并复制引用对象的内容。这样，深克隆后的新对象和原对象是完全独立的。

示例

为 Person 类实现深克隆：

class Person implements Cloneable {
    private String name;
    private Address address;

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();
        cloned.address = new Address(this.address.getCity()); // 深克隆
        return cloned;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', address=" + address.getCity() + "}";
    }
}

测试深克隆：

public class DeepCloneTest {
    public static void main(String[] args) {
        try {
            Address address = new Address("New York");
            Person person1 = new Person("Alice", address);
            Person person2 = (Person) person1.clone();

            System.out.println("Before modification:");
            System.out.println(person1);
            System.out.println(person2);

            person2.getAddress().setCity("San Francisco");

            System.out.println("After modification:");
            System.out.println(person1);
            System.out.println(person2);

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

Before modification:
Person{name='Alice', address=New York}
Person{name='Alice', address=New York}
After modification:
Person{name='Alice', address=New York}
Person{name='Alice', address=San Francisco}

可以看到，修改 person2 的地址不会影响 person1，这是因为深克隆创建了 Address 的新实例，每个 Person 对象有自己的 Address 实例。

总结

  • 浅克隆：复制对象时，只复制原对象的基本类型字段和引用类型字段的引用。克隆对象与原对象共享同一个引用对象。
  • 深克隆：复制对象时，除了复制基本类型字段外，对于引用类型字段，也会创建新的实例并复制其内容。克隆对象与原对象完全独立。
赚够壹仟万
关注
  • 18
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java cloneable 接口_JDK源码阅读笔记-Cloneable接口
weixin_31955599的博客
02-23 208
JDK 版本：1.8代码地址1.前言clone方法能方便的获得一个对象的拷贝，但其中也有些细节需要注意。2.实现注意事项2.1 要调用 clone 方法必须实现 Cloneable 接口如果类没有实现 Cloneable 接口，类的实例却调用了 clone 方法，则会抛出CloneNotSupportedException异常。用反射机制去调用 Objec 类的 clone 方法，可以观察到这个现...
Cloneable接口
F_Just
04-21 2275
Cloneable接口 1、Cloneable接口 Cloneable是一个接口，实现这个接口后，可以在类中重写Object中的clone方法，然后通过类调用clone方法进行克隆，如果不实现Cloneable接口，则会抛出CloneNotSupportedException异常。Object中clone方法： protected native Object clone() throws CloneNotSupportedException 2、Object中的clone方法是一个空的方法，那么他是如何判
java cloneable 接口_Cloneable 接口 记号接口（标记接口）
weixin_30262217的博客
02-23 312
Cloneable 接口指示了一个类提供了一个安全的clone方法。首先了解Object.clone()方法：clone是Object超类的一个protected方法，用户代码不能直接调用这个方法。Object的子类只能调用Object超类中受保护的clone方法来克隆它自己的对象，必须重新定义clone为public才能允许所有方法调用这个类的实例的clone方法克隆对象。clone方法的作用：...
【Java SE】接口实例——Cloneable 关于深拷贝与浅拷贝
m0_61814277的博客
05-16 2433
本期内容将会进一步了解接口实例Clonable接口，深入理解接口与抽象类的区别，并讲解Object类的方法。
Java中的Cloneable接口
weixin_60794607的博客
05-10 2584
1.Cloneable接口的作用 Cloneable是标记接口（其方法体为空），它用来表示一个类拥有某些希望具有的特征。实现Cloneable接口的类被标记为可克隆的，而且其对象可以使用Object类中定义的clone()方法克隆。如果没有实现Cloneable类对象，调用clone()就回抛出CloneNotSupportedException异常 java.lang包中的 Cloneable 接口的定义如下所示： package java.lang public interface Clone
Java API接口详述.rar
12-08
2. `java.lang.Cloneable`: 标记接口，表示对象可以被克隆。 3. `java.lang.Runnable`: 实现此接口的类可以作为线程执行的任务。 4. `java.util.List`, `Set` 和 `Map`: 这些接口定义了集合框架的核心接口，提供数据...
2022年抽象类和接口2.ppt
11-02
在Java编程语言中，抽象类和接口是两种...同时，`Calendar` 类和 `GregorianCalendar` 类，以及 `Comparable`、`Cloneable` 接口等，都是在实际开发中经常遇到的工具，理解并熟练运用它们可以提高代码的效率和质量。
Java实验7抽象类和接口.pdf
10-07
抽象类和接口 ...通过这个实验，我们学习了抽象类、接口、Cloneable 接口和多态性的概念，并掌握了如何使用它们来编写 Java 程序。我们还学习了浅拷贝和深拷贝的概念，并掌握了如何消除浅拷贝的方法。
day16-Map、可变参数、Cloneable.pdf
11-02
总的来说，Map接口提供了一种高效的方式来存储和检索键值对数据，可变参数简化了函数调用，Cloneable接口支持对象的克隆，而多线程则为并发编程提供了基础。理解和掌握这些知识点对于Java开发至关重要。
学习Java实验7抽象类和接口.pdf
10-05
本实验主要讲解了Java中的抽象类和接口的概念和使用方法，并且深入探讨了 Cloneable 接口和 clone 方法在对象内容复制中的应用。 一、抽象类的概念和使用方法 在 Java 中，抽象类是一个不能被实例化的类，它提供了...
Java内存模型
weixin_44267758的博客
07-19 564
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
最新发布
山重水复疑无路，柳暗花明又一村。
07-20 482
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1040
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 171
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1040
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java实验2
qq_64727229的博客
07-16 534
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
每 日练 习
m0_67187271的博客
07-19 794
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 458
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值