Java创建对象的5种方式以及浅克隆与深克隆的区别

已于 2022-07-27 10:37:54 修改
阅读量297 收藏
点赞数
文章标签： java 开发语言 jvm
于 2022-07-11 10:55:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45745964/article/details/125716883
版权

Java创建对象的5种方式

哔哩哔哩链接：https://www.bilibili.com/video/BV1Bu411U7Ya?spm_id_from=333.999.0.0&vd_source=7c5f1f4c039688f19024d50ef51aaed1

1.Student类

static class Student implements Serializable, Cloneable {
        private String id;

        private String name;

        private Integer age;

        public Student() {
        }

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

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

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

        public Integer getAge() {
            return age;
        }

        public void setAge(Integer age) {
            this.age = age;
        }

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

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

2.java创建对象的5种方式

// java创建对象的5种方式
@Test
public void createObject() {
    System.out.println(createStudent01());
    System.out.println(createStudent02());
    System.out.println(createStudent03());
    System.out.println(createStudent04());
    System.out.println(createStudent05());
}


// 1.通过new xxx()调用构造方法创建对象
private Student createStudent01() {
    return new Student(UUID.randomUUID().toString(), "zhangsan", 20);
}

// 2.通过反射，调用xxx.getClass().newInstance()创建对象
private Student createStudent02() {
    try {
        // 得到一个空的对象
        Student student = Student.class.newInstance();
        student.setId(UUID.randomUUID().toString());
        student.setName("lisi");
        student.setAge(22);
        return student;
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return null;
}

// 3.通过反射，调用construct.newInstance()创建对象
private Student createStudent03() {
    // 获取Student类对应的class字节码对象
    Class<Student> studentClass = Student.class;
    Constructor<Student> constructor = null;
    try {
        // 获取Student类中有参构造方法
        constructor = studentClass.getConstructor(String.class, String.class, Integer.class);
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }

    Student wanwu = null;
    try {
        // 创建对象
        wanwu = constructor.newInstance(UUID.randomUUID().toString(), "wanwu", 25);
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
    return wanwu;
}

// 4.通过xxx.clone()克隆方式创建(需要实现Cloneable接口，重写clone方法)
public Student createStudent04(){
    Student student = new Student(UUID.randomUUID().toString(), "zhaoliu", 26);
    try {
        Student clone = (Student)student.clone();
        return clone;
    } catch (CloneNotSupportedException e) {
        e.printStackTrace();
    }
    return null;
}

// 5.通过序列化，反序列化创建对象（需要实现Serializable接口）
public Student createStudent05(){
    Student student = new Student(UUID.randomUUID().toString(), "tianqi", 27);
    try {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("E:\\student.txt"));
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("E:\\student.txt"));
        // 调用输出流将student对象序列化到E:\student.txt
        objectOutputStream.writeObject(student);
        // 从E:\student.txt文件中反序列化出student对象
        Student object = (Student)objectInputStream.readObject();
        return object;
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    return null;
}

在这里插入图片描述

3.浅克隆与深克隆

哔哩哔哩链接：https://www.bilibili.com/video/BV1Sa41127pU?spm_id_from=333.999.0.0&vd_source=7c5f1f4c039688f19024d50ef51aaed1
在这里插入图片描述
在这里插入图片描述

3.1.浅克隆

Teacher
package com.bilibili.juc.clone;

public class Teacher {

    private Integer pkid;

    private String name;

    public Teacher() {
    }

    public Teacher(Integer pkid, String name) {
        this.pkid = pkid;
        this.name = name;
    }

    public Integer getPkid() {
        return pkid;
    }

    public void setPkid(Integer pkid) {
        this.pkid = pkid;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Teacher{" +
                "pkid=" + pkid +
                ", name='" + name + '\'' +
                '}';
    }
}
Student
package com.bilibili.juc.clone;


public class Student implements Cloneable{

    private double weight;

    private Integer pkid;

    private String name;

    // 持有一个教师对象的引用
    private Teacher teacher;

    public Student(double weight, Integer pkid, String name, Teacher teacher) {
        this.weight = weight;
        this.pkid = pkid;
        this.name = name;
        this.teacher = teacher;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public Integer getPkid() {
        return pkid;
    }

    public void setPkid(Integer pkid) {
        this.pkid = pkid;
    }

    public String getName() {
        return name;
    }

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

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public String toString() {
        return "Student{" +
                "weight=" + weight +
                ", pkid=" + pkid +
                ", name='" + name + '\'' +
                ", teacher=" + teacher +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
浅克隆测试
// 浅拷贝演示
@org.junit.jupiter.api.Test
public void qianTest() throws CloneNotSupportedException {
    Teacher teacher = new Teacher(1, "黄老师");
    // 浅拷贝之前的对象
    Student student = new Student(50.00, 1, "张三", teacher);
    // 浅拷贝之后的对象
    Student student1 = (Student) student.clone();

    System.out.println(student == student1);
    System.out.println(student.getTeacher() == student1.getTeacher());
    System.out.println("浅拷贝前teacher的hashcode：" + student.getTeacher().hashCode());
    System.out.println("浅拷贝后teacher新对象的hashcode：" + student1.getTeacher().hashCode());

    System.out.println("克隆之前student学生的老师：" + student.getTeacher().getName());
    // 将克隆后的对象student1的老师姓名改为张老师，导致旧student的老师姓名也被修改
    student1.getTeacher().setName("张老师");
    System.out.println("克隆之前的student学生：" + student);
    System.out.println("克隆之后的student1学生：" + student1);
}

在这里插入图片描述

3.2.深克隆

Teacher2
package com.bilibili.juc.clone;

public class Teacher2 implements Cloneable{

    private Integer pkid;

    private String name;

    public Teacher2() {
    }

    public Teacher2(Integer pkid, String name) {
        this.pkid = pkid;
        this.name = name;
    }

    public Integer getPkid() {
        return pkid;
    }

    public void setPkid(Integer pkid) {
        this.pkid = pkid;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Teacher{" +
                "pkid=" + pkid +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
Student2
package com.bilibili.juc.clone;

public class Student2 implements Cloneable{

    private double weight;

    private Integer pkid;

    private String name;

    // 持有一个教师对象的引用
    private Teacher2 teacher;

    public Student2(double weight, Integer pkid, String name, Teacher2 teacher) {
        this.weight = weight;
        this.pkid = pkid;
        this.name = name;
        this.teacher = teacher;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public Integer getPkid() {
        return pkid;
    }

    public void setPkid(Integer pkid) {
        this.pkid = pkid;
    }

    public String getName() {
        return name;
    }

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

    public Teacher2 getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher2 teacher) {
        this.teacher = teacher;
    }

    @Override
    public String toString() {
        return "Student{" +
                "weight=" + weight +
                ", pkid=" + pkid +
                ", name='" + name + '\'' +
                ", teacher=" + teacher +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student2 student = null;
        student = (Student2) super.clone();
        // 拷贝teacher对象
        student.teacher = (Teacher2)this.teacher.clone();
        return student;
    }
}
深克隆测试
// 深拷贝演示
@org.junit.jupiter.api.Test
public void shenTest() throws CloneNotSupportedException {
    Teacher2 teacher = new Teacher2(1, "黄老师");
    // 深拷贝之前的对象
    Student2 student = new Student2(50.00, 1, "张三", teacher);
    // 深拷贝之后的对象
    Student2 student1 = (Student2) student.clone();

    System.out.println(student == student1);
    System.out.println(student.getTeacher() == student1.getTeacher());
    System.out.println("深拷贝前teacher的hashcode：" + student.getTeacher().hashCode());
    System.out.println("深拷贝后teacher新对象的hashcode：" + student1.getTeacher().hashCode());

    System.out.println("克隆之前student学生的老师：" + student.getTeacher().getName());
    // 将克隆后的对象student1的老师姓名改为张老师，因为是深拷贝，旧student的老师姓名不会被修改
    student1.getTeacher().setName("张老师");
    System.out.println("克隆之前的student学生：" + student);
    System.out.println("克隆之后的student1学生：" + student1);
}

在这里插入图片描述

3.3.通过序列化实现深克隆

Teacher3
package com.bilibili.juc.clone;

import java.io.Serializable;

public class Teacher3 implements Serializable {

    private Integer pkid;

    private String name;

    public Teacher3() {
    }

    public Teacher3(Integer pkid, String name) {
        this.pkid = pkid;
        this.name = name;
    }

    public Integer getPkid() {
        return pkid;
    }

    public void setPkid(Integer pkid) {
        this.pkid = pkid;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Teacher{" +
                "pkid=" + pkid +
                ", name='" + name + '\'' +
                '}';
    }
}
Student3
package com.bilibili.juc.clone;

import java.io.*;

public class Student3 implements Serializable {

    private double weight;

    private Integer pkid;

    private String name;

    // 持有一个教师对象的引用
    private Teacher3 teacher;

    public Student3(double weight, Integer pkid, String name, Teacher3 teacher) {
        this.weight = weight;
        this.pkid = pkid;
        this.name = name;
        this.teacher = teacher;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public Integer getPkid() {
        return pkid;
    }

    public void setPkid(Integer pkid) {
        this.pkid = pkid;
    }

    public String getName() {
        return name;
    }

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

    public Teacher3 getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher3 teacher) {
        this.teacher = teacher;
    }

    @Override
    public String toString() {
        return "Student{" +
                "weight=" + weight +
                ", pkid=" + pkid +
                ", name='" + name + '\'' +
                ", teacher=" + teacher +
                '}';
    }


    // 通过序列化实现深拷贝
    public Student3 deepCloneBySerializable() {
        Student3 student = null;
        ByteArrayOutputStream byteArrayOutputStream = null;
        ObjectOutputStream objectOutputStream = null;
        ByteArrayInputStream byteArrayInputStream = null;
        ObjectInputStream objectInputStream = null;
        try {
            byteArrayOutputStream = new ByteArrayOutputStream();
            objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);//对象序列化
            objectOutputStream.writeObject(this);
            byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            objectInputStream = new ObjectInputStream(byteArrayInputStream);
            //对象的反序列化
            student = (Student3) objectInputStream.readObject();
            return student;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (null != objectInputStream) {
                try {
                    objectInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != byteArrayInputStream) {
                try {
                    byteArrayInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != objectOutputStream) {
                try {
                    objectOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != byteArrayOutputStream) {
                try {
                    byteArrayOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
}
通过序列化实现深克隆测试
@org.junit.jupiter.api.Test
public void searilizableTest() throws CloneNotSupportedException {
    Teacher3 teacher = new Teacher3(1, "黄老师");
    // 深拷贝之前的对象
    Student3 student = new Student3(50.00, 1, "张三", teacher);
    // 深拷贝之后的对象
    Student3 student1 = (Student3) student.deepCloneBySerializable();

    System.out.println(student == student1);
    System.out.println(student.getTeacher() == student1.getTeacher());
    System.out.println("深拷贝前teacher的hashcode：" + student.getTeacher().hashCode());
    System.out.println("深拷贝后teacher新对象的hashcode：" + student1.getTeacher().hashCode());

    System.out.println("克隆之前student学生的老师：" + student.getTeacher().getName());
    // 将克隆后的对象student1的老师姓名改为张老师，因为是深拷贝，旧student的老师姓名不会被修改
    student1.getTeacher().setName("张老师");
    System.out.println("克隆之前的student学生：" + student);
    System.out.println("克隆之后的student1学生：" + student1);
}

在这里插入图片描述

3.4 不实现深克隆

Attachment：

package com.bilibili.juc.sheng;

import java.io.Serializable;

public class Attachment  implements Serializable {

    private String name;

    public String getName() {
        return name;
    }

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

YuelyLog ：

package com.bilibili.juc.sheng;

import java.io.Serializable;

public class YuelyLog implements Serializable,Cloneable {
    private Attachment attachment;
    private String name;
    private String date;

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

    public Attachment getAttachment() {
        return attachment;
    }

    public void setAttachment(Attachment attachment) {
        this.attachment = attachment;
    }

    public String getName() {
        return name;
    }

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

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }
}

ShengTest ：

package com.bilibili.juc.sheng;

import java.io.IOException;
import java.util.Date;

public class ShengTest {

    public static void main(String[] args) throws IOException, ClassNotFoundException, CloneNotSupportedException {
        Attachment attachment = new Attachment();
        attachment.setName("wj");
        YuelyLog yuelyLog = new YuelyLog();
        yuelyLog.setAttachment(attachment);
        yuelyLog.setDate(new Date().toString());
        yuelyLog.setName("dn");
        System.out.println("yelyLog:name="+(yuelyLog.getAttachment().getName()));

        YuelyLog clone = yuelyLog.clone();
        clone.getAttachment().setName("clone");
        System.out.println("yelyLog:name="+(yuelyLog.getAttachment().getName()));
    }
}

输出结果：
yelyLog:name=wj
yelyLog:name=clone

说明在修改浅拷贝队形的同时原对象也发生了变化，这是一种非常危险的事情，如果处理不当，对全局性的变量或者原对象进项操作会引起大bug

其实我们拷贝一个对象就是希望他是独立的，可操作的，不会因为修改他而引起原对象发生变化。

通过序列化实现深拷贝

public class YuelyLog implements Serializable,Cloneable {
    private Attachment attachment;
    private String name;
    private String date;

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

    public Attachment getAttachment() {
        return attachment;
    }

    public void setAttachment(Attachment attachment) {
        this.attachment = attachment;
    }

    public String getName() {
        return name;
    }

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

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }

    /**
     * 使用序列化技术实现深拷贝
     * @return
     */
    public YuelyLog deepClone() throws IOException,ClassNotFoundException{
        //将对象写入流中
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(this);
        //从流中取出
        ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        return (YuelyLog)objectInputStream.readObject();

    }
}

之后将YuelyLog clone = yuelyLog.clone();改为YuelyLog clone = yuelyLog.deepClone();
代码如下：

package com.bilibili.juc.sheng;

import java.io.IOException;
import java.util.Date;

public class ShengTest {

    public static void main(String[] args) throws IOException, ClassNotFoundException, CloneNotSupportedException {
        Attachment attachment = new Attachment();
        attachment.setName("wj");
        YuelyLog yuelyLog = new YuelyLog();
        yuelyLog.setAttachment(attachment);
        yuelyLog.setDate(new Date().toString());
        yuelyLog.setName("dn");
        System.out.println("yelyLog:name="+(yuelyLog.getAttachment().getName()));

        YuelyLog clone = yuelyLog.deepClone();
        clone.getAttachment().setName("clone");
        System.out.println("yelyLog:name="+(yuelyLog.getAttachment().getName()));
    }
}

输出结果：
yelyLog:name=wj
yelyLog:name=wj

在这里强调一点，当然如果你能保证在拷贝对象后，你只是对拷贝对象成员变量为基本类型和String类型进行操作，可以使用浅拷贝，像对复杂对象操作，我们一般使用深拷贝，或者对非基本类型单独实现拷贝进行修改。业务中灵活掌握。

4.方法重载和重写的区别

哔哩哔哩链接：https://www.bilibili.com/video/BV1sS4y1j7tX?spm_id_from=333.999.0.0&vd_source=7c5f1f4c039688f19024d50ef51aaed1

在这里插入图片描述
在这里插入图片描述

5.String s = new String(“abc”)创建了几个对象

在这里插入图片描述

在这里插入图片描述

public class NewString {
    public static void main(String[] args) {
        // 在方法执行过程中,根据字节码指令,往栈里写入数据或提取数据,即入栈/出栈。某些字节码指令把值压入操作数栈,其余指令将操作数取出栈。
        // 1.在字符串常量池中创建了一个“abc”的字符串常量
        // 2.把字符串常量“abc”的值压入到操作数栈中
        // 3.把栈中的元素存入到局部变量表索引为1的位置
        // 4.方法返回
        String abc = "abc";
    }
}

在这里插入图片描述

public class NewString {
    public static void main(String[] args) {
        // 1.创建一个新的实例
        // 2.复制栈中的元素并把复制的值压入到操作数栈中
        // 3.在字符串常量池中创建了一个“abc”的字符串常量
        // 4.把字符串常量“abc”的值压入到操作数栈中
        // 5.调用String构造方法，
        // 6.把栈中的元素存入到局部变量表索引为1的位置
        // 7.方法返回
        String abc = new String("abc");
    }
}

在这里插入图片描述

public class NewString {
    public static void main(String[] args) {

        // 1.在字符串常量池中创建了一个“abc”的字符串常量
        // 2.把栈中的元素存入到局部变量表索引为1的位置
        // 3.创建一个新的实例
        // 4.复制栈中的元素并把复制的值压入到操作数栈中
        // 5.由于之前已经创建了“abc”字符串常量池，即“abc”已经在字符串常量池中存在，直接获取#2（abc在字符串常量池中）的地址
        // 6.调用String构造方法
        // 7.把栈中的元素存入到局部变量表索引为2的位置
        // 8.方法返回
        String ABC = "abc";
        String abc = new String("abc");
    }
}

在这里插入图片描述

喜欢请关注我

至此，我们的Java创建对象的5种方式以及浅克隆与深克隆的区别就讲解完成了。喜欢我的话可以关注我的微信公众号我爱学习呀嘻嘻 ，不定期分享各类资源哦。

image-20211108230322493

我爱学习呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 对象的克隆（浅克隆和深克隆）
08-29
总结起来，Java对象的克隆机制是创建对象副本的一种手段，分为浅克隆和深克隆。浅克隆只复制对象的基本类型字段，而引用字段指向的是原始对象的引用。深克隆则会递归地复制所有字段，包括引用类型的字段，确保副本与...
用浅拷贝在循环中创建对象
一个天天与人打赌周更blog被迫极限一换一的程序员骚年
01-04 186
两者就在于，浅拷贝只是简单的复制，对对象里面的对象属性和数组属性只是复制了地址，并没有创建新的相同对象或者数组,新旧对象还是共享同一块内存。而深拷贝是完完全全的复制一份，空间大小占用一样但是位置不同,新对象跟原对象不共享内存，修改新对象不会改到原对象。浅拷贝：有两种方式，一种是把一个对象里面的所有的属性值和方法都复制给另一个对象，另一种是直接把一个对象赋给另一个对象，使得两个都指向同一个对象。深拷贝：把一个对象的属性和方法一个个找出来，在另一个对象中开辟对应的空间，一个个存储到另一个对象中。
浅拷贝和深拷贝(谈谈java中的clone)
热门推荐
吴渣渣的博客
02-12 3万+
clone顾名思义就是复制， 在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。那么在java语言中，有几种方式可以创建对象呢？ 1. 使用new操作符创建一个对象 2. 使用clone方法复制一个对象 那么这两种方式有什么相同和不同呢？ new操作符的本意是分配内存。程序执行
Java对象的创建方式及其区别
u012325073的博客
10-09 769
做一件事，首先要明白是做什么，我们为什么要创建对象？创建对象都是在heap里面的分配内存。 一、直接new（ClassObj  obj = new ClassObj();）       我们常用的创建方法就是new  object();  这个关键地方肯定是 new 关键字。 二、运用反射手段，调用Java.lang.Class或者java.lang.reflect.Constructor类
Java创建对象有哪几种方式？有什么区别？
GAN_3的博客
07-26 1059
最近在准备面试，整理一些Java基础知识，不整理不知道，一整理吓一跳。作为一名入职一年的程序员深深的理解到了基础不牢，地动山摇。 言归正传，开Gan 面试官： Java创建对象有哪几种方式？ 我： 答：面试官，你好，整体来说可以分为四种，细分可以分为5种，分别为： 手动new 通过构造函数创建 实现超类Object的Cloneable方法 通过反射获取类模板对象，再通过Class对象的newInstance()方法创建 通过反射获取类模板对象，再Constructor对象创建 反序列化的方式创建 面.
在Java中创建对象的不同方法是什么？
Tybyqi的博客
11-22 225
在这篇快速文章中，我们将讨论在Java中创建对象的五种不同方法。我们知道，类是创建对象的模板或蓝图。让我们列出在Java中创建对象的不同方法。 用Java创建对象的5种不同方法 1.使用新关键字 2.使用  newInstance() Class类的方法 3.使用  newInstance() Constructor类的方法 4.使用对象反序列化 5.使用对象克隆 -  clone()...
浅析Java中clone()方法浅克隆与深度克隆
08-30
总之，Java的克隆机制提供了一种创建对象副本的方式，浅克隆适用于简单的数据结构，而深度克隆适用于复杂的数据结构，以避免对象间的引用共享导致的意外修改。正确理解和使用克隆机制，可以帮助开发者更好地控制对象...
java 深克隆 浅克隆
11-28
在Java编程语言中，克隆是一种创建对象副本的方法，它允许我们复制一个对象并得到一个与原对象相同但独立的新对象。克隆分为两种主要类型：深克隆和浅克隆。理解这两种克隆的区别是Java面向对象编程中的重要概念。 ...
Java对象的深克隆与浅克隆详解.zip(wcb2003)
04-27
Java提供了两种主要的克隆方式：浅克隆（Shallow Clone）和深克隆（Deep Clone）。下面我们将深入探讨这两种克隆方法。 ### 浅克隆 浅克隆是指创建一个新的对象，其成员变量的值与原对象相同，但引用类型成员变量...
Java中对象的序列化方式克隆详解
08-31
当需要对一个对象进行克隆时，Java提供了两种基本的克隆方式：浅克隆和深克隆。浅克隆只是复制了对象本身，而深克隆则会连同对象引用的其他对象一起复制。 在提供的代码示例中，实现的是深克隆。深克隆通过序列化和...
Java深克隆的几种方式
夏壹分享
07-14 621
克隆对象需继承Serializable接口。
Java深克隆和浅克隆的原理及实现
最新发布
lvyuanj的专栏
04-20 1061
通过上面的例子可以看到，浅拷贝会带来数据安全方面的隐患，例如我们只是想修改了 student 的 teacher，但是 student1 的 teacher 也被修改了，因为它们都是指向的同一个地址。可以通过hascode打印的值看的出来，引用类型的是相同内存地址，所以修改copy后中teacher.age，直接影响原来student中teacher对象的age。(2) 对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。
Java对象克隆的简介说明
qq_25073223的博客
10-13 188
Java对象克隆的简介说明
java设置一个方法_Java中五种不同方法的创建对象
weixin_39634052的博客
02-17 298
前言作为Java开发者，我们每天都会创建大量的对象，但是，我们总是使用管理依赖系统(如Spring框架)来创建这些对象。其实还有其他方法可以创建对象，在接下来的文章中我会进行详细介绍。1.使用new关键字这是最常见的创建对象的方法，并且也非常简单。通过使用这种方法我们可以调用任何我们需要调用的构造函数。Employee emp1 = new Employee();0: new #19 ...
33. JAVA高级技术-对象克隆2（浅克隆）
CSDN全栈领域优秀博主，阿里云博客专家，工信部权威认证物联网技术开发工程师，曾30分钟高分通过C语言二级，两天手撸代码完成EasyX飞机大战，靠接软件私活一个月换苹果电脑
04-23 359
JAVA高级技术-对象克隆2（浅克隆）
java 克隆对象_Java之用克隆创建对象(一)
weixin_35810223的博客
12-26 475
1.new 类名()。2.c.newInstance();反射创建对象。3.ObjectInputStream反序列化，把一个对象以二进制的形式读出。 4.克隆技术一共有五种创建对象的方式，我现在学到用克隆创建对象。 创建一个User类用get/set来写name和age，写一个构造函数，写一个返回值，继承Cloneable接口，实现其方法。public class User2 implement...
Java中的深克隆和浅克隆的原理及三种方式实现深克隆
终生学习践行者
03-26 5099
本文详细介绍了Java中的浅克隆和深克隆的概念，及案例演示如何实现深克隆！
Java基础-浅克隆对象
m0_60509400的博客
07-26 164
Java基础-浅克隆对象
Java编程：浅克隆与深克隆实现及比较
1. **内存消耗**：深克隆会消耗更多内存，因为它创建了所有引用对象的新副本，而浅克隆只复制对象本身。 2. **安全性**：深克隆提供了更强的数据隔离，因为修改克隆对象不会影响原始对象。浅克隆则可能导致两者共享...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值