Java对象克隆

最新推荐文章于 2024-07-31 09:30:00 发布
最新推荐文章于 2024-07-31 09:30:00 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： Java程序语言 文章标签： 克隆 浅克隆 深克隆 拷贝 模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhliro/article/details/47382153
版权

Java对象克隆

1. 介绍

克隆就是复制一个对象的副本。Java支持我们对一个对象进行克隆，通常用在装饰模式和原型模式中。

一个对象中可能有基本数据类型（如:int、long、double等）的属性，也同时含有引用数据类型（如数组、集合等）的属性，所以在对象克隆时分为浅克隆与深克隆两种。那么，什么是浅克隆，什么又是深克隆呢？

浅克隆是指克隆对象时仅仅克隆对象本身（包括对象中的基本类型的变量），而不克隆对象包含的引用指向的子对象，即克隆对象与被克隆对象共享子对象。

深克隆不仅克隆对象本身，而且克隆对象包含的引用指向的所有子对象。

2. clone()方法

Object类中的clone()方法可以实现将对象复制一份并返回给调用者。一般而言，clone()方法满足：

  1. 对任何的对象obj，都有obj.clone() != obj，即克隆对象与原对象不是同一个对象。
  2. 对任何的对象obj，都有obj.clone().getClass() == obj.getClass()，即克隆对象与原对象的类型一样。
  3. 如果对象obj的equals()方法定义恰当，那么obj.clone().equals(obj)应该成立。

Object类的clone()方法执行特定的复制操作，如果此对象的类不能实现接口Cloneable，则会抛出CloneNotSupportedException异常。

在Java中，为了获取对象的一份拷贝，我们可以重写Object类的clone()方法，一般遵循下列步骤：

  1. 在类中实现Cloneable接口。
  2. 在类中覆盖基类的clone()方法，并声明为public。
  3. 在派生类的clone()方法中，调用super.clone()

3. 浅克隆

示例：

地址类：

package test.clone;

/**
 * 地址类
 * 
 * @author 小明
 *
 */
public class Address implements Cloneable {
    private String province; // 省
    private String city; // 市
    private String detail; // 详细地址

    public Address() {
        super();
    }

    public Address(String province, String city, String detail) {
        super();
        this.province = province;
        this.city = city;
        this.detail = detail;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

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

    public String getDetail() {
        return detail;
    }

    public void setDetail(String detail) {
        this.detail = detail;
    }

    @Override
    public String toString() {
        return "Address [province=" + province + ", city=" + city + ", detail="
                + detail + "]";
    }

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

学生类：

package test.clone;

/**
 * 学生类
 * 
 * @author 小明
 *
 */
public class Student implements Cloneable {
    private String name; // 姓名
    private int age; // 年龄
    private Address address; // 地址

    public Student() {
        super();
    }

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

    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;
    }

    public Address getAddress() {
        return address;
    }

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

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", address="
                + address + "]";
    }

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

测试类：

package test.clone;

/**
 * 浅克隆测试
 * 
 * @author 小明
 *
 */
public class ShallowCloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("广东", "广州", "天河"); // 地址
        Student stu1 = new Student("小明", 28, address); // 第一个学生对象
        Student stu2 = (Student) stu1.clone(); // 第二个学生对象，为克隆第一个学生对象
        // 修改第二个学生对象的信息
        stu2.setName("王飞鸿");
        stu2.setAge(35);
        stu2.getAddress().setProvince("四川");
        stu2.getAddress().setCity("成都");
        stu2.getAddress().setDetail("青羊区");
        // 打印第一个学生对象的信息
        System.out.println(stu1);
    }
}

运行结果：

Student [name=小明, age=28, address=Address [province=四川, city=成都, detail=青羊区]]

从运行结果看到，我们仅只修改了第二个学生对象的地址，但第一个学生对象的地址也改变了，这说明两个学生对象是共享的学生地址对象。

那如何实现深克隆呢？

4. 深克隆

地址类：

package test.clone;

/**
 * 地址类
 * 
 * @author 小明
 *
 */
public class Address implements Cloneable {
    private String province; // 省
    private String city; // 市
    private String detail; // 详细地址

    public Address() {
        super();
    }

    public Address(String province, String city, String detail) {
        super();
        this.province = province;
        this.city = city;
        this.detail = detail;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

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

    public String getDetail() {
        return detail;
    }

    public void setDetail(String detail) {
        this.detail = detail;
    }

    @Override
    public String toString() {
        return "Address [province=" + province + ", city=" + city + ", detail="
                + detail + "]";
    }

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

学生类：

package test.clone;

/**
 * 学生类
 * 
 * @author 小明
 *
 */
public class Student implements Cloneable {
    private String name; // 姓名
    private int age; // 年龄
    private Address address; // 地址

    public Student() {
        super();
    }

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

    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;
    }

    public Address getAddress() {
        return address;
    }

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

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", address="
                + address + "]";
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        Student stu = (Student) super.clone();
        stu.address = (Address) address.clone();
        return stu;
    }
}

测试类：

package test.clone;

/**
 * 深克隆测试
 * 
 * @author 小明
 *
 */
public class DeepCloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("广东", "广州", "天河"); // 地址
        Student stu1 = new Student("小明", 28, address); // 第一个学生对象
        Student stu2 = (Student) stu1.clone(); // 第二个学生对象，为克隆第一个学生对象
        // 修改第二个学生对象的信息
        stu2.setName("王飞鸿");
        stu2.setAge(35);
        stu2.getAddress().setProvince("四川");
        stu2.getAddress().setCity("成都");
        stu2.getAddress().setDetail("青羊区");
        // 打印第一个学生对象的信息
        System.out.println(stu1);
        // 打印第二个学生对象的信息
        System.out.println(stu2);
    }
}

运行结果：

Student [name=小明, age=28, address=Address [province=广东, city=广州, detail=天河]]
Student [name=王飞鸿, age=35, address=Address [province=四川, city=成都, detail=青羊区]]

从运行结果中看出，修改第二个学生对象时，第一个学生对象的地址并不受影响，说明克隆学生对象时，不仅克隆了学生对象，也克隆了其子对象。

5. 利用串行化实现深克隆

地址类：

package test.clone2;

import java.io.Serializable;

/**
 * 地址类
 * 
 * @author 小明
 *
 */
public class Address implements Serializable {
    private String province; // 省
    private String city; // 市
    private String detail; // 详细地址

    public Address() {
        super();
    }

    public Address(String province, String city, String detail) {
        super();
        this.province = province;
        this.city = city;
        this.detail = detail;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

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

    public String getDetail() {
        return detail;
    }

    public void setDetail(String detail) {
        this.detail = detail;
    }

    @Override
    public String toString() {
        return "Address [province=" + province + ", city=" + city + ", detail="
                + detail + "]";
    }
}

学生类：

package test.clone2;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 学生类
 * 
 * @author 小明
 *
 */
public class Student implements Serializable {
    private String name; // 姓名
    private int age; // 年龄
    private Address address; // 地址

    public Student() {
        super();
    }

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

    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;
    }

    public Address getAddress() {
        return address;
    }

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

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", address="
                + address + "]";
    }

    /**
     * 利用串行化深克隆
     * 
     * @return 深克隆后的对象
     */
    public Object deepClone() {
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(byteArrayOutputStream);
            oos.writeObject(this);
            ois = new ObjectInputStream(new ByteArrayInputStream(
                    byteArrayOutputStream.toByteArray()));
            return ois.readObject();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (oos != null)
                    oos.close();
                if (ois != null)
                    ois.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

测试类：

package test.clone2;

/**
 * 深克隆测试
 * 
 * @author 小明
 *
 */
public class DeepCloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("广东", "广州", "天河"); // 地址
        Student stu1 = new Student("小明", 28, address); // 第一个学生对象
        Student stu2 = (Student) stu1.deepClone(); // 第二个学生对象，为克隆第一个学生对象
        // 修改第二个学生对象的信息
        stu2.setName("王飞鸿");
        stu2.setAge(35);
        stu2.getAddress().setProvince("四川");
        stu2.getAddress().setCity("成都");
        stu2.getAddress().setDetail("青羊区");
        // 打印第一个学生对象的信息
        System.out.println(stu1);
        // 打印第二个学生对象的信息
        System.out.println(stu2);
    }
}

运行结果：

Student [name=小明, age=28, address=Address [province=广东, city=广州, detail=天河]]
Student [name=王飞鸿, age=35, address=Address [province=四川, city=成都, detail=青羊区]]

说明：利用串行化实现深克隆，克隆对象与子对象对应的类都必须实现java.io.Serializable接口。

江湖人称小明
关注
专栏目录
深入java对象复制的分析
09-05
Java对象复制是一个重要的概念，它涉及到对象的深拷贝和浅拷贝，以及如何通过不同的方式来实现对象的复制。本文将深入分析Java中的对象复制，主要包括两种常见方法：使用`clone()`方法和通过反射机制。 1. **Object...
Java的对象克隆
lanleihhh的博客
06-13 2370
在浅克隆中：源对象和克隆对象的成员变量指向相同的内存地址 直接重写Object的clone()，会抛出异常 正确用法：1.先实现实现Cloneable接口,再重写clone()方法 测试 作为属性的类(没有重写clone方法) 被克隆的类(重写了clone方法) 测试 两个对象关联的同一个Address对象，Address修改了，克隆对象的信息也发生了变化在深克隆中，无论源对象的成员是基本类型/引用类型，都会复制给克隆对象 也就是在深克隆中，对象和所有成员都会被克隆 而在浅克隆中，只会克隆对象和基本类型成
java对象克隆详解
weixin_71243923的博客
02-09 4877
java对象克隆详解,浅克隆,深克隆,序列化方式的克隆
JAVA -- 对象的克隆操作
最新发布
xycxycooo的博客
07-31 942
浅克隆：通过实现Cloneable接口和重写clone方法实现，适用于基本数据类型的成员变量。深克隆：通过手动复制引用类型的成员变量或使用序列化实现，确保克隆对象和原对象完全独立。通过这些方法，开发者可以根据需求选择合适的克隆方式，实现对象的克隆操作。
Java基础：对象的克隆（复制）
wangshiqi666的博客
04-18 2654
java克隆
Java实现对象的克隆方式
热门推荐
java123456111的博客
05-19 1万+
Java实现对象克隆的方法 1、Java实现克隆有两种形式 浅拷贝 深拷贝 在Java中吗，我们说两个对象是否相等通常有两层含义： 对象的内容是否相等，通常使用到对象的 equals(Object o) 函数； 引用的地址是否相同，使用运算符 ＝＝ 比较即可。 当两个对象通过赋值符号 = 赋值时，表明这两个对象指向了内存中同一个地址，所以改变其中一个对象的内容，也就间接地改变了另一个对象的内容。有时候，我们需要从一个已经存在的对象重新拷贝一份出来，并且不仅这两个对象内容相等，在内存中存在两个独立的存
Java对象的克隆
Emy_Jxy的博客
03-10 2165
Java克隆
java对象复制
07-31
Java对象的复制主要有两种方式：浅复制（Shallow Copy）和深复制（Deep Copy）。标题中的"java对象复制"主要涉及到Java中对象复制的基本概念、实现方法以及相关的注意事项。 首先，Java中的对象复制问题源于其默认...
java对象复制克隆
10-28
标题中的“java对象复制克隆”主要涉及的是深拷贝，这是一种创建一个新对象的方式，新对象不仅复制了原对象的所有属性，还复制了嵌套的对象引用，使得修改复制后的对象不会影响到原始对象。 **浅拷贝**：在浅拷贝中...
Java对象的复制三种方式(小结)
08-25
"Java对象的复制三种方式" Java对象的复制是Java编程中的一种常见操作，主要是将一个对象的值复制到另一个对象中，使得两个对象独立，但具有相同的初始值。在实际编程过程中，我们常常需要复制对象，以便于对象之间...
深入JAVA对象深度克隆的详解
09-05
总之，Java对象的深度克隆是解决复杂对象复制问题的有效手段，通过序列化和反序列化确保了新旧对象的完全独立。然而，它也有其局限性和潜在性能影响，所以在实际应用中应根据具体情况选择合适的克隆策略。
java克隆对象(两种方法)
09-17
java的两种深度克隆方法,1cloneTest是用Cloneable接口的clone方法实现(对象必须要实现cloneable接口).2cloneSerialize.java是用对象流写对象到byte数组中,然后从byte数组中取得对象.(对象必须要实现serializble接口)
编写Student类，类中包含学生姓名，学号等私有数据成员。使用JAVA反射机制修改一个学生对象的私有数据成员
07-04
编写Student类，类中包含学生姓名，学号等私有数据成员。 使用JAVA反射机制修改一个学生对象的私有数据成员（不允许调用setters)
Java中如何克隆一个对象？
网络技术联盟站
04-21 1986
要实现对象的深拷贝，可以自定义一个深拷贝方法，在该方法中递归复制对象中的所有引用类型成员变量所指向的对象。// 构造方法和getter/setter方法省略// 使用MyObject的拷贝构造方法在上面的示例中，我们定义了一个deepCopy()方法，通过手动复制每个引用类型成员变量所指向的对象来实现深拷贝。在Java中，对象克隆是一个重要的概念，它允许我们创建一个与原始对象具有相同状态的全新对象。本文介绍了两种常见的对象克隆方法：浅拷贝和深拷贝。
Java中对象的克隆
2303_79615760的博客
07-17 1593
浅克隆只复制对象本身，不复制对象中的引用类型成员变量所指向的对象（记录的是引用类型变量的地址）。新旧对象之间可能存在共享的引用关系。修改新对象中引用类型成员变量的状态可能会影响原始对象。
java--对象克隆
qq_38618691的博客
05-31 629
java对象克隆
Java - 对象克隆
xx12321q的博客
05-23 967
目录 对象克隆 浅克隆 深克隆 多层克隆 对象克隆 在讨论对象克隆之前, 可能会有人说 , 不能直接new一个吗?为什么要克隆 首先关于这个问题, 直接new一个对象, 这个对象里面包含的成员变量是null的 , 那问题又来了, 我不能去一个个set对象的值吗? 当然可以, 但这样麻烦, 对象克隆采用的是native方法,效率更高 那么该怎样去克隆呢? 克隆又分为浅克隆和深克隆 首先这样的方式不叫克隆 (这种只能叫做引用复制): Object obj1 = new Object()
浅克隆和深克隆
ChineseSoftware的博客
02-15 4458
一、浅克隆(ShallowClone) 在浅克隆中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。 简单来说，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。 二、深克隆(DeepClone) 在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值