JAVA里的object类

于 2024-07-01 16:04:23 发布
阅读量823 收藏 8
点赞数 9
分类专栏： JAVA 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65752158/article/details/140076562
版权

 public static String toString(Object o)                     // 获取对象的字符串表现形式
public static boolean equals(Object a, Object b)            // 比较两个对象是否相等
public static boolean isNull(Object obj)                    // 判断对象是否为null
public static boolean nonNull(Object obj)                    // 判断对象是否不为null

1.toString(获取对象的字符串表现形式)

默认情况下,因为object类中的toString方法返回的是地址值,所以默认打印地址值
如果我们要打印属性值,就必须重写toString方法
toString方法的结论
如果我们打印一个对象,想要看到属性值,那就必须重写toString方法
在重写的方法中,把对象的属性值进行拼接
public class objectdemo1 {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(s1);//Object.Student@b4c966a
        String s2 = s1.toString();
        System.out.println(s2);//Object.Student@b4c966a

        //默认情况下,因为object类中的toString方法返回的是地址值,所以默认打印地址值
        //如果我们要打印属性值,就必须重写toString方法
        //toString方法的结论
        //如果我们打印一个对象,想要看到属性值,那就必须重写toString方法
        //在重写的方法中,把对象的属性值进行拼接

    }
}

 重写之后


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




public class objectdemo1 {
    public static void main(String[] args) {
        Student s1 = new Student("zhangsan",18);
        System.out.println(s1);//zhangsan,18
        String s2 = s1.toString();
        System.out.println(s2);//zhangsan,18

        //默认情况下,因为object类中的toString方法返回的是地址值,所以默认打印地址值
        //如果我们要打印属性值,就必须重写toString方法
        //toString方法的结论
        //如果我们打印一个对象,想要看到属性值,那就必须重写toString方法
        //在重写的方法中,把对象的属性值进行拼接

    }
}

2.equals(比较两个对象是否相等)

默认比的是地址值,由于我们创建对象肯定创建出不同的对象,在堆区会开辟不同的内存空间,所以地址值肯定不一样,所以我们就要重写父类object里的equals方法

//public static boolean equals(Object a, Object b) 比较两个对象是否相等
public class objectdemo2 {
    public static void main(String[] args) {

        Student s1 = new Student();
        Student s2 = new Student();
        System.out.println(s1.equals(s2));//比的是地址值
        
    }
}

结果

重新父类的equals方法

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

如果我们比较属性值:

//public static boolean equals(Object a, Object b) 比较两个对象是否相等
public class objectdemo2 {
    public static void main(String[] args) {

        Student s1 = new Student("张三",18);
        Student s2 = new Student("张三",18);
        System.out.println(s1.equals(s2));//比的是属性值

    }
}

结果

//public static boolean equals(Object a, Object b) 比较两个对象是否相等
public class objectdemo3 {
    public static void main(String[] args) {

        String s1 = "abc";
        StringBuffer sb = new StringBuffer("abc");
        System.out.println(s1.equals(sb));//false
        //因为equals方法是被s1调用的,而s1是字符串
        //所以equals要看String类中的
        //如果是字符串,则比较内部属性值
        //如果参数不是字符串,直接返回false
        System.out.println(sb.equals(s1));//false
        //因为equals方法是被sb调用的,而sb是不是字符串是StringBuffer
        //所以equals要看StringBuffer类中的
        //因为StringBuffer没有重写equals方法,所以默认使用的是父类object类的equals方法
        //所以比较的是地址值
        //而这里s1和sb的地址值不一样,所以返回false
    }
}

结论: 

3.浅克隆和深克隆

在Java中，实现浅克隆通常意味着你需要重写对象的clone()方法。Java中的Object类提供了一个默认的clone()方法，但这个默认实现是受保护的，因此你需要让你的类实现Cloneable接口（尽管这个接口是一个标记接口，没有任何方法），并且重写clone()方法以使其为public。

浅克隆 

细节:

public class objectdemo5 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Day day = new Day(2024, 6, 6);
        // 创建一个Animal对象
        Animal a = new Animal("小黑", 2, day);
        // 浅克隆这个Animal对象
        //先是object cloneA=a.clone();
        //然后强转成Animal类型
        // Animal cloneA=(Animal)a.clone();
        Animal cloneA = (Animal) a.clone();
        System.out.println(cloneA);
    }
}

 

package Object;

import java.util.Objects;

// 假设我们有一个简单的类Animal，它包含基本数据类型和另一个对象的引用
public class Animal implements Cloneable{
    private String name;
    private int age;
    private Day day; 假设Day是另一个类，并且我们想要浅克隆它

    public Animal(String name, int age, Day day) {
        this.name = name;
        this.age = age;
        this.day = day;
    }

    public Animal() {
    }

    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 Day getDay() {
        return day;
    }

    public void setDay(Day day) {
        this.day = day;
    }

    // 重写clone方法以实现浅克隆


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

    // toString方法（可选，但有助于调试）
    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", day=" + day +
                '}';
    }
}

 

package Object;

public class Day {
    private int year;
    private int month;
    private int day;

    public Day(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public Day() {
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return "Day{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}

结果:

 clone 方法是浅拷贝，对象内属性引用的对象只会拷贝引用地址，而不会将引用的对象重新分配内存，相对应的深拷贝则会连引用的对象也重新创建。

说白了 浅克隆 是克隆的对象和被克隆的对象共享一块内存,其实一方改变,则另一方也跟着改变

深克隆

深克隆我们可以导入第三方工具类

//用第三方工具
        //编写代码
        Gson gson = new Gson();
        //把对象变成字符串
        String s = gson.toJson(a);//克隆Animal a类
        //再把字符串变成对象即可
        Animal animal = gson.fromJson(s, Animal.class);
        //试一下是不是深克隆 animal没有变即深克隆
        day.setYear(2023);
        //打印对象
        System.out.println(animal);//拷贝之后的结果

结果

说白了 深克隆 是克隆的对象和被克隆的对象不是一块内存,其实一方改变,则另一方也不会跟着改变,克隆出来的本质是拷贝了一个副本,操作的是自己属于的那块内存

 Objects

 public static void main(String[] args) {
        Student s1 = null;
        Student s2 = new Student("zhangsan", 18);
        //判断对象是否为null
        boolean result = Objects.equals(s1, s2);
        System.out.println(result);//false
        //细节:
        //1.方法的底层会判断s1是否为null,如果为null,直接返回false
        //2.如果s1不为null,那就利用s1再次调用equals方法
        //3.此时s1是Student类型,所以最终还是会调用Student类型中的equals方法
        //如果没有重写,比较的是地址值,如果重写了,比较的就是属性值了

结果:

public static boolean isNull(Object obj)                    // 判断对象是否为null
public static boolean nonNull(Object obj)                    // 判断对象是否不为null 

  Student s3 = new Student("zhangsan", 18);
        Student s4 = null;
        System.out.println(Objects.isNull(s3)); 判断对象是否为null,为null返回true
        System.out.println(Objects.isNull(s4));

结果:

  // public static boolean nonNull(Object obj)// 判断对象是否不为null
  Student s5 = new Student("zhangsan", 18);
 Student s6 = null;
 System.out.println(Objects.nonNull(s5));//判断对象是否为不null,如果不为null返回true
 System.out.println(Objects.nonNull(s6));

结果 

 

林的快手
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值