Object类

最新推荐文章于 2022-05-30 17:27:54 发布
最新推荐文章于 2022-05-30 17:27:54 发布
阅读量124 收藏
点赞数
分类专栏： JavaSE 文章标签： java object 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45883310/article/details/112088638
版权

基本概念

  • java.lang.Object类是Java语言中类层次结构的根类，任何一个类都是该类的直接或者间接子类
    • java.lang包下的类不用import导包
  • 如果定义一个Java类时没有使用extends关键字声明其父类，则其父类为 java.lang.Object 类
  • Object类定义了“对象”的基本行为, 被子类默认继承

常用方法

  • Object() ：使用无参方式构造对象

  • boolean equals(Object obj)：

    • 该方法默认比较两个对象的地址是否相等，与 == 运算符的结果一致

      • 源码

        public boolean equals(Object obj) {
	return (this == obj); 
}
	// this 当前正在调用的对象
    // obj 	形式参数 传的实际参数
    // boolean b1 = s1.equals(s2); 
    // this = s1 obj = s2

      • 编程实现Student类的封装，特征：学号(id)和姓名，要求提供打印所有特征的方法

        public class Student extends Object {
    private int id; // 用于描述学号的成员变量
    private String name; // 用于描述姓名的成员变量

    public Student() {
    }

    public Student(int id, String name) {
        setId(id);
        setName(name);
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        if (id > 0) {
            this.id = id;
        } else {
            System.out.println("学号不合理哦！！！");
        }
    }

    public String getName() {
        return name;
    }

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

      • 编程实现StudentTest类，在main方法中使用有参方式构造两个Student类型的对象并打印特征

        public class StudentTest {

    public static void main(String[] args) {

        // 使用有参方式构造Student类型的两个对象并判断是否相等
        Student s1 = new Student(1001, "zhangfei");
        Student s2 = new Student(1002, "guanyu");
        //Student s2 = s1;  // 表示s2和s1都指向了同一个对象，地址相同了
        
        // 下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址，可以查看源码验证
        boolean b1 = s1.equals(s2);
        System.out.println("b1 = " + b1); // false true
        System.out.println("s1 == s2" + s1 == s2); // 比较地址 false true
    }
}

    • 若希望比较两个对象的内容，则需要重写该方法

      public class Student extends Object {
    // 在get set方法下方重写equals方法
	
    /**
     * 为了比较两个对象的内容（也就是学号信息）需要重写该方法
     */
    // Student this = s1;
    // Object obj = s2;

    @Override
    public boolean equals(Object obj) {
        // 当调用对象和参数对象指向同一个对象时，则内容一定相同
        if (this == obj) return true;
        // 当调用对象为不为空而参数对象为空时，则内容一定不相同
        if (null == obj) return false;
        // 判断obj指向的对象是否为Student类型的对象，若是则条件成立，否则条件不成立
        if (obj instanceof Student) {
            Student ts = (Student) obj; // 强制类型转换
            return this.getId() == ts.getId(); // 比较ID内容
        }
        // 否则类型不一致没有可比性，则内容一定不相同
        return false;
    }
}

      public class StudentTest {

    public static void main(String[] args) {

        Student s1 = new Student(1001, "zhangfei");
        Student s2 = new Student(1001, "zhangfei");

        // 当Student类中重写equals方法后，则调用重写以后的版本，比较内容
        
        //Student s3 = null;
        //Student s3 = s1;
        //boolean b1 = s1.equals(s3);
        
        boolean b1 = s1.equals(s2);
        System.out.println("b1 = " + b1); // 比较内容 true
        System.out.println("s1 == s2" + s1 == s2); // 比较地址 false
    }
}

    • 若该方法被重写后，则应该重写hashCode方法来保证结果的一致性

  • int hashCode()：

    • 用于获取调用对象的哈希码值(内存地址的编号)

    • 若两个对象调用equals方法相等，则各自调用该方法的结果必须相同；若两个调用对象equals方法不相等，则各自调用该方法的结果应该不相同

      public class StudentTest {

    public static void main(String[] args) {

        Student s1 = new Student(1001, "zhangfei");
        //Student s2 = new Student(1002, "guanyu");
        Student s2 = s1;  // s2和s1都指向同一个对象，地址相同，内容也一定相同
        
        boolean b1 = s1.equals(s2);
        System.out.println("b1 = " + b1); // 比较内容 true 
        
        // 下面调用从Object类中继承下来的hashCode方法，获取调用对象的哈希码值(内存地址的编号)
        int ia = s1.hashCode();
        int ib = s2.hashCode();
        System.out.println("ia = " + ia); // ia = 123(举例)
        System.out.println("ib = " + ib); // ib = 1234
        // 上一步equals方法结果为true，hashCode方法返回值应该相同
        // ia ib结果不同，因为没重写hashCode方法
    }
}

    • 为了使得该方法与equals方法保持一致，需要重写该方法

      public class Student extends Object {
    // 在equals方法下方重写hashCode方法
    
	/**
     * 为了使得该方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定，需要重写该方法
     */

    @Override
    public int hashCode() {
        //return getId(); // 不再代表内存地址的编号了
        final int type = 12;
        return type*31 + getId();
        // 随便想的12和31，但结果是固定的，最终还是依赖于Id值
        // 可以和直接获取学号加以区分
    }
}

      public class StudentTest {

    public static void main(String[] args) {

        Student s1 = new Student(1001, "zhangfei");
        //Student s2 = new Student(1002, "guanyu");
        Student s2 = s1;  // s2和s1都指向同一个对象，地址相同，内容也一定相同
        
        boolean b1 = s1.equals(s2);
        System.out.println("b1 = " + b1); // 比较内容 true 
        
        // 当Student类中重写hashCode方法后，则调用重写以后的版本
        
        int ia = s1.hashCode();
        int ib = s2.hashCode();
        System.out.println("ia = " + ia); // ia = 1373
        System.out.println("ib = " + ib); // ib = 1373
        // ia ib结果相同
    }
}

  • String toString()：

    • 用于获取调用对象的字符串形式

    • 该方法默认返回的字符串为：包名.类名@哈希码值的十六进制

    • 为了返回更有意义的数据，需要重写该方法

    • 使用print或println打印引用 或 字符串拼接引用都会自动调用该方法

      public class Student extends Object {
    // 在hashCode方法下方重写toString方法
    
    /**
     * 为了返回更有意义的字符串数据，则需要重写该方法
     */ 
    
    @Override
    public String toString() {
        return "Student[id = " + getId() + ", name = " + getName() + "]";
    }
}

      package com.lagou.task11;

public class StudentTest {

    public static void main(String[] args) {
        // 下面调用从Object类中继承下来的toString方法，获取调用对象的字符串形式：包名.类名@哈希码值的十六进制
        String str1 = s1.toString();
        System.out.println("str1 = " + str1); // com.lagou.task11.Student@55d
        
        // 当Student类中重写toString方法后，则调用重写以后的版本：Student[id = 1001, name = zhangfei]
        
        // 当打印一个引用变量时会自动调用toString方法
        System.out.println(s1); // Student[id = 1001, name = zhangfei]
        String str2 = "hello" + s1;
        System.out.println("str2 = " + str2);// str2 = helloStudent[id = 1001, name = zhangfei]
    }
}

  • Classs<?> getClass() ：

    • 用于返回调用对象执行时的Class实例，反射机制使用
题目扩展

如何实现以姓名作为基准判断两个对象是否相等？以及以学号和姓名同时作为基准判断两个对象是否相等？

基础知识：

  • int是基本数据类型，内存空间中放的就是数据本身，使用 == 可以判断数据是否相同
  • String是引用数据类型，内存空间中放的是地址，使用 == 判断地址是否相同
  • 查询 java.lang包，发现String类型已经重写equals和hashCode方法

手写版：

public class Student extends Object {  

    @Override
    public boolean equals(Object obj) {
        
        if (this == obj) return true;
        if (null == obj) return false;
        if (obj instanceof Student) {
            Student ts = (Student) obj;
            // 以学号作为基准判断两个对象是否相等  int是基本数据类型，内存空间中放的就是数据本身，使用 == 可以判断数据是否相同
            //return this.getId() == ts.getId();
            // 以姓名作为基准判断两个对象是否相等  String是引用数据类型，内存空间中放的是地址，使用 == 判断地址是否相同
            // 也就是判断两个对象中姓名字符串的地址是否相同，不够完美
            //return this.getName() == ts.getName();
            
            return this.getName().equals(ts.getName()); // 比较姓名字符串的内容是否相同
        }
        return false;
    }

    @Override
    public int hashCode() {
        final int type = 12;
        //return type*31 + getName(); // getName()是String类型，拼接后结果为String类型，而函数返回值要求int类型
        return type*31 + getName().hashCode();
    }
}

生成版：

IntelliJ Deafault：

	@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (id != student.id) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }

Template：java.util.Objects.equals and hashCode(java 7+)：

import java.util.Objects;

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

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

个人理解：

假设在抽屉A里放了一个苹果，两张纸条上都写着“抽屉X”字样（X表示未知）。抽屉A相当于内存地址，苹果相当于所存数据，两张纸条其中一条拿在手上，相当于调用对象，另一条放在桌子上，相当于参数对象。

if (this == o) return true;：两张纸条上都写着“抽屉A”字样，同一个抽屉，同一个苹果

if (o == null || getClass() != o.getClass()) return false;：放在桌子上的纸条没写字 / 拿在手上的纸条写着“抽屉A”，放在桌子上的纸条写着“书包A”（类型不同，没有可比性）

Student student = (Student) o;：强制向下转型（小转大可自动，大转小需手动）

return id == student.id && Objects.equals(name, student.name);：id匹配成功才会继续匹配名字

我要成为罗宾姐姐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第十一章 Object类和包装类.md
10-24
==与equals的比较，包装类的使用
Java面向对象（进阶）- Object类的详细概述
最新发布
11-14
Object类是所有Java类的根父类，无论何时我们创建一个新的类，除非明确指定其他父类，否则它都会默认继承Object类。这使得Object类中的方法对所有Java类都可用，体现了Java的继承性和多态性。 1. **根父类理解** -...
Object类的常用方法
热门推荐
lele的博客
06-20 1万+
Java语言不同于C++语言，是一种单根继承结构语言，也就是说，Java中所有的类都有一个共同的祖先。这个祖先就是Object类。object类的结构 如图可知，Object类有12个成员方法，按照用途可以分为以下几种 1，构造函数 2，hashCode和equale函数用来判断对象是否相同, 3，wait(),wait(long),wait(long,int),notify(),notifyAl...
ES6及以后
qq_56636514的博客
05-30 382
ES6简介 ES6，全称 ECMAScript 6.0 ，是 JavaScript 的下一个版本标准，2015.06 发版 虽然15年就有正式版本了，但是国内普遍商用是在2018年之后去了，甚至到现在有很多前端仍然搞不懂ES6（都2022年了，兄dei~） ES6 的出现主要是为了解决 ES5 的先天不足，比如 JavaScript 里并没有类的概念 目前存在少数低版本浏览器的 JavaScript 是 ES5 版本，大多数的浏览器已经支持 ES6 ES6提供了大量的语法糖，让你写代码的时候简直不要太爽！
Object类中常用方法
欢迎一起学习交流
05-01 481
方法 描述 toString() 返回该对象的字符串表示 hashcode() native方法，用于返回对象的哈希吗，主要使用在哈希表中，比如jdk中的 HashMap equals() 判断这两个对象是否是相同的 getClass() 返回此 Object 的运行时类 finalize() 当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。 notify() 唤醒正在等待对象监视器的单个线程。 notifyAll()
Object类常用的方法
weixin_43371098的博客
06-26 311
Object类的hashCode()方法 Object是所有类的顶层父类，所有类都是直接或间接继承他。 hashCode()是返回一个对象的哈希吗值 可以通过创建Object对象，调用hashCode方法，转换成整数值 Object object = new Object(); int i = object.hashCode(); //用Object对象调用hashCode方法，转换成具体的整数值...
Java中的Object类、Set接口（学习小结）
12-22
1.Object类 1.1 Object类概述 Object类是Java中所有类的基类。Java中所有的类都是直接或间接继承Object类。 Object类的引用数据类型变量可以保存Java中任意数据类型空间的首地址。 Object类中规定了一些方法，可供...
1.javaObject类.zip
06-14
1.javaObject类.zip1.javaObject类.zip1.javaObject类.zip1.javaObject类.zip1.javaObject类.zip1.javaObject类.zip1.javaObject类.zip1.javaObject类.zip1.javaObject类.zip1.javaObject类.zip1.javaObject类.zip1....
java中object类实例分析
08-28
java中object类实例分析 Object类是Java语言中所有类的父类，位于java.lang包中。它是所有Java类的终极父类，数组也继承了Object类。然而，接口是不继承Object类的，Object类不作为接口的父类。 Object类提供了几...
【转】Object类的常用方法
MR_FTD的博客
11-24 273
Java语言不同于C++语言，是一种单根继承结构语言，也就是说，Java中所有的类都有一个共同的祖先。这个祖先就是Object类。 object类的结构 如图可知，Object类有12个成员方法，按照用途可以分为以下几种 1，构造函数 2，hashCode和equale函数用来判断对象是否相同, 3，wait(),wait(long),wait(long,int),notify(),notifyAll() 4，toString()和getClass, 5，clone() 6，finali...
Object类中的常用方法
m0_53365899的博客
04-11 1万+
这里写目录标题二，toString()方法三，finalize()方法四，hashcode()方法 二，toString()方法 三，finalize()方法 1,在object类中的源代码： protected void finalize()throws Throwable() 2,finalize()方法只有一个方法体，里面没有代码，而且这个方法是protected修饰的。 class Person{ protected void finalize()throws Throwable{ //
Object类常用方法
qq_37373722的博客
05-13 145
Object类常用方法 Object类是类层次结构的根类，所有类都直接或间接的继承自该类，该类的成员方法也都被继承，要根据具体的情况来选择覆写哪个方法。 1.取得对象信息：toString（）方法 Object类的toString()方法默认返回该对象实现类的“类名+@+hashcode”值，这个返回值不能满足一般的需求，所以在定义的具体的类中需要重写Object类的toString()方法来实现。 2.对象比较：equals（）方法 提供定义对象是否“相等”的逻辑。即x.equals(y)当x与y是同一个
kotlin object类
03-26
Kotlin中的Object类是一个单例类，它被用于创建只有一个实例的类。Object类的实例在程序中只能被创建一次，并且这个实例可以被程序的任何部分访问和使用。 Object类是Kotlin中的一个非常有用的类，它可以用于创建单例对象、静态方法和常量。Object类可以在Kotlin中被用于以下几个方面： 1. 单例对象：Object类可以用于创建单例对象，这个对象只会被创建一次，其余的访问都是对同一个实例的调用。 2. 静态方法：Object类中的方法可以被直接调用，不需要创建实例对象。 3. 常量：Object类中的常量可以被用于表示程序中的一些固定值，这些值在程序中多次使用，使用常量可以减少代码的重复。 下面是使用Object类创建单例对象的示例： ``` object MySingleton { fun doSomething() { // do something } } // 调用单例对象的方法 MySingleton.doSomething() ``` 上面的示例中，MySingleton是一个单例对象，它只会被创建一次，并且可以在程序的任何部分被访问和使用。同时，我们可以使用MySingleton.doSomething()来调用这个对象中的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值