Ⅰ object類方法
Object類有12個成員方法，按照用途可以分為以下幾種
1，構造函數
2，hashCode和equale函數用來判斷對象是否相同,
3，wait(),wait(long),wait(long,int),notify(),notifyAll()
4，toString()和getClass,
5，clone()
6，finalize()用於在垃圾回收
函數說明
clone()
clone()函數的用途是用來另存一個當前存在的對象。
hashCode()和equale()
equale()用於確認兩個對象是否相同。
hashCode()用於獲取對象的哈希值，這個值的作用是檢索，具體的作用可以參考這里
哈希值相同的對象不一定equale()
equale()返回true的兩個對象一定相同。
toString()和getClass()
toString()返回一個String對象，用來標識自己
getClass()返回一個Class對象，如果列印出來會發現結果是如下格式
class package.name.xxx
1
因為返回的是一個class對象,後面可以跟class類的方法。用的是誰的構造函數，那麼getClass返回的就是誰的類型。
getClass()經常用於java反射機制
wait(),wait(long),wait(long,int),notify(),notifyAll()
這幾個函數體現的是Java的多線程機制
在使用的時候要求在synchronize語句中使用
wait()用於讓當前線程失去操作許可權，當前線程進入等待序列
notify()用於隨機通知一個持有對象的鎖的線程獲取操作許可權
notifyAll()用於通知所有持有對象的鎖的線程獲取操作許可權
wait(long) 和wait(long,int)用於設定下一次獲取鎖的距離當前釋放鎖的時間間隔
finalize()
這個函數在進行垃圾回收的時候會用到，匿名對象回收之前會調用到，具體的例子如圖所示
Ⅱ 面試問題java Object類有哪些方法
構造方法，用來初始化對象的時候用的，
toString()以字元串的形式返回；
equals 比較的是對象的引用地址的值
Ⅲ 面試題：簡述object類9個方法的作用
簡介： Java克隆(Clone)是Java語言的特性之一，但在實際中應用比較少見。但有時候用克隆會更方便更有效率。 對於克隆(Clone)，Java有一些限制： 1、被克隆的類必須自己實現Cloneable 介面，以指示 Object.clone() 方法可以合法地對該類實例進行按欄位復制。Cloneable 介面實際上是個標識介面，沒有任何介面方法。 2、實現Cloneable介面的類應該使用公共方法重寫 Object.clone（它是受保護的）。 3、在Java.lang.Object類中克隆方法是這么定義的： protected Object clone() throws CloneNotSupportedException 創建並返回此對象的一個副本。表明是一個受保護的方法，同一個包中可見。 按照慣例，返回的對象應該通過調用 super.clone 獲得。 引題： 舉個例子說吧，現在有一個對象比如叫foo，你需要在創建當前對象的一個副本作為存根你能怎麼做？ 假如你不用Clone，那麼你可以先new一個對象foo1： Foo foo1=new Foo(), 然後用foo給foo1對象set值，這樣就得到foo的副本foo1；除此之外，別無選擇。 這樣說，也許有人會覺得說的過於絕對了，不過事實如此啊。 要產生一個副本，那副本要不要內存？----當然要了，那就對了！既然需要內存，（不克隆的情況下）你不new還有什麼辦法呢？請大家時刻銘記對象是Java運行時產生的，駐留在計算機內存中。 常見錯誤： 下面我澄清幾個初學者容易犯迷糊的錯誤，同樣的問題，產生foo對象的副本： 1、Foo foo1=new Foo(); foo1=foo; 然後就想當然的認為副本foo1生成了！ 錯誤原因：foo1沒錯是申請了內存，但是執行foo1=foo後，foo1就不在指向剛申請的內存區域了，轉而指向foo對象的內存區域，這時候，foo1、foo指向了同一內存區域。剛才new的操作製造一堆垃圾等著JVM回收。 2、Foo foo1=foo; 錯誤原因：還是兩個變數都指向了同一塊內存。 3、有些老鳥更厲害一些：在Foo中定義一個返回自身的方法： public Foo getInstance(){ return this; } 然後，Foo foo1=foo.getInstance(); 錯誤原因：同上，主要還是沒有重新開辟內存，this在對象里是什麼？----就是對象自己的引用！那麼getInstance()自然返回的就是對象自己，反正又是兩個對象穿了一條褲子----***，哈哈。錯得心服口服吧。為了節省篇幅，我在最後寫個例子，留給那些對此有異議的人看。 引入克隆 看了這么多方法都不行，還很麻煩！乾脆用克隆吧，簡單明了。 廢話不說了，看例子： 定義兩個類CloneFooA、CloneFooB，然後寫個測試類CloneDemo分別克隆這兩個類的對象，然後列印測試結果到控制台。 /** * Created by IntelliJ IDEA. * User: leimin * Date: 2007-9-20 * Time: 19:40:44 * 簡單類克隆實現 * 要實現克隆,必須實現Cloneable介面,這是一個標識介面,沒有介面方法 * 實現了 Cloneable 介面，以指示 Object.clone() 方法可以合法地對該類實例進行按欄位復制。 * 按照慣例，實現此介面的類應該使用公共方法重寫 Object.clone（它是受保護的）。 */ public class CloneFooA implements Cloneable { private String strA; private int intA; public CloneFooA(String strA, int intA) { this.strA = strA; this.intA = intA; } public String getStrA() { return strA; } public void setStrA(String strA) { this.strA = strA; } public int getIntA() { return intA; } public void setIntA(int intA) { this.intA = intA; } /** * @return 創建並返回此對象的一個副本。 * @throws CloneNotSupportedException */ public Object clone() throws CloneNotSupportedException { //直接調用父類的clone()方法,返回克隆副本 return super.clone(); } } /** * Created by IntelliJ IDEA. * User: leimin * Date: 2007-9-20 * Time: 19:59:55 * 深度克隆對象,當類存在聚合關系的時候,克隆就必須考慮聚合對象的克隆 */ public class CloneFooB implements Cloneable { private CloneFooA fooA; private Double douB; public CloneFooB(Double douB) { this.douB = douB; } public CloneFooB(CloneFooA fooA, Double douB) { this.fooA = fooA; this.douB = douB; } public CloneFooA getFooA() { return fooA; } public void setFooA(CloneFooA fooA) { this.fooA = fooA; } public Double getDouB() { return douB; } public void setDouB(Double douB) { this.douB = douB; } /** * 克隆操作 * * @return 自身對象的一個副本 * @throws CloneNotSupportedException */ public Object clone() throws CloneNotSupportedException { //先調用父類的克隆方法進行克隆操作 CloneFooB cloneFooB = (CloneFooB) super.clone(); //對於克隆後出的對象cloneFooB,如果其成員fooA為null,則不能調用clone(),否則出空指針異常 if (this.fooA != null) cloneFooB.fooA = (CloneFooA) this.fooA.clone(); return cloneFooB; } } /** * Created by IntelliJ IDEA. * User: leimin * Date: 2007-9-20 * Time: 19:52:01 * 測試類：分別克隆CloneFooA和CloneFooB類,並列印克隆前後的結果. */ public class CloneDemo { public static void main(String args[]) throws CloneNotSupportedException { //CloneFooA克隆前 CloneFooA fooA1 = new CloneFooA("FooA", 11); System.out.println("CloneFooA的對象克隆前對象fooA1值為: " + fooA1.getStrA() + "," + fooA1.getIntA()); //CloneFooA克隆後 CloneFooA fooA2 = (CloneFooA) fooA1.clone(); System.out.println("CloneFooA的對象克隆後對象fooA2值為: " + fooA2.getStrA() + "," + fooA2.getIntA()); //比較fooA1和fooA2內存地址 if (fooA1 == fooA2) System.out.println("比較fooA1和fooA2內存地址:相等!"); else System.out.println("比較fooA1和fooA2內存地址:不相等!"); System.out.println("-------------------------"); //CloneFooB克隆前 CloneFooB fooB1 = new CloneFooB(fooA1, new Double("33")); System.out.println("CloneFooB的對象克隆前對象fooB1值為: " + fooB1.getFooA().getStrA() + "," + fooB1.getFooA().getIntA() + " | " + fooB1.getDouB()); //CloneFooB克隆後 CloneFooB fooB2 = (CloneFooB) fooB1.clone(); System.out.println("CloneFooB的對象克隆前對象fooB2值為: " + fooB2.getFooA().getStrA() + "," + fooB2.getFooA().getIntA() + " | " + fooB2.getDouB()); if (fooA1 == fooA2) System.out.println("比較fooB1和fooB2內存地址:相等!"); else System.out.println("比較fooB1和fooB2內存地址:不相等!"); } } 運行結果： CloneFooA的對象克隆前對象fooA1值為: FooA,11 CloneFooA的對象克隆後對象fooA2值為: FooA,11 比較fooA1和fooA2內存地址:不相等! ------------------------- CloneFooB的對象克隆前對象fooB1值為: FooA,11 | 33.0 CloneFooB的對象克隆前對象fooB2值為: FooA,11 | 33.0 比較fooB1和fooB2內存地址:不相等! Process finished with exit code 0 反面教材： 最後，我給出我上面提出到最後要給出的反面例子。 隨便寫一個，在CloneFooA 的基礎上做了少許改動，內容如下： public class CloneFooA implements Cloneable { private String strA; private int intA; public CloneFooA(String strA, int intA) { this.strA = strA; this.intA = intA; } public String getStrA() { return strA; } public void setStrA(String strA) { this.strA = strA; } public int getIntA() { return intA; } public void setIntA(int intA) { this.intA = intA; } /** * @return 創建並返回此對象的一個副本。 * @throws CloneNotSupportedException */ public Object clone() throws CloneNotSupportedException { //直接調用父類的clone()方法,返回克隆副本 return super.clone(); } /** * @return 返回運行時的對象 */ public CloneFooA getInstance(){ return this; } public static void main(String args[]){ CloneFooA fooA=new CloneFooA("aa",11); System.out.println(fooA.getStrA()+" "+fooA.getIntA()); CloneFooA fooA1=fooA.getInstance(); System.out.println(fooA1.getStrA()+" "+fooA1.getIntA()); if(fooA==fooA1) System.out.println("fooA和fooA1內存地址相等!"); System.out.println("-------------------------"); //改變後fooA或者fooA1中任何一個,看看另外一個是否會改變 fooA1.setStrA("bb"); System.out.println(fooA.getStrA()+" "+fooA.getIntA()); System.out.println(fooA1.getStrA()+" "+fooA1.getIntA()); if(fooA==fooA1) System.out.println("fooA和fooA1內存地址相等,改變fooA1後,fooA的值也跟著變化了"); } } 運行結果： aa 11 aa 11 fooA和fooA1內存地址相等! ------------------------- bb 11 bb 11 fooA和fooA1內存地址相等,改變fooA1後,fooA的值也跟著變化了 Process finished with exit code 0
Ⅳ Java object類中有哪些方法歸類總結一下
試問的最多的問題是：「」。一般情況下，3年以上工作經驗的回答少於6個方法的，會導致減分，2年以下工作經驗的知道6個以上會加分。到阿里雲後面試過30+，回答讓我滿意的人很少。 作為一個半路出家當程序員，開始我總是痴迷於應用。a框架的配置，b框架的模板，c框架的控制……其實我對Java底層了解的很少，也沒有想過了解java的底層。觸動我去看Object類的是幾件事。 在上個東家做消息全網傳輸的時候，我用BeanUtil.Properties()拷貝對象的值，覺得很爽，後面某同事review我的代碼提示我可以覆寫對象的clone()方法的，畢竟，反射的效率是比較低的。然後當我去做的時候，發現了更好的選擇。然後在列印日誌的時候，我習慣拼接屬性，於是又被提示覆寫toString()方法是包爽的，就這樣，我認識了Object的2個方法。 看《Effecive Java》這本書，中間提到「為什麼覆寫equals()方法的時候總是要覆寫hashcode()」。開始第一遍沒有看懂，也懶得管了，因為hashcode我用的少，後來去參加一個面試，被人問到的時候，感覺無比的尷尬，我讀過，卻不知道答案！這是個人總結能力的問題，後面又不能不回來仔細看看這2個方法到底是做什麼的。 關於線程的notify() ， notifyAll() ， wait()『3個』 方法，學習線程的時候看過，不過自從用了JUC的包，我基本沒有在代碼中使用過了。每次用eclipse的「alt + /」 快捷鍵從後翻總能看到，所以無論如何，這幾個方法應該知道。 寫到這里，有7個方法了，這幾個方法很容易想到，在我開發java2年後，能夠回答Object類中的7個方法。其實clone()方法不常用，所以，我 說的數字6是有依據的。這6個方法，作為java程序員，天天不見也會見幾次。如果寫了幾年java代碼不知道基類裡面的方法，就算你Hbase玩的再 熟，我憑什麼相信你能寫優質代碼？如果一個在農村蓋房子3年的砌匠不知道前後梁有多少瓴子（魯班收徒的故事），您會怎麼想？
Ⅳ 2020-09-10：java里Object類有哪些方法
Java Object類是所有類的父類，主要方法有：
getClass（）：獲取運行時類型,返回值為Class對象
2.hashCode（）：返回該對象的哈希碼值，是為了提高哈希表的性能（HashTable）
3.equals（）：判斷兩個對象是否相等，在Object源碼中equals就是使用==去判斷，所以在Object中equals是等價於==的，但是在String及某些類對equals進行了重寫，實現不同的比較。
4.clone（）：JAVA里除了8種基本類型傳參數是值傳遞，其他的類對象傳參數都是引用傳遞，我們有時候不希望在方法里講參數改變，這是就需要在類中復寫clone方法。此方法只實現了一個淺層拷貝,對於基本類型欄位成功拷貝,對嵌套對象,只把地址拷貝了,需要自己重寫clone方法進行深度拷貝。
5.toString（）：返回一個String字元串,用於描述當前對象的信息,可以重寫返回對自己有用的信息，默認返回的是當前對象的類名+hashCode的16進制數字。
6.wait（）：多線程時用到的方法，作用是讓當前線程進入等待狀態，同時也會讓當前線程釋放它所持有的鎖。直到其他線程調用此對象的 notify() 方法或 notifyAll() 方法，當前線程被喚醒
7.notify（）：多線程時用到的方法，喚醒該對象等待的某個線程
8.notifyAll（）：多線程時用到的方法，喚醒該對象等待的所有線程
9.finalize（）：對象在被GC釋放之前調用finalize方法。
你明白了嗎？
Ⅵ object類的六個方法都有什麼分別是什麼意思有什麼用途
protected Object clone()
創建並返回此對象的一個副本。
boolean equals(Object obj)
指示其他某個對象是否與此對象「相等」。
protected void finalize()
當垃圾回收器確定不存在對該對象的更多引用時，由對象的垃圾回收器調用此方法。
Class<?> getClass()
返回此 Object 的運行時類。
int hashCode()
返回該對象的哈希碼值。
void notify()
喚醒在此對象監視器上等待的單個線程。
void notifyAll()
喚醒在此對象監視器上等待的所有線程。
String toString()
返回該對象的字元串表示。
void wait()
在其他線程調用此對象的 notify() 方法或 notifyAll() 方法前，導致當前線程等待。
void wait(long timeout)
在其他線程調用此對象的 notify() 方法或 notifyAll() 方法，或者超過指定的時間量前，導致當前線程等待。
void wait(long timeout, int nanos)
在其他線程調用此對象的 notify() 方法或 notifyAll() 方法，或者其他某個線程中斷當前線程，或者已超過某個實際時間量前，導
Ⅶ JAVA中Object類中 有幾個方法
Java中Object類Java基礎Java中所有類（包括用戶自己定義的類）都自動繼承Object類，即Object類是所有類的父類。Object中常用方法：public boolean equals（Object obj）比較當前對象與obj是否為同一對象，返回值：ture/falsepublic String toString（）返回當前對象的字元串表達形式public native int hashCode（）；返回對象的Hash碼。Hash碼是標志對象的唯一值，Hash碼相同的對象是同一對象protected void finalize（）throws Throwable對象銷毀時被調用以下三個函數用於控制線程public final native void notify（）；public final native void notifyAll（）；public final native void wait（）；native型方法指由C++語言編寫的方法，Java解釋器對其進行轉義後才執行。「==」與equals()"==" 一般用於基本數據類型比較。若用作兩個引用對象比較，僅當引用變數引用同一個對象時，才返回true,否則false。 void EqualCompare()
{
String s1 = new String("Hello");
String s2 = new String("Hello");
String s3 = "Hello";
String s4 = "Hello"; //未使用new，s4引用既存的對象（編譯器創建對象之前先進行檢測"Hello"是否已經存在，若存在，則返回原對象的引用）
System.out.println(s1.equals(s2)); // true x1行
System.out.println(s1 ==s2); // false 兩變數引用不同對象
System.out.println(s3.equals(s4)); //true 兩變數引用相同對象
System.out.println(s3 ==s4); // true 兩變數引用相同對象
}比較對象時，一般用equal()方法。Object類方法定義：public boolean equals（Object obj）{ return （this == obj);}不同的類可方便的對該對象進行覆蓋。String類就覆蓋了Object類的equals()方法，所以x1行輸出true.a==b 如果a,b引用同一對象，則返回true；a.equals(b) 如果a對象內容和b對象內容相同，則返回true如果未重載equals（）方法的類對象使用該方法與另一個對象進行比較，則調用Object的equals()方法，仍然是對象的比較，返回值為false。
Ⅷ java里的object類裡面有什麼方法
查看一下API講解object的部分吧，這是一個超類，所有的類都是該類的子類。
超類，意思就是所有類的父類，有equals()、hashCode()、wait()、toString()等方法
Ⅸ java中object類中有哪些方法
java語言中Object是所有類的父類，任何類都默認繼承Object。Object類到底實現了哪些方法？
（1）clone方法
保護方法，實現對象的淺復制，只有實現了Cloneable介面才可以調用該方法，否則拋出CloneNotSupportedException異常。
（2）getClass方法
final方法，獲得運行時類型。
（3）toString方法
該方法用得比較多，一般子類都有覆蓋。
（4）finalize方法
該方法用於釋放資源。因為無法確定該方法什麼時候被調用，很少使用。
（5）equals方法
該方法是非常重要的一個方法。一般equals和==是不一樣的，但是在Object中兩者是一樣的。子類一般都要重寫這個方法。
（6）hashCode方法
該方法用於哈希查找，重寫了equals方法一般都要重寫hashCode方法。這個方法在一些具有哈希功能的Collection中用到。
一般必須滿足obj1.equals(obj2)==true。可以推出obj1.hash- Code()==obj2.hashCode()，但是hashCode相等不一定就滿足equals。不過為了提高效率，應該盡量使上面兩個條件接近等價。
（7）wait方法
wait方法就是使當前線程等待該對象的鎖，當前線程必須是該對象的擁有者，也就是具有該對象的鎖。wait()方法一直等待，直到獲得鎖或者被中斷。wait(long timeout)設定一個超時間隔，如果在規定時間內沒有獲得鎖就返回。
調用該方法後當前線程進入睡眠狀態，直到以下事件發生。
（1）其他線程調用了該對象的notify方法。
（2）其他線程調用了該對象的notifyAll方法。
（3）其他線程調用了interrupt中斷該線程。
（4）時間間隔到了。
此時該線程就可以被調度了，如果是被中斷的話就拋出一個InterruptedException異常。
（8）notify方法
該方法喚醒在該對象上等待的某個線程。
（9）notifyAll方法
該方法喚醒在該對象上等待的所有線程。
Ⅹ 簡要說明object類有什麼特點
Object類是所有類的父類，聲明一個Object類的作用就是可以傳遞任何類型的類來使用。
Object是所有類的父類，它有很多類對象會用到的方法，例如比較常用的toString 、equals，當你新建xx類時，你可以重寫Object已經定義的方法，也可以直接調用Object中的方法，如果你寫一個封裝的方法，不確定傳進來的是什麼類型的值，就可以使用Object作為一個籠統類