Object类，对象克隆，拷贝

已于 2023-04-05 19:31:29 修改
阅读量252 收藏
点赞数
文章标签： java jvm servlet
于 2023-04-05 19:27:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66254911/article/details/129975409
版权 
package com.itheima.a04objectdemo;

public class ObjectDemo1 {
    public static void main(String[] args) {
        /*
            public string tostring() 返回对象的字符串表示形式
            public boolean equals(Object obj) 比较两个对象是否相等
            protected object clone(int a) 对象克隆
        */
        //1.tostring 返回对象的字符串表示形式
        Object obj = new Object();
        String str1 = obj.toString();
        System.out.println(str1);//java.lang.Object@119d7047

        Student stu = new Student();
        String str2 = stu.toString();
        System.out.println(str2);//com.itheima.a04objectdemo.student@4eec7777

        //细节:
        System.out.println(stu);//com.itheima.a04objectdemo.student@4eec7777


        //细节:
        //System:类名
        //out:静态变量
        //system.out:获取打印的对象
        //println():方法
        //参数:表示打印的内容
        //核心逻辑:
        //当我们打印一个对象的时候，底层会调用对象的tostring方法，把对象变成字符串。
        //然后再打印在控制台上，打印完毕换行处理。

        //思考:默认情况下，因为Object类中的tostring方法返回的是地址值
        //所以，默认情况下，打印一个对象打印的就是地址值
        //但是地址值对于我们是没什么意义的?
        //我想要看到对象内部的属性值?我们该怎么办?
        //处理方案：重写父类Object类中的toString方法
        System.out.println(stu);//com.itheima.a04objectdemo.Student@4eec7777


        //tostring方法的结论:
        //如果我们打印一个对象，想要看到属性值的话，那么就重写tostring方法就可以了。
        //在重写的方法中，把对象的属性值进行拼接。
    }
}


package com.itheima.a04objectdemo;

public class ObjectDemo2 {
    public static void main(String[] args) {
        /*
            public boolean equals(Object obj) 比较两个对象是否相等
        */
        Student s1 = new Student("zhangsan",23);
        Student s2 =new Student("zhangsan",23);

        boolean result1 = s1.equals(s2);
        System.out.println(result1);//true

        //结论:
        //1.如果没有重写equals方法，那么默认使用Object中的方法进行比较，比较的是地址值是否相等
        //2.一般来讲地址值对于我们意义不大，所以我们会重写，重写之后比较的就是对象内部的属性值了。
    }
}


package com.itheima.a04objectdemo;

public class ObjectDemo3 {
    public static void main(String[] args) {
        String s = "abc";
        StringBuilder sb = new StringBuilder("abc");

        System.out.println(s.equals(sb));// false
        //因为equals方法是被s调用的，而s是字符串
        //所以equals要看string类中的
        //字符串中的equals方法，先判断参数是否为字符串
        // 如果是字符串，再比较内部的属性
        //但是如果参数不是字符串，直接返回false


        System.out.println(sb.equals(s));// false
        //因为equals方法是被sb调用的，而sb是StringBuilder
        //所以这里的equals方法要看StringBuilder中的equals方法
        //那么在StringBuilder当中，没有重写equals方法
        //使用的是Object中的
        //在Object当中默认是使用==号比较两个对象的地址值
        //而这里的s和sb记录的地址值是不一样的，所以结果返回false
    }
}


package com.itheima.a05objectsdemo;

import java.util.Objects;

public class ObjectsDemo1 {
    public static void main(String[] args) {
        /*
            public static boolean equals(Object a, Object b) 先做非空判断，比较两个对象
            public static boolean isNull(Object obj) 判断对象是否为null，为nul1返回true ，反之
            public static boolean nonNull(Object obj) 判断对象是否为null，跟isNull的结果相反
        */
        //1.创建学生类的对象
        Student s1 = null;
        Student s2 = new Student("zhangsan", 23);

        //2.比较两个对象的属性值是否相同
        if(s1 != null){
            boolean result = s1.equals(s2);
            System.out.println(result);
        }else{
            System.out.println("调用者为空");
        }


        boolean result = Objects.equals(s1, s2);
        System.out.println(result);
        //细节:
        //1.方法的底层会判断s1是否为null，如果为null，直接返回false
        //2.如果s1不为null，那么就利用s1再次调用equals方法
        //3.此时s1是student类型，所以最终还是会调用student中的equals方法。
        // 如果没有重写，比较地址值，如果重写了，就比较属性值。





        //public static boolean isNull(Obiect obi) 判断对象是否为null，为nul1返回true,反之
        Student s3 = new Student();
        Student s4 = null;

        System.out.println(Objects.isNull(s3));//false
        System.out.println(Objects.isNull(s4));//true

        System.out.println(Objects.nonNull(s3));//true
        System.out.println(Objects.nonNull(s4));//false



    }
}
5package com.itheima.a04objectdemo;

public class ObjectDemo4 {
    public static void main(String[] args) throws CloneNotSupportedException {
        // protected object clone(int a) 对象克隆 

        //1.先创建一个对象
        int[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0};
        User u1 = new User(1, "zhangsan", "1234qwer", "girl11", data);

        //2.克隆对象
        //细节:
        //方法在底层会帮我们创建一个对象,并把原对象中的数据拷贝过去。
        //书写细节:
        //1.重写Object中的clone方法
        //2.让javabean类实现Cloneable接口
        //3.创建原对象并调用clone就可以了
        //User u2 =(User)u1.clone();

        //验证一件事情：Object中的克隆是浅克隆
        //想要进行深克隆，就需要重写clone方法并修改里面的方法体
        //int[] arr = u1.getData();
        //arr[0] = 100;

        //System.out.println(u1);
        //System.out.println(u2);


        //以后一般会用第三方工具进行克隆
        //1.第三方写的代码导入到项目中
        //2.编写代码
        //Gson gson =new Gson();
        //把对象变成一个字符串
        //String s=gson.toJson(u1);
        //再把字符串变回对象就可以了
        //User user =gson.fromJson(s, User.class);

        //int[] arr=u1.getData();
        //arr[0] = 100;

        //打印对象
        //System.out.println(user);




    }
}

package com.itheima.a05objectsdemo;

import java.util.Objects;

public class Student {
    private String name;
    private int age;


    public Student() {
    }

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

    /**
     * 获取
     *
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     *
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     *
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     *
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public String toString() {
        return name + ", " + age;
    }
}


package com.itheima.a04objectdemo;

import java.util.Objects;

public class Student {
    private String name;
    private int age;


    public Student() {
    }

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

    /**
     * 获取
     *
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     *
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     *
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     *
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public String toString() {
        return name + ", " + age;
    }
}


package com.itheima.a04objectdemo;

import java.util.StringJoiner;



//Cloneable
//如果一个接口里面没有抽象方法
//表示当前的接口是一个标记性接口
//现在Cloneable表示一旦实现了，那么当前类的对象就可以被克降
//如果没有实现，当前类的对象就不能克隆
public class User implements Cloneable {
    private int id;
    private String username;
    private String password;
    private String path;
    private int[] data;




    public User() {
    }

    public User(int id, String username, String password, String path, int[] data) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.path = path;
        this.data = data;
    }

    /**
     * 获取
     *
     * @return id
     */
    public int getId() {
        return id;
    }

    /**
     * 设置
     *
     * @param id
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * 获取
     *
     * @return username
     */
    public String getUsername() {
        return username;
    }

    /**
     * 设置
     *
     * @param username
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * 获取
     *
     * @return password
     */
    public String getPassword() {
        return password;
    }

    /**
     * 设置
     *
     * @param password
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * 获取
     *
     * @return path
     */
    public String getPath() {
        return path;
    }

    /**
     * 设置
     *
     * @param path
     */
    public void setPath(String path) {
        this.path = path;
    }

    /**
     * 获取
     *
     * @return data
     */
    public int[] getData() {
        return data;
    }

    /**
     * 设置
     *
     * @param data
     */
    public void setData(int[] data) {
        this.data = data;
    }

    public String toString() {
        return "角色编号为：" + id + "，用户名为：" + username + "密码为：" + password + ", 游戏图片为:" + path + ", 进度:" + arrToString();
    }


    public String arrToString() {
        StringJoiner sj = new StringJoiner(", ", "[", "]");

        for (int i = 0; i < data.length; i++) {
            sj.add(data[i] + "");
        }
        return sj.toString();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //调用父类中的clone方法
        //相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去。

        //先把被克隆对象中的数组获取出来
        int[] data = this.data;
        //创建新的数组
        int[] newData =new int[data.length];
        //拷贝数组中的数据
        for (int i = 0; i < data.length; i++) {
            newData[i] = data[i];
        }
        //调用父类中的方法克隆对象
            User u=(User)super.clone();
        //因为父类中的克隆方法是浅克隆，替换克隆出来对象中的数组地址值
        u.data =newData;
        return u;
    }
}

神秘人623
关注
php实现对象克隆的方法
10-24
PHP实现对象克隆的知识点主要涉及对象的深拷贝与浅拷贝的概念、PHP对象克隆的语法以及__clone魔术方法的使用。以下为详细知识点： 1. 对象克隆基本概念： 对象克隆，是面向对象编程中的一项技术，用于创建一个与...
Fastjson JSONArray深度复制
一路向前
02-24 3003
Fastjson JSONArray深度复制 目录 Fastjson JSONArray深度复制 1，new JSONArray (Object); 2，AddAll; 3，串行化复制; 总结： 如何对fajstjson JSONArray类型的数据进行深度复制，有几种方式呢？ 1，new JSONArray (Object); 代码： public static void main(String[] args) throws IOException, ClassNotFound.
java复制对象之深拷背(深克隆)
一生编程，快乐编程
07-05 425
在java开发中，有时我们需要复制对象，并且确保修改复制得到的对象不会影响原来的对象。 于是，有些人可能会写出类似以下的代码： public class CloneTest { public static void main(String[] args) { JSONObject paramJson= new JSONObject(); paramJso...
快速理解java的浅拷贝和深拷贝
weixin_43718423的博客
02-08 1071
BeanUtils.copyProperties()方法为浅拷贝方法：当拷贝源对象当中有User对象属性，那么拷贝之后目标对象的User的指针与拷贝源User对象指针指向同一处。这里深拷贝代码采用了JSONObject.toJSONString()和JSONObject.parseObject()方法实现，当修改其中一个对象属性的字段另一个字段不会随着改变。
对象拷贝，深拷贝、浅拷贝、JSON拷贝
qq_57334853的博客
08-12 1132
总结：深拷贝：拷贝的是内容，相当于开辟了一个新的内容空间，将原数组美容重新复制，无论怎么修改都不会改变原内容，比如基础数据类型都是深拷贝 浅拷贝：拷贝的只是地址，内容被修改，改的是地址，原数组也会跟着改变,比如Object Array Function 都是浅拷贝.........
java中将一个实体类复制到另一个实体类的三种方法
热门推荐
Bombradish的博客
05-26 1万+
java中将一个实体类复制到另一个实体类的三种方法
深入了解Java对象的克隆
08-24
1. 使用 clone() 方法：Java 的 Object 类提供了一个 clone() 方法，该方法可以创建对象的副本。 2. 使用拷贝构造函数：我们可以使用拷贝构造函数来创建对象的副本。 3. 使用序列化：我们可以使用序列化来创建对象的...
java对象拷贝常见面试题及应答汇总
08-24
1. 实现Cloneable接口并重写Object类中的clone()方法。 2. 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。 下面是一个使用序列化和反序列化实现克隆的示例代码： ```java ...
clone()方法示例(对象克隆)_对象克隆_nervouse78_源码
10-04
`clone()`方法是Java中的`Object`类的一个成员函数，它的作用是创建并返回当前对象的一个副本，这个副本与原对象具有相同的属性值。但是，需要注意的是，`clone()`方法返回的是一个浅拷贝，即如果对象的属性包含其他...
js实现数组和对象的深浅拷贝
10-19
在JavaScript中，数据类型分为两种：原始数据...浅拷贝较为简单，但是只能拷贝对象的引用；深拷贝更为复杂，可以彻底复制对象，让新旧对象互不影响。在实际开发中，我们需要根据具体的需求和场景，选择合适的拷贝方式。
拷贝JSON对象值进Java Bean对象
03-21
NULL 博文链接：https://loven-11.iteye.com/blog/952161
克隆JSONObject
NaXieNianYiShiGuJi的专栏
05-18 1305
克隆JSONObject
实现Object深拷贝的方法及其原理
glx_gaolixian的博客
02-24 1018
使用 JSON.stringify() 和 JSON.parse()：这种方式可以将对象转换为字符串，再将字符串转换回对象。通过这种方式可以实现深拷贝，但是有一些限制，例如不能拷贝函数、循环引用等。因为该方法简单、易用、有效，针对大多数常见对象类型都能进行深拷贝，且能够适用于大多数业务场景，所以该方法是最常用、最有效的方法。无法处理函数和undefined等特殊类型；当处理包含大量数据或复杂结构的对象时，可能会比较慢。
Java 将JSONObject 复制一个新的JSONObject对象
chuan_zhang_ak的博客
07-03 1万+
JSONObject fys = new JSONObject(); fys.put("11","22"); JSONObject fys2 = JSONObject.parseObject(fys.toJSONString()); 将json对象转为字符串，将字符串重新构建 JSONObject
java json clone_java Object对象的clone方法
weixin_35933582的博客
02-13 714
参考copy链接：http://blog.csdn.net/bigconvience/article/details/25025561在看原型模式，发现要用到clone这个方法，以前和朋友聊过，没怎么看过，刚好要用，就看看了。源码解释：/*** Creates and returns a copy of this object. The precise meaning* of "copy" ma...
JSON，对象深拷贝
看见小狮子没
07-04 1243
JavaScript Object Notation1、JSON是一个字符串 常常用于网络传输数据的一种字符串格式区别： querystring 查询字符串 "name=karen&pwd=abc123&count=20" template 模板字符串 `666` JSON json字符串 '{"name":"karen","its":["hello","h5"]}' （' '）2、JSON解析 ...
震惊！Fastjson！JSONObject/JSONArray深浅拷贝踩坑，如何深度复制对象
是小宗啊？的博客
05-22 6146
文章目录一、写在前面二、问题描述三、问题模型抽取四、正文，开始敲代码，首先模拟重现问题五、问题解决的探索过程六、如何解决JSONArray/JSONObject浅拷贝问题（如何获得深拷贝对象）方法一：借助addAll()或者putAll()方法进行深度拷贝方法二：先将源对象转成JSON字符串，再解析成新对象七、写在最后 一、写在前面   昨天周五，在开发某个接口时遇到了一个非常坑的问题（当然是因为自己基础不够扎实），没有注意到JSONArray和JSONObject深拷贝与浅拷贝的问题，在坑了呆了一下午才出
java对象拷贝
初学码农
12-02 1020
java对象拷贝
Object类中的clone()方法
最新发布
2301_80636143的博客
03-21 1486
1要在类中实现Cloneable接口（异常的知识）2重写clone()方法，把throws CloneNotSupportedException放在main方法后面（异常的知识可以先后续学了在了解）3.强制类型转换成要克隆的对象的类型（因为clone返回Object类型）4.克隆方法是浅拷贝（接下来介绍）
JS自定义扩展、克隆与混合类实践解析
"本文将深入探讨JavaScript中的类扩展、对象克隆以及混合类的概念，并通过自定义的`extend`、`clone`和`augment`函数来阐述这些技术的实现和应用。我们将首先介绍如何使用`extend`函数来实现类的继承，然后讨论如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值