Java对象克隆

最新推荐文章于 2024-09-11 20:33:36 发布
最新推荐文章于 2024-09-11 20:33:36 发布
阅读量1.6k 收藏 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的对象克隆
lanleihhh的博客
06-13 2393
在浅克隆中：源对象和克隆对象的成员变量指向相同的内存地址 直接重写Object的clone()，会抛出异常 正确用法：1.先实现实现Cloneable接口,再重写clone()方法 测试 作为属性的类(没有重写clone方法) 被克隆的类(重写了clone方法) 测试 两个对象关联的同一个Address对象，Address修改了，克隆对象的信息也发生了变化在深克隆中，无论源对象的成员是基本类型/引用类型，都会复制给克隆对象 也就是在深克隆中，对象和所有成员都会被克隆 而在浅克隆中，只会克隆对象和基本类型成
java对象复制克隆
10-28
标题中的“java对象复制克隆”主要涉及的是深拷贝，这是一种创建一个新对象的方式，新对象不仅复制了原对象的所有属性，还复制了嵌套的对象引用，使得修改复制后的对象不会影响到原始对象。 **浅拷贝**：在浅拷贝中...
java 对象克隆
weixin_50518344的博客
08-04 892
return id;}}try {}}}扩展抽象类的实体类}@Override}}创建一个类获取实体类，并把它们存储在一个 Hashtable 中Shape>();}// 对每种形状都运行操作创建该形状shapeMap.put(shapeKey, shape);}}使用ShapeCache类来获取存储在Hashtable中的形状的克隆}}...
java克隆-知之深浅Clone
最新发布
tttwwwcccyyds的博客
09-11 321
浅克隆克隆外层，深克隆克隆全部。
JAVA对象克隆
qq_36094023的博客
05-25 334
1.Java对象创建 在java语言中，有几种方式可以创建对象呢？ 使用new操作符创建一个对象 使用clone方法复制一个对象 那么这两种方式有什么相同和不同呢？ new操作符的本意是分配内存。程序执行到new操作符时，首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对...
Java 对象克隆
qq_42544728的博客
07-22 322
本文讨论Cloneable接口，这个接口指示一个类提供了安全的clone方法。由于克隆不太常见，而且相关技术细节很强，本文仅作基础概述介绍。
深入java对象复制的分析
09-05
Java对象复制是一个重要的概念，它涉及到对象的深拷贝和浅拷贝，以及如何通过不同的方式来实现对象的复制。本文将深入分析Java中的对象复制，主要包括两种常见方法：使用`clone()`方法和通过反射机制。 1. **Object...
Java对象的复制三种方式(小结)
08-25
"Java对象的复制三种方式" Java对象的复制是Java编程中的一种常见操作，主要是将一个对象的值复制到另一个对象中，使得两个对象独立，但具有相同的初始值。在实际编程过程中，我们常常需要复制对象，以便于对象之间...
java对象的克隆
HKF的博客
06-07 130
class Test extends Object { public static void main(String[] args) throws CloneNotSupportedException { Person perSon = new Person(); perSon.setAge(1); perSon.setName("张三"); Person personClone = (Person) perSon.clone(.
java对象克隆
weixin_40187126的博客
11-06 121
java对象clonejava对象克隆 java对象克隆 (要克隆的对象必须要实现 CloneEable 接口 这个接口是一个标志接口(空接口 没有任何的方法实现和属性) 留给jvm处理 ) @Data @AllArgsConstructor @NoArgsConstructor class Person implements Cloneable{ String name; Integer age; Cat cat; public Person c
Java对象的克隆
Emy_Jxy的博客
03-10 2219
Java克隆
Java - 对象克隆
xx12321q的博客
05-23 984
目录 对象克隆 浅克隆 深克隆 多层克隆 对象克隆 在讨论对象克隆之前, 可能会有人说 , 不能直接new一个吗?为什么要克隆 首先关于这个问题, 直接new一个对象, 这个对象里面包含的成员变量是null的 , 那问题又来了, 我不能去一个个set对象的值吗? 当然可以, 但这样麻烦, 对象克隆采用的是native方法,效率更高 那么该怎样去克隆呢? 克隆又分为浅克隆和深克隆 首先这样的方式不叫克隆 (这种只能叫做引用复制): Object obj1 = new Object()
java对象克隆clone
Xu
06-06 3285
克隆与拷贝对象的区别: 当拷贝一个变量时，原始变量与拷贝变量引用同一个对象.这就是说，改变一个变量所有引用的随想将会对另一个对象产生影响. 如果创建一个对象的新的copy，它的初始窗台与original一样，但以后将可以各自改变各自的状态，那就需要使用clone方法了. 不过事情并没有这么间的那，clone方法是object类的一个proteced方法，也就是说在用户编写的代码中
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值