如何理解根父類

類java.lang.Object是類層次結(jié)構(gòu)的根類，即所有其它類的父類。每個(gè)類都使用Object作為超類。

• Object類型的變量與除Object以外的任意引用數(shù)據(jù)類型的對(duì)象都存在多態(tài)引用

method(Object obj){…} //可以接收任何類作為其參數(shù)
Person o = new Person();  
method(o);

• 所有對(duì)象（包括數(shù)組）都實(shí)現(xiàn)這個(gè)類的方法
• 一個(gè)類沒有特別指定父類，那么默認(rèn)則繼承自O(shè)bject類

public class Person {
	...
}
//上面和下面是等價(jià)的
public class Person extends Object {
	...
}

Object類的方法

根據(jù)JDK源代碼及Object類的API文檔，Object類中包含的方法有11個(gè)，但是今天只看其中主要的5個(gè)。

equals()

所有類都繼承了Object，那么也就獲得了equals()方法，且還可以重寫方法。 equals()：

• 只能比較引用類型，比較是否指向同一個(gè)對(duì)象
• 格式：obj1.equals(obj2)
• 特例：當(dāng)用equals()方法進(jìn)行比較時(shí)，對(duì)類File、String、Date及包裝類來說，是比較類型及內(nèi)容而不考慮引用的是否是同一個(gè)對(duì)象，因?yàn)樵谶@些類中重寫了Object類的equals()方法
• 當(dāng)自定義equals()方法時(shí)，可以重寫方法，用來比較兩個(gè)對(duì)象的內(nèi)容是否一樣

重寫equals()方法的原則：

• 對(duì)稱性：如果x.equals(y)返回是true，那么y.equals(x)也應(yīng)該返回是true
• 自反性：x.equals(x)必須返回是true
• 傳遞性：如果x.equals(y)返回是true，且y.equals(z)返回是true，那么z.equals(x)也應(yīng)該返回true
• 一致性：如果x.equals(y)返回是true，只要x和y內(nèi)容不變，無論重復(fù)x.equals(y)多少次，都是返回true
• 任何情況下，x.equals(null)都是返回false，x.equals(和x是不同類型的對(duì)象)都是返回false

重寫舉例:

class User{
	private String host;
	private String username;
	private String password;
	public User(String host, String username, String password) {
		super();
		this.host = host;
		this.username = username;
		this.password = password;
	}
	public User() {
		super();
	}
	public String getHost() {
		return host;
	}
	public void setHost(String host) {
		this.host = host;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	@Override
	public String toString() {
		return "User [host=" + host + ", username=" + username + ", password=" + password + "]";
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (host == null) {
			if (other.host != null)
				return false;
		} else if (!host.equals(other.host))
			return false;
		if (password == null) {
			if (other.password != null)
				return false;
		} else if (!password.equals(other.password))
			return false;
		if (username == null) {
			if (other.username != null)
				return false;
		} else if (!username.equals(other.username))
			return false;
		return true;
	}
}

= =：

• 基本類型比較的是值：只要兩個(gè)變量的值相等，即為true
• 引用類型比較引用(是否指向同一個(gè)對(duì)象)：只有指向同一個(gè)對(duì)象時(shí)，才返回true

注意： 用來進(jìn)行比較時(shí)，符號(hào)兩邊的數(shù)據(jù)類型必須兼容（可自動(dòng)轉(zhuǎn)換的基本數(shù)據(jù)類型除外），否則編譯報(bào)錯(cuò)。

= =和equals的區(qū)別：

• = =即可以比較基本數(shù)據(jù)類型也可以比較引用類型，對(duì)于基本類型就是比較數(shù)值，對(duì)于引用類型就是比較內(nèi)存地址
• equals是屬于java.lang.Object類里面的方法，如果該方法沒有被重寫，默認(rèn)也是= =，String等類的equals方法是被重寫過的，而且String類在日常開發(fā)中用的較多，形成了equals是比較值的錯(cuò)誤觀點(diǎn)，這點(diǎn)要注意
• 具體要看自定義類型里有沒有重寫Object的equals方法來判斷
• 通常情況下，重寫equals方法，會(huì)比較類中的相應(yīng)屬性是否都相等

toString()

public String toString()：默認(rèn)情況下toString()返回的是對(duì)象的運(yùn)行時(shí)類型@對(duì)象的hashCode值的十六進(jìn)制形式。

在進(jìn)行String與其他類型數(shù)據(jù)的連接操作時(shí)，自動(dòng)調(diào)用toString方法，比如：

Date now=new Date();
System.out.println("now="+now); //相當(dāng)于"now="+now.toString()

如果直接打印對(duì)象，默認(rèn)會(huì)調(diào)用該對(duì)象的toString()方法（Java的引用數(shù)據(jù)類型的變量中存儲(chǔ)的實(shí)際上是對(duì)象的內(nèi)存地址，但是Java對(duì)外隱藏了內(nèi)存地址信息，所以不能直接將內(nèi)存地址顯示出來，所以當(dāng)打印對(duì)象時(shí)，JVM會(huì)調(diào)用對(duì)象的toString()方法）。

可以根據(jù)需要在用戶自定義類型中重寫toString()方法。

getClass()

public final Class<?> getClass()：獲取對(duì)象的運(yùn)行時(shí)類型。

由于Java有多態(tài)現(xiàn)象，所以一個(gè)引用數(shù)據(jù)類型的變量編譯時(shí)類型與運(yùn)行時(shí)類型可能不一致，因此如果需要查看這個(gè)變量實(shí)際指向的對(duì)象的類型，就需要用getClass()方法。

public static void main(String[] args) {
	Object obj = new Person();
	System.out.println(obj.getClass()); //獲取運(yùn)行時(shí)類型
}

hashCode()

public int hashCode()：返回每個(gè)對(duì)象的hash值。

如果重寫equals，那么通常會(huì)一起重寫hashCode()方法，hashCode()方法主要是為了當(dāng)對(duì)象存儲(chǔ)到哈希表等容器中時(shí)提高存儲(chǔ)和查詢性能用的，這是因?yàn)殛P(guān)于hashCode()有兩個(gè)常規(guī)協(xié)定：

• 如果兩個(gè)對(duì)象的hash值不同，那么這兩個(gè)對(duì)象一定不相等
• 如果兩個(gè)對(duì)象的hash值是相同的，那么這兩個(gè)對(duì)象不一定相等

重寫equals()和hashCode()方法時(shí)，要保證滿足如下要求：

• 如果兩個(gè)對(duì)象調(diào)用equals返回true，那么要求這兩個(gè)對(duì)象的hashCode值一定是相等的
• 如果兩個(gè)對(duì)象的hashCode值不同，那么要求這兩個(gè)對(duì)象調(diào)用equals方法一定是false
• 如果兩個(gè)對(duì)象的hashCode值相同，那么這兩個(gè)對(duì)象調(diào)用equals可能是true，也可能是false

public static void main(String[] args) {
	System.out.println("Aa".hashCode()); //2112
	System.out.println("BB".hashCode()); //2112
}

clone()

clone()方法將對(duì)象復(fù)制了一份并返回給調(diào)用者，clone()的作用在于復(fù)制對(duì)象，在復(fù)制對(duì)象的過程中，首先要分配一個(gè)和源對(duì)象同樣大小的空間，在這個(gè)空間中創(chuàng)建一個(gè)新的對(duì)象。

示例：

public class CloneTest {
	public static void main(String[] args) {
		Animal a1 = new Animal("小黑");
		try {
			Animal a2 = (Animal) a1.clone();
			System.out.println("原始對(duì)象：" + a1);
			a2.setName("小黃");
			System.out.println("clone的對(duì)象：" + a2);
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}
}
class Animal implements Cloneable{
	private String name;
	public Animal() {
		super();
	}
	public Animal(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Animal [name=" + name + "]";
	}
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

finalize()

當(dāng)對(duì)象被回收時(shí)，系統(tǒng)自動(dòng)調(diào)用該對(duì)象的finalize()方法，子類可以重寫該方法，做一些釋放資源的操作。如果重寫該方法，讓一個(gè)新的引用變量重新引用該對(duì)象，則會(huì)重新激活對(duì)象。

永遠(yuǎn)不要主動(dòng)調(diào)用某個(gè)對(duì)象的finalize方法，應(yīng)該交給垃圾回收機(jī)制調(diào)用。

什么時(shí)候被回收：

當(dāng)某個(gè)對(duì)象沒有任何引用時(shí)，JVM就認(rèn)為這個(gè)對(duì)象是垃圾對(duì)象，就會(huì)在之后不確定的時(shí)間使用垃圾回收機(jī)制來銷毀該對(duì)象，在銷毀該對(duì)象前，會(huì)先調(diào)用finalize()方法（垃圾回收發(fā)生具有不可預(yù)知性，程序無法精確控制垃圾回收機(jī)制的執(zhí)行）。

垃圾回收機(jī)制的調(diào)用是由系統(tǒng)來決定的，也可以通過System.gc()或者Runtime.getRuntime().gc()來通知系統(tǒng)進(jìn)行垃圾回收，會(huì)有一些效果，但是系統(tǒng)是否進(jìn)行垃圾回收依然是不確定的。

public class FinalizeTest {
	public static void main(String[] args) {
		Person p = new Person("Peter", 12);
		System.out.println(p);
		p = null; //此時(shí)對(duì)象實(shí)體就是垃圾對(duì)象，等待被回收,但時(shí)間不確定
		System.gc();//強(qiáng)制性釋放空間
	}
}
class Person{
	private String name;
	private int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	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;
	}
	//子類重寫此方法，可在釋放對(duì)象前進(jìn)行某些操作
	@Override
	protected void finalize() throws Throwable {
		System.out.println("對(duì)象被釋放--->" + this);
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

native關(guān)鍵字的理解

使用native關(guān)鍵字說明這個(gè)方法是原生函數(shù)，也就是這個(gè)方法是用c/c++等非Java語言實(shí)現(xiàn)的，并且被編譯成了dll，由Java去調(diào)用，在定義一個(gè)native方法時(shí)，并不提供實(shí)現(xiàn)體。

為什么要用native方法

雖然Java使用起來非常方便，然而有些層次的任務(wù)用Java實(shí)現(xiàn)起來不易，或?qū)Τ绦虻男屎茉谝鈺r(shí)就會(huì)考慮native方法。

例如：有時(shí)Java應(yīng)用需要與Java外面的環(huán)境交互，這是本地方法存在的主要原因，當(dāng)Java需要與一些底層系統(tǒng)如操作系統(tǒng)或某些硬件交換信息時(shí)的情況，本地方法正是這樣的一種交流機(jī)制，它提供了一個(gè)非常簡(jiǎn)潔的接口，而且無需我們?nèi)チ私釰ava應(yīng)用之外的繁瑣細(xì)節(jié)。

native聲明的方法，對(duì)于調(diào)用者可以當(dāng)做其他Java方法一樣使用

一個(gè)native方法可以返回任何Java類型，包括非基本類型，而且同樣可以進(jìn)行異?？刂?。

native方法的存在并不會(huì)對(duì)其他類調(diào)用這些本地方法產(chǎn)生任何的影響，實(shí)際上調(diào)用這些方法的其他類甚至不知道它調(diào)用的是一個(gè)本地方法，JVM將控制調(diào)用本地方法的所有細(xì)節(jié)。

如果一個(gè)含有本地方法的類被繼承，子類會(huì)繼承這個(gè)本地方法并且可以用Java在需要的時(shí)候重寫該方法。

以上就是Java中Object類的理解和使用的詳細(xì)內(nèi)容，更多關(guān)于Java Object類的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

最新評(píng)論