Java 中的Object类（5千字详解）

分手后的思念是犯贱 2023-09-28 13:49 21阅读 0赞

# 前言 #

*  **Class Object是类Object结构的根。 每个类都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法。**
 *  **Object类中的方法如下**：  
    ![在这里插入图片描述][bbfd8c1bbe724c478a50244976d98227.png]
 *  **我们将逐个解释Object类中的各个方法。**

# 一、equals 方法 #

## 1. 基本语法 ##

*  **如下图所示：**  
    ![在这里插入图片描述][9fad9f59777340dc86bae1877ebafd5b.png]

## 2. equals 与 == 运算符的对比 ##

*  **基本概念：**  
    ![在这里插入图片描述][5484d0e89bdb41f3bda772c7e8065fb9.png]
 *  **代码演示：**

public class Equals01 {
        
        public static void main(String[] args) {
        
            //引用类型，判断对象地址（对象）是否相等
            A a = new A();
            A b = a;
            A c = b;// a、b、c指向同一个对象；
            System.out.println(a == c);//true
            System.out.println(b == c);//true
            B bObj = a;//指向同一个对象
            System.out.println(bObj == c);//true
            
            //基本数据类型，判断值是否相等
            //注意！虽然数据类型不同，但实质上比较的是值，与数据类型无关
            //如果是char类型，则需要先把char类型数据转成对应10进制数据，再进行比较
            int num1 = 10;
            double num2 = 10.0;
            System.out.println(num1 == num2);//true，10.0和10是一样的
    
            /*
            怎么查看源码：
            equals 方法，源码怎么查看.
            把光标放在equals方法，直接输入ctrl + b
            */
            /*
            查看Object类的 equals 源码：
            Object 的equals 方法默认就是比较对象地址是否相同，
            也就是判断两个对象是不是同一个对象。
    
            public boolean equals(Object obj) {
                return (this == obj);
            }
             */
            
            "hello".equals("abc");// 比较两个字符串是否相等；
            String str1 = new String("hspedu");
            String str2 = new String("hspedu");
            System.out.println(str1 == str2);//false
            System.out.println(str1.equals(str2));//true
            /*
            查看 String类的 equals方法：
            把Object的equals 方法重写了,变成了比较两个字符串值是否相同；
            
        	public boolean equals(Object anObject) {
            	if (this == anObject) {//如果是同一个对象
            	    return true;//返回true
         		}
            	if (anObject instanceof String) {//判断类型
                	String anotherString = (String)anObject;//向下转型
                	int n = value.length;
                	if (n == anotherString.value.length) {//如果长度相同
                    	char v1[] = value;
                    	char v2[] = anotherString.value;
                    	int i = 0;
                    	while (n-- != 0) {//然后一个一个的比较字符
                        	if (v1[i] != v2[i])
                            	return false;
                        	i++;
                    	}
                   		return true;//如果两个字符串的所有字符都相等，则返回true
                	}
            	}
            	return false;//如果比较的不是字符串，则直接返回false
        	}
             */
            // 注意：有个特殊情况
            Srting s1 = "lin";// 在常量池中存储了"lin"，返回s1地址
            String s2 = "lin";// s2发现常量池中存在了"lin"，于是直接指向它
            System.out.println(s1 == s2);//true，因为s1和s2 指向地址相同
    
    
    		Integer integer1 = new Integer(1000);
            Integer integer2 = new Integer(1000);
            System.out.println(integer1 == integer2);//false
            System.out.println(integer1.equals(integer2));//true
            /*
            查看Integer类的 equals 源码：
            从源码可以看到 Integer 也重写了Object的equals方法,
            变成了判断两个值是否相同；
            
            public boolean equals(Object obj) {
                if (obj instanceof Integer) {
                    return value == ((Integer)obj).intValue();
                }
                return false;
            }
            */
        }
    }
    
    class B {
        }
    class A extends B {
        }

## 3. 重写 equals 方法 ##

*  **应用实例：**

>  *  **应用实例: 判断两个 Person 对象的内容是否相等，如果两个 Person 对象的各个属性值都一样，则返回 true，反之 false。**

*  **代码实现：**

public class EqualsExercise01 {
        
        public static void main(String[] args) {
        
            Person person1 = new Person("jack", 10, '男');
            Person person2 = new Person("jack", 20, '男');
    
            System.out.println(person1.equals(person2));//假
        }
    }
    
    class Person{
         //extends Object
        private String name;
        private int age;
        private char gender;
    
        //重写Object 的 equals方法
        public boolean equals(Object obj) {
        
            //判断如果比较的两个对象是同一个对象，则直接返回true
            if(this == obj) {
        
                return true;
            }
            //类型判断，使用instanceof 判断传入对象是否是Person类对象或者是其子类对象
            if(obj instanceof Person) {
         // 类型满足，才能比较，不满足则直接报错
    
                //由于obj有可能是父类的引用，所以统一对obj进行 向下转型, 因为需要得到obj的 各个属性
                Person p = (Person)obj;
                return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
            }
            //如果不是Person ，则直接返回false
            return false;
    
        }
    
        public Person(String name, int age, char gender) {
        
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
    
        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 char getGender() {
        
            return gender;
        }
    
        public void setGender(char gender) {
        
            this.gender = gender;
        }
    }

# 二、hashCode 方法 #

## 1. 基本语法 ##

*  **如下图所示：**  
    ![在这里插入图片描述][7b198c6e7cc84e9db32152eed72cc58a.png]

## 2. hashCode 使用小结 ##

> 1.  **哈希值可以提高具有哈希结构的容器的效率；**
> 2.  **两个引用，如果指向的是同一个对象，则哈希值肯定是一样的；**
> 3.  **两个引用，如果指向的是不同对象，则哈希值是不一样的（注意，不是一定）；**
> 4.  **哈希值主要根据地址号来给出的，但不能完全将哈希值等价于地址；**
> 5.  **后面在集合中， hashCode 如果需要的话，也会重写；**

*  **代码演示：**

public class HashCode_ {
        
        public static void main(String[] args) {
        
    
            AA aa = new AA();
            AA aa2 = new AA();
            AA aa3 = aa;
            System.out.println("aa.hashCode()=" + aa.hashCode());
            System.out.println("aa2.hashCode()=" + aa2.hashCode());
            System.out.println("aa3.hashCode()=" + aa3.hashCode());
    		// aa 和 aa2的哈希值不相等；aa 和aa3的哈希值相等；
        }
    }
    class AA {
        }

# 三、toString 方法 #

## 1. 基本语法 ##

*  **如下图所示：**  
    ![在这里插入图片描述][8b8c2ca8a3eb4dddbc567f6ab487bd4b.png]

## 2. toString 使用细节 ##

*  **子类往往重写 toString 方法，用于返回对象的属性信息；**
 *  **重写 toString 方法，打印对象或拼接对象时，都会自动调用该对象的 toString 形式；**
 *  当直接输出一个对象时，toString 方法会被默认的调用, 比如 ：System.out.println(monster)； 就会默认调用 monster.toString()；
 *  **代码演示：**

public class ToString_ {
        
        public static void main(String[] args) {
        
            /*
            查看Object的toString() 源码
            (1)getClass().getName() 类的全类名(包名+类名 )
            (2)Integer.toHexString(hashCode()) 将对象的hashCode值转成16进制字符串
            
            public String toString() {
                return getClass().getName() + "@" + Integer.toHexString(hashCode());
            }
             */
            Monster monster = new Monster("小妖怪", "巡山的", 1000);
            System.out.println(monster.toString() + " hashcode=" + monster.hashCode());
    
            System.out.println("==当直接输出一个对象时，toString 方法会被默认的调用==");
            System.out.println(monster); //等价 monster.toString()
        }
    }
    
    class Monster {
        
        private String name;
        private String job;
        private double sal;
    
        public Monster(String name, String job, double sal) {
        
            this.name = name;
            this.job = job;
            this.sal = sal;
        }
    
        //重写toString方法, 输出对象的属性
        //使用快捷键即可 alt+insert -> toString
        //重写后，一般是把对象的属性值输出，当然程序员也可以自己自定义
        @Override
        public String toString() {
         
            return "Monster{" +
                    "name='" + name + '\'' +
                    ", job='" + job + '\'' +
                    ", sal=" + sal +
                    '}';
        }
    }

# 四、finalize 方法 #

## 1. 基本语法 ##

*  **如下图所示：**  
    ![在这里插入图片描述][b9c7b37c514e456ead78700afe4731c4.png]

## 2. finalize 使用细节 ##

> 1.  **当对象被回收时，系统自动调用该对象的 finalize 方法。子类可以重写该方法，做一些释放资源的操作；**
> 2.  **什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来 销毁该对象，在销毁该对象前，会先调用 finalize 方法；**
> 3.  **垃圾回收机制的调用时间，是由系统来决定(即有自己的 GC 算法)，也可以通过调用 System.gc() 主动触发垃圾回收机制；**

*  **代码演示：**

public class Finalize_ {
        
        public static void main(String[] args) {
        
    
            Car bmw = new Car("宝马");
    
            bmw = null;
            // 这时 car对象就是一个垃圾,垃圾回收器就会回收(销毁)对象, 在销毁对象前，系统会调用该对象的finalize方法
            // 程序员可以在 finalize中，写自己的业务逻辑代码(比如释放资源：数据库连接,或者打开文件..)
            // 如果程序员不重写 finalize,那么就会调用 Object类的 finalize, 即默认处理
            // 如果程序员重写了 finalize方法, 就可以实现自己的逻辑
            
            System.gc();// 主动调用垃圾回收器；
            
            // 注意，调用finalize 时系统不会阻塞，会继续运行下面代码
            // 所以下面的语句会优先输出；
            System.out.println("程序退出了....");
        }
    }
    
    class Car {
        
        private String name;
        public Car(String name) {
        
            this.name = name;
        }
    
        //重写 finalize
        @Override
        protected void finalize() throws Throwable {
        
            System.out.println("我们销毁 汽车" + name );
            System.out.println("释放了某些资源...");
        }
    }

# 总结 #

*  本文是小白博主在学习B站韩顺平老师的Java网课时整理的学习笔记，在这里感谢韩顺平老师的网课，如有有兴趣的小伙伴也可以去看看。
 *  Object类 方法的学习总结就结束啦，明天接着学习新的内容了。如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！

[bbfd8c1bbe724c478a50244976d98227.png]: https://img-blog.csdnimg.cn/bbfd8c1bbe724c478a50244976d98227.png
[9fad9f59777340dc86bae1877ebafd5b.png]: https://img-blog.csdnimg.cn/9fad9f59777340dc86bae1877ebafd5b.png
[5484d0e89bdb41f3bda772c7e8065fb9.png]: https://img-blog.csdnimg.cn/5484d0e89bdb41f3bda772c7e8065fb9.png
[7b198c6e7cc84e9db32152eed72cc58a.png]: https://img-blog.csdnimg.cn/7b198c6e7cc84e9db32152eed72cc58a.png
[8b8c2ca8a3eb4dddbc567f6ab487bd4b.png]: https://img-blog.csdnimg.cn/8b8c2ca8a3eb4dddbc567f6ab487bd4b.png
[b9c7b37c514e456ead78700afe4731c4.png]: https://img-blog.csdnimg.cn/b9c7b37c514e456ead78700afe4731c4.png