Object類
概述
概念
Object是類層次結構的根類.每個類都使用Object作為超類.所有對象(包括數組)都實現這個類的方法.
隨意定義一個類型,不手動顯式定義其父類,那么這個類的父類就是Object類.
Object類: 是所有類的父類 ,Object類沒有父類 是所有類的爸爸
特點
1. Object類型的引用 可以指向任何類的對象
2. Object類中定義的所有的非私有的屬性和方法 在所有的類中都擁有使用權
3. 當定義一個類的時候,沒有繼承任何的類,默認這個類 繼承Object
4、Object類如果不是一個類的直接父類,必定是這個類的間接父類
構造方法
語法
Object()
用途
1.創建Object類的對象的方法.
2.子類訪問,所有子類都會直接或者間接的訪問到這個頂層父類的構造方法.
常用方法
toString()
作用
返回對象的字符串形式
方法實現
輸出
getClass().getName() + '@' + Integer.toHexString(hashCode())
過程
(1)getClass().getName() 表示類的完全限定名.
(2)hashCode() 表示根據內存地址通過哈希算法生成的哈希碼值.
(3)Integer.toHexString() 表示無符號十六進制的字符串表示形式.
過程詳解
輸出內容:getClass().getName() + '@' + Integer.toHexString(hashCode())
(1)getClass.getName(): 作用：獲取對象的全類名
1）getClass()
作用:返回此 Object 的運行時類。
獲取的是類的字節碼對象 ，就是 Class 類的對象,輸出結果最前面會帶有 class.
對象中存儲了 關於 xx類中所有的屬性名 、 類名、 包名 、 構造方法名、 構造方法 .....
例：class com.study.day0416.Student
2)getName()
必須與getClass()連用，不可單獨使用
getClass.getName(): 作用：獲取對象的全類名、帶包結構的類名. 即包名 + 類名組成的字符串（會消除最前方的class）
例: com.study.day0416.Student
(2)hashCode()
作用:返回該對象的哈希碼值。
哈希值: 將對象的地址進行哈希算法的計算得到的一個整數值 這個值叫做哈希值
hashCode方法的實現不是Java語言實現的 是一個本地方法
(3)Integer.toHexString(int a)
作用：將一個10進制的整數 轉換為16進制的數
特點
1、在實際開發中一般遵從重寫原則
2、直接打印對象的引用，就是打印的是對象調用toString方法后返回的字符串的值。
案例
重寫前
package com.study.day14;
public class Demo2 {
public static void main(String[] args) {
//創建一個學生對象
Student s1 = new Student("老王",16);
System.out.println(s1);//com.study.day14.Student @ 1b6d3586
System.out.println(s1.toString());
// getClass().getName() + '@' + Integer.toHexString(hashCode())
String s = s1.toString();
System.out.println(s);
//com.ujiuye.day14.Student ---> 對象的全類名 帶包結構的類名
Class aClass = s1.getClass();//獲取的是 student類的 字節碼對象 就是 Class 類 的對象
//aClass 對象中 存儲了 關於 學生類中所有的屬性名 類名 包名 構造方法名 構造方法 .....
String name = aClass.getName();//獲取 包名 + 類名組成的字符串
System.out.println(name);//全類名
// Integer.toHexString(hashCode())
//hashCode() ---> 將對象的地址進行哈希算法的計算得到的一個整數值 這個值叫做哈希值 hashCode方法的實現不是Java語言實現的 是一個本地方法
int hash = s1.hashCode();//int類型值 哈希值 -2147483648 --- 2147483647
System.out.println(hash);//460141958
//Integer.toHexString(int a)
//將一個10進制的整數 轉換為16進制的數
String s2 = Integer.toHexString(460141958);
System.out.println(s2);//1b6d3586
String result = name+"@"+s2;
System.out.println(result);//com.study.day14.Student@1b6d3586
}
}
class Student{
String name;
int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
重寫后
package com.study.day14;
public class Demo2 {
public static void main(String[] args) {
//創建一個學生對象
Student s1 = new Student("老王",16);
System.out.println(s1);
}
}
class Student{
String name;
int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//重寫toString方法
// @Override
// public String toString() {
// return "姓名:"+this.name+" 年齡:"+this.age;
// }
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
equals()
作用
判斷兩個對象是否相等
特點
1、在實際開發中重寫原則
2、比較兩個對象的所有屬性/部分屬性 是否全部相同
步驟：
（1）判斷兩個引用是否相同
（2）判斷obj是否為空
（3）判斷兩個引用的類型是否相同
（4）向下轉型
（5）判斷屬性是否相同
== 和 equals 方法的區別
簡單數據類型
1. == 可以判斷兩個簡單數據類型的值是否相等
2. equals方法不能用於簡單數據類型
引用數據類型
1. == 可以判斷兩個引用中的地址是否相同
2. equals方法在重寫之前和 == 一樣，重寫之后判斷的是兩個對象的內容屬性是否相同
案例
//案例1:
package com.study.day14;
public class Demo2 {
public static void main(String[] args) {
//創建學生對象
Student s1 = new Student("老王",15,100);
Student s2 = s1;
//Student s2 = new Student("老王",15,100);
// Student s2 = null;
//Dog s2 = new Dog();
//System.out.println(s1 == s2);//判斷的是s1中的地址 和 s2中的地址是否相等
// == 在引用數據類型中 不能判斷兩個對象是否是同一個對象
System.out.println(s1.equals(s2));//使用的是 Object 繼承下來的 你沒有給我標准
}
}
class Student{
String name;
int age;
int code;//學號 唯一 不會重復
public Student() {
}
public Student(String name, int age,int code) {
this.name = name;
this.age = age;
this.code = code;
}
//重寫toString方法
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//重寫equals 方法
@Override
public boolean equals(Object o) {
// 1判斷兩個引用的地址是否相同
if (this == o){
return true;
}
//2 判斷 o 是否為空
if (o == null){
return false;
}
//3 判斷這兩個引用中存放的對象是否是同一個類型
if (this.getClass() != o.getClass()){
return false;
}
// 4 向下轉型
Student s = (Student) o;
//this s
if (this.code == s.code){
return true;
}else{
return false;
}
}
}
class Dog{
}
//案例2:
package com.study.day14;
public class Demo2 {
public static void main(String[] args) {
//創建學生對象
Student s1 = new Student("老王",15,100);
Student s2 = s1;
System.out.println(s1.equals(s2));//使用的是 Object 繼承下來的 你沒有給我標准
}
}
class Student{
String name;
int age;
int code;//學號 唯一 不會重復
public Student() {
}
public Student(String name, int age,int code) {
this.name = name;
this.age = age;
this.code = code;
}
//重寫toString方法
// @Override
// public String toString() {
// return "姓名:"+this.name+" 年齡:"+this.age;
// }
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//重寫equals 方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && code == student.code && name.equals(student.name);
}
}
finalize()
作用
當垃圾回收器確定不存在對該對象的更多引用時，由對象的垃圾回收器調用此方法。
一般語法：
Object的子類可重寫此方法
案例
package com.study.day14;
public class Demo5 {
public static void main(String[] args) {
Test test = new Test();//不是垃圾
test = null;//test不指向 對象 new Test()沒有引用指向它了 就成為垃圾 到達一定的程度 垃圾回收器會進行回收
//通知進行垃圾回收
System.gc();
//當垃圾被回收了 調用finalize方法
// for (int i = 0; i < 10000000; i++) {
// new Test();//100個垃圾
// }
}
}
class Test extends Object{
//重寫
@Override
protected void finalize() throws Throwable {
System.out.println("我被調用了 垃圾被回收了");
super.finalize();
}
}