JAVA——Object
作者：互联网
JDK类库的根类：Object
这个老祖宗类中的方法我们需要先研究一下，因为这些方法都是所有子类通用的。
任何一个类默认继承Object。就算没有直接继承，最终也会间接继承。
对于Object原文是如此描述的：
Class Object is the root of the class hierarchy. Every class has Object as a superclass. All objects, including arrays, implement the methods of this class.
Since: JDK1.0
See Also: Class
Author: unascribe
Object类当中有哪些常用的方法？
我们去哪里找这些方法呢？
第一种方法：去源代码当中。（但是这种方式比较麻烦，源代码也比较难）
第二种方法：去查阅java的类库的帮助文档。
*什么是API
应用程序编程接口。（Application Program Interface）
整个JDK的类库就是一个javase的API。
每一个API都会配置一套API帮助文档。
SUN公司提前写好的这套类库就是API。（一般每一份API都对应一份API帮助文档。）
目前为止我们只需要知道这几个方法即可：
protected Object clone() // 负责对象克隆的。
int hashCode() // 获取对象哈希值的一个方法。
boolean equals(Object obj) // 判断两个对象是否相等
String toString() // 将对象转换成字符串形式
protected void finalize() // 垃圾回收器负责调用的方法
关于Object中的toString()方法
1、源代码长什么样？
public String toString() {
return this.getClass().getName() + "@" + Integer.toHexString(hashCode());
}
源代码上toString()方法的默认实现是：
类名@对象的内存地址转换为十六进制的形式
2、SUN公司设计toString()方法的目的是什么？
toString()方法的作用是什么？
toString()方法的设计目的是：通过调用这个方法可以将一个“java对象”转换成“字符串表示形式”
3、其实SUN公司开发java语言的时候，建议所有的子类都去重写toString()方法。
toString()方法应该是一个简洁的、详实的、易阅读的.
测试程序：
public class Test01{
public static void main(String[] args){
MyTime t1 = new MyTime(1970, 1, 1);
// 一个日期对象转换成字符串形式的话，我可能还是希望能看到具体的日期信息。
String s1 = t1.toString();
//MyTime类重写toString()方法之前
//System.out.println(s1); // MyTime@28a418fc
//MyTime类重写toString()方法之后
System.out.println(s1); // 1970年1月1日
//System.out.println(t1.toString()); //1970年1月1日
// 注意：输出引用的时候，会自动调用该引用的toString()方法。
System.out.println(t1);
}
}
class MyTime{
int year;
int month;
int day;
public MyTime(){
}
public MyTime(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
// 重写toString()方法
// 这个toString()方法怎么重写呢？
// 越简洁越好，可读性越强越好。
// 向简洁的、详实的、易阅读的方向发展
public String toString(){
//return this.year + "年" + this.month + "月" + this.day + "日";
return this.year + "/" + this.month + "/" + this.day;
}
}关于Object类中的equals方法
1、equals方法的源代码
public boolean equals(Object obj) {
return (this == obj);
}
以上这个方法是Object类的默认实现。
2、SUN公司设计equals方法的目的是什么？
以后编程的过程当中，都要通过equals方法来判断两个对象是否相等。
equals方法是判断两个对象是否相等的。
3、我们需要研究一下Object类给的这个默认的equals方法够不够用！！！！
在Object类中的equals方法当中，默认采用的是“==”判断两个java对象
是否相等。而“==”判断的是两个java对象的内存地址，我们应该判断
两个java对象的内容是否相等。所以老祖宗的equals方法不够用，
需要子类重写equals。
4、判断两个java对象是否相等，不能使用“==”，因为“==”比较的是两个
对象的内存地址。
代码验证：
//测试类
public class Test02{
public static void main(String[] args){
// 判断两个基本数据类型的数据是否相等直接使用“==”就行。
int a = 100;
int b = 100;
// 这个“==”是判断a中保存的100和b中保存的100是否相等。
System.out.println(a == b); //true（相等） false(不相等)
// 判断两个java对象是否相等，我们怎么办？能直接使用“==”吗？
// 创建一个日期对象是：2008年8月8日。
MyTime t1 = new MyTime(2008, 8, 8); //MyTime t1 = 0x1234;
// 创建了一个新的日期对象，但表示的日期也是：2008年8月8日。
MyTime t2 = new MyTime(2008, 8, 8); //MyTime t2 = 0x3698;
//测试以下，比较两个对象是否相等，能不能使用“==”？？？
// 这里的“==”判断的是：t1中保存的对象内存地址和t2中保存的对象内存地址是否相等。
System.out.println(t1 == t2); // false
// 重写Object equals方法之前（比较的是对象内存地址）
/*
boolean flag = t1.equals(t2);
System.out.println(flag); //false
*/
// 重写Object equals方法之后（比较的是内容。）
boolean flag = t1.equals(t2);
System.out.println(flag); //true
// 再创建一个新的日期
MyTime t3 = new MyTime(2008, 8, 9);
// 两个日期不相等，就是false。
System.out.println(t1.equals(t3)); // false
}
}对应初代equals()方法：
class MyTime { //extends Object{
int year;
int month;
int day;
public MyTime(){
}
public MyTime(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
// 默认的equals方法
/*
public boolean equals(Object obj) {
return (this == obj);
}
*/
// 重写Object类的equals方法
// 怎么重写？复制粘贴。相同的返回值类型、相同的方法名、相同的形式参数列表。
// equals到底应该怎么重写？你自己定，你认为两个对象什么相等的时候表示相等，你就怎么重写。
public boolean equals(Object obj) {
// 当年相同，月相同，并且日也相同的时候，表示两个日期相同。两个对象相等。
// 获取第一个日期的年月日
int year1 = this.year;
int month1 = this.month;
int day1 = this.day;
// 获取第二个日期的年月日
//int year2 = obj.year;
//int month2 = obj.month;
//int day2 = obj.day;
if(obj instanceof MyTime){
MyTime t = (MyTime)obj;
int year2 = t.year;
int month2 = t.month;
int day2 = t.day;
if(year1 == year2 && month1 == month2 && day1 == day2){
return true;
}
}
// 程序能够执行到此处表示日期不相等。
return false;
}
}思考：我们这个程序有bug吗？可以运行，但是效率怎么样？低（怎么改造。）
如果出现以下情况，之前的方法运行效率就比较低：
MyTime t4 = null;
System.out.println(t1.equals(t4)); //false改良方法：
public boolean equals(Object obj) {
// 如果obj是空，直接返回false
if(obj == null){
return false;
}
// 如果obj不是一个MyTime，没必要比较了 ，直接返回false
if(!(obj instanceof MyTime)){
return false;
}
// 如果this和obj保存的内存地址相同，没必要比较了，直接返回true。
// 内存地址相同的时候指向的堆内存的对象肯定是同一个。
if(this == obj){
return true;
}
// 程序能够执行到此处说明什么？
// 说明obj不是null，obj是MyTime类型。
MyTime t = (MyTime)obj;
if(this.year == t.year && this.month == t.month && this.day == t.day){
return true;
}
// 程序能到这里返回false
return false;
}这就比之前的效率要高很多，也对细节处进一步改良：
public boolean equals(Object obj) {
if(obj == null || !(obj instanceof MyTime)){
return false;
}
if(this == obj){
return true;
}
MyTime t = (MyTime)obj;
return this.year == t.year && this.month == t.month && this.day == t.day ;
}这样就更为简介了，时间复杂度和空间复杂度都得到了改良。
(这些方法在IDEA继承开发工具都可以自动帮助编写不用我们手动编写)
IDEA自动编写的equlas()方法程序：
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MyTime myTime = (MyTime) o;
return year == myTime.year && month == myTime.month && day == myTime.day;
}探究：java中的字符串String有没有重写toString，equals方法
测试程序：
public class Test03{
public static void main(String[] args){
// 大部分情况下，采用这样的方式创建字符串对象
String s1 = "hello";
String s2 = "abc";
// 实际上String也是一个类。不属于基本数据类型。
// 既然String是一个类，那么一定存在构造方法。
String s3 = new String("Test1");
String s4 = new String("Test1");
// new两次，两个对象内存地址，s3保存的内存地址和s4保存的内存地址不同。
// == 判断的是内存地址。不是内容。
System.out.println(s3 == s4); // false
// 比较两个字符串能不能使用双等号？
// 不能，必须调用equals方法。
// String类已经重写equals方法了。
System.out.println(s3.equals(s4)); // true
// String类有没有重写toString方法呢？
String x = new String("HelloWorld");
// 如果String没有重写toString()方法，输出结果：java.lang.String@十六进制的地址
// 经过测试：String类已经重写了toString()方法。
System.out.println(x.toString()); //HelloWorld
System.out.println(x); //HelloWorld
}
}总结：
1、String类已经重写了equals方法，比较两个字符串不能使用==，必须使用equals。String对象比较的时候必须使用equals方法
equals是通用的。
2、String类已经重写了toString方法。
大结论：
java中什么类型的数据可以使用“==”判断
java中基本数据类型比较是否相等，使用==
java中什么类型的数据需要使用equals判断
java中所有的引用数据类型统一使用equals方法来判断是否相等。
这是规矩。
关于Object类中的finalize()方法（非重点）
1、在Object类中的源代码：
protected void finalize() throws Throwable { }
GC：负责调用finalize()方法。
2、finalize()方法只有一个方法体，里面没有代码，而且这个方法是protected修饰的。
3、这个方法不需要程序员手动调用，JVM的垃圾回收器负责调用这个方法。
不像equals toString，equals和toString()方法是需要你写代码调用的。
finalize()只需要重写，重写完将来自动会有程序来调用。
4、finalize()方法的执行时机：
当一个java对象即将被垃圾回收器回收的时候，垃圾回收器负责调用
finalize()方法。（类似遗言）
5、finalize()方法实际上是SUN公司为java程序员准备的一个时机，垃圾销毁时机。
如果希望在对象销毁时机执行一段代码的话，这段代码要写到finalize()方法当中。
6、静态代码块的作用是什么？
static {
....
}
静态代码块在类加载时刻执行，并且只执行一次。
这是一个SUN准备的类加载时机。
finalize()方法同样也是SUN为程序员准备的一个时机。
这个时机是垃圾回收时机。
7、提示：
java中的垃圾回收器不是轻易启动的，
垃圾太少，或者时间没到，种种条件下，
有可能启动，也有可能不启动。
测试程序：
// 项目开发中有这样的业务需求：所有对象在JVM中被释放的时候，请记录一下释放时间！！！
// 记录对象被释放的时间点，这个负责记录的代码写到哪里？
// 写到finalize()方法中。
class Person{
// 重写finalize()方法
// Person类型的对象被垃圾回收器回收的时候，垃圾回收器负责调用：p.finalize();
protected void finalize() throws Throwable {
// this代表当前对象
System.out.println(this + "即将被销毁！");
}
}public class Test06{
public static void main(String[] args){
for(int i = 0; i < 1000; i++){
Person p = new Person();
p = null;
// 有一段代码可以建议垃圾回收器启动。
if(i % 2 == 0){
System.gc(); // 建议启动垃圾回收器。（只是建议，可能不启动，也可能启动。启动的概率高了一些。）
}
}
}
}项目开发中有这样的业务需求：所有对象在JVM中被释放的时候，请记录一下释放时间！！！
记录对象被释放的时间点，这个负责记录的代码写到哪里？
写到finalize()方法中。
关于Object类中的hashCodee()方法
在Object中的hashCode方法是怎样的？
public native int hashCode();
这个方法不是抽象方法，带有native关键字，底层调用C++程序。
hashCode()方法返回的是哈希码：
实际上就是一个java对象的内存地址，经过哈希算法，得出的一个值。
所以hashCode()方法的执行结果可以等同看做一个java对象的内存地址。
测试程序：
public class Test07{
public static void main(String[] args){
Object o = new Object();
int hashCodeValue = o.hashCode();
// 对象内存地址经过哈希算法转换的一个数字。可以等同看做内存地址。
System.out.println(hashCodeValue); //798154996
MyClass mc = new MyClass();
int hashCodeValue2 = mc.hashCode();
System.out.println(hashCodeValue2); //1392838282
MyClass mc2 = new MyClass();
System.out.println(mc2.hashCode()); // 523429237
}
}
class MyClass
{
}总结：
toString()方法
以后所有类的toString()方法是需要重写的。
重写规则，越简单越明了就好。
System.out.println(引用); 这里会自动调用“引用”的toString()方法。
String类是SUN写的，toString方法已经重写了。
equals()方法
以后所有类的equals方法也需要重写，因为Object中的equals方法比较
的是两个对象的内存地址，我们应该比较内容，所以需要重写。
重写规则：自己定，主要看是什么和什么相等时表示两个对象相等。
基本数据类型比较实用：==
对象和对象比较：调用equals方法
String类是SUN编写的，所以String类的equals方法重写了。
以后判断两个字符串是否相等，最好不要使用==，要调用字符串对象的equals方法。
注意：重写equals方法的时候要彻底。
finalize()方法。
这个方法是protected修饰的，在Object类中这个方法的源代码是：
protected void finalize() throws Throwable { }
标签：JAVA,String,Object,equals,MyTime,toString,方法 来源： https://blog.csdn.net/weixin_62838185/article/details/123025308