Java Object类详解

「爱情、让人受尽委屈。」 2023-10-08 22:40 38阅读 0赞

![660fb01243a04f12b917e402deb1da00.png][]

Object 是 Java 类库中的一个特殊类，也是所有类的父类。也就是说，Java 允许把任何类型的对象赋给 Object 类型的变量。当一个类被定义后，如果没有指定继承的父类，那么默认父类就是 Object 类。因此，以下两个类表示的含义是一样的。

>     public class MyClass{…}

等价于

>     public class MyClass extends Object {…}

由于 Java 所有的类都是 Object 类的子类，所以任何 Java 对象都可以调用 Object 类的方法。常见的方法如表 1 所示。

<table>  表 1 Object 类的常用方法  
 <tbody> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
  <tr> 
   <td>Object clone()</td> 
   <td>创建与该对象的类相同的新对象</td> 
  </tr> 
  <tr> 
   <td>boolean equals(Object)</td> 
   <td>比较两对象是否相等</td> 
  </tr> 
  <tr> 
   <td>void finalize()</td> 
   <td>当垃圾回收器确定不存在对该对象的更多引用时，对象垃圾回收器调用该方法</td> 
  </tr> 
  <tr> 
   <td>Class getClass()</td> 
   <td>返回一个对象运行时的实例类</td> 
  </tr> 
  <tr> 
   <td>int hashCode()</td> 
   <td>返回该对象的散列码值</td> 
  </tr> 
  <tr> 
   <td>void notify()</td> 
   <td>激活等待在该对象的监视器上的一个线程</td> 
  </tr> 
  <tr> 
   <td>void notifyAll()</td> 
   <td>激活等待在该对象的监视器上的全部线程</td> 
  </tr> 
  <tr> 
   <td>String toString()</td> 
   <td>返回该对象的字符串表示</td> 
  </tr> 
  <tr> 
   <td>void wait()</td> 
   <td>在其他线程调用此对象的 notify()&nbsp;方法或 notifyAll()&nbsp;方法前，导致当前线程等待</td> 
  </tr> 
 </tbody> 
</table>

其中，toString()、equals() 方法和 getClass() 方法在 Java 程序中比较常用。

### toString() 方法 ###

toString() 方法返回该对象的字符串，当程序输出一个对象或者把某个对象和字符串进行连接运算时，系统会自动调用该对象的 toString() 方法返回该对象的字符串表示。  
  
Object 类的 toString() 方法返回“运行时类名@十六进制哈希码”格式的字符串，但很多类都重写了 Object 类的 toString() 方法，用于返回可以表述该对象信息的字符串。

> 哈希码（hashCode），每个 Java 对象都有哈希码属性，哈希码可以用来标识对象，提高对象在集合操作中的执行效率。

先看以下代码：

1.      // 定义Demo类，实际上继承Object类
        class Demo {
        
        }
        
        public class ObjectDemo01 {
        public static void main(String[] args) {
        Demo d = new Demo(); // 实例化Demo对象
        System.out.println("不加toString()输出：" + d);
        System.out.println("加上toString()输出：" + d.toString());
        }
        }

输出结果为：

> 不加toString()输出：Demo@15db9742  
> 加上toString()输出：Demo@15db9742

以上的程序是随机输出了一些地址信息，从程序的运行结果可以清楚的发现，加和不加 toString() 的最终输出结果是一样的，也就是说对象输出时一定会调用 Object 类中的 toString() 方法打印内容。所以利用此特性就可以通过 toString() 取得一些对象的信息，如下面代码。

1.      public class Person {
        private String name;
        private int age;
        
        public Person(String name, int age) {
        this.name = name;
        this.age = age;
        }
        
        public String toString() {
        return "姓名：" + this.name + "：年龄" + this.age;
        }
        
        public static void main(String[] args) {
        Person per = new Person("CSDN社区", 30);// 实例化Person对象
        System.out.println("对象信息：" + per);// 打印对象调用toString()方法
        }
        }

输出结果为：

> 对象信息：姓名：CSDN社区：年龄30

程序中的 Person 类中重写了 Object 类中的 toString() 方法，这样直接输出对象时调用的是被子类重写过的 toString() 方法。

### equals() 方法 ###

在前面学习字符串比较时，曾经介绍过两种比较方法，分别是`==`运算符和 equals() 方法，`==`运算符是比较两个引用变量是否指向同一个实例，equals() 方法是比较两个对象的内容是否相等，通常字符串的比较只是关心内容是否相等。  
  
其使用格式如下：

1.      boolean result = obj.equals(Object o);

其中，obj 表示要进行比较的一个对象，o 表示另一个对象。

例 1

编写一个 Java 程序，实现用户登录的验证功能。要求用户从键盘输入登录用户名和密码，当用户输入的用户名等于 admin 并且密码也等于 admin 时，则表示该用户为合法用户，提示登录成功，否则提示用户名或者密码错误信息。  
  
在这里使用 equals() 方法将用户输入的字符串与保存 admin 的字符串对象进行比较，具体的代码如下：

1.      
        import java.util.Scanner;
        public class Test01 {
        // 验证用户名和密码
        public static boolean validateLogin(String uname, String upwd) {
        boolean con = false;
        if (uname.equals("admin") && upwd.equals("admin")) { // 比较两个 String 对象
        con = true;
        } else {
        con = false;
        }
        return con;
        }
        public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("------欢迎使用大数据管理平台------");
        System.out.println("用户名：");
        String username = input.next(); // 获取用户输入的用户名
        System.out.println("密码：");
        String pwd = input.next(); // 获取用户输入的密码
        boolean con = validateLogin(username, pwd);
        if (con) {
        System.out.println("登录成功！");
        } else {
        System.out.println("用户名或密码有误！");
        }
        }
        }

上述代码在 validateLogin() 方法中又使用 equals() 方法将两个 String 类型的对象进行了比较，当 uname 对象与保存 admin 的 String 对象相同时，uname.equals("admin") 为 true；与此相同，当 upwd 对象与保存 admin 的 String 对象相同时，upwd.equals("admin") 为 true。当用户输入的用户名和密码都为 admin 时，表示该用户为合法用户，提示登录成功信息，否则提示用户名或密码有误的错误信息。  
  
该程序的运行结果下所示：

>     ------欢迎使用大数据管理平台------
>     用户名：
>     adinm
>     密码：
>     admin
>     用户名或密码有误！

>     ------欢迎使用大数据管理平台------
>     用户名：
>     admin
>     密码：
>     admin
>     登录成功！

### getClass() 方法 ###

getClass() 方法返回对象所属的类，是一个 Class 对象。通过 Class 对象可以获取该类的各种信息，包括类名、父类以及它所实现接口的名字等。

例 2

编写一个实例，演示如何对 String 类型调用 getClass() 方法，然后输出其父类及实现的接口信息。具体实现代码如下：

1.      public class Test02 {
        public static void printClassInfo(Object obj) {
        // 获取类名
        System.out.println("类名：" + obj.getClass().getName());
        
        // 获取父类名
        System.out.println("父类：" + obj.getClass().getSuperclass().getName());
        System.out.println("实现的接口有：");
        
        // 获取实现的接口并输出
        for (int i = 0; i < obj.getClass().getInterfaces().length; i++) {
        System.out.println(obj.getClass().getInterfaces()[i]);
        }
        }
        
        public static void main(String[] args) {
        String strObj = new String();
        printClassInfo(strObj);
        }
        }

该程序的运行结果如下：

>     类名：java.lang.String
>     父类：java.lang.Object
>     实现的接口有：
>     interface java.io.Serializable
>     interface java.lang.Comparable
>     interface java.lang.CharSequence

### 接收任意引用类型的对象 ###

既然 Object 类是所有对象的父类，则所有的对象都可以向 Object 进行转换，在这其中也包含了数组和接口类型，即一切的引用数据类型都可以使用 Object 进行接收。

1.      interface A {
        public String getInfo();
        }
        
        class B implements A {
        public String getInfo() {
        return "Hello World!!!";
        }
        }
        
        public class ObjectDemo04 {
        public static void main(String[] args) {
        // 为接口实例化
        A a = new B();
        // 对象向上转型
        Object obj = a;
        // 对象向下转型
        A x = (A) obj;
        System.out.println(x.getInfo());
        
        }
        }

输出结果为：

> Hello World!!!

通过以上代码可以发现，虽然接口不能继承一个类，但是依然是 Object 类的子类，因为接口本身是引用数据类型，所以可以进行向上转型操作。  
  
同理，也可以使用 Object 接收一个数组，因为数组本身也是引用数据类型。

1.      public class ObjectDemo05 {
        public static void main(String[] args) {
        int temp[] = { 1, 3, 5, 7, 9 };
        // 使用object接收数组
        Object obj = temp;
        // 传递数组引用
        print(obj);
        }
        
        public static void print(Object o) {
        // 判断对象的类型
        if (o instanceof int[]) {
        // 向下转型
        int x[] = (int[]) o;
        // 循环输出
        for (int i = 0; i < x.length; i++) {
        System.out.print(x[i] + "\t");
        }
        }
        }
        }

输出结果为：

> 1 3 5 7 9

以上程序使用 Object 接收一个整型数组，因为数组本身属于引用数据类型，所以可以使用 Object 接收数组内容，在输出时通过 instanceof 判断类型是否是一个整型数组，然后进行输出操作。  
  
提示：因为 Object 类可以接收任意的引用数据类型，所以在很多的类库设计上都采用 Object 作为方法的参数，这样操作起来会比较方便。

[660fb01243a04f12b917e402deb1da00.png]: https://img-blog.csdnimg.cn/660fb01243a04f12b917e402deb1da00.png