JAVA——Object

2022-02-20 16:31:38 阅读：180 来源： 互联网

标签：JAVA String Object equals MyTime toString 方法

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9