object常用的方法

A. 面試問題java Object類有哪些方法

構造方法，用來初始化對象的時候用的，
toString()以字元串的形式返回；
equals 比較的是對象的引用地址的值

B. 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()
這個函數在進行垃圾回收的時候會用到，匿名對象回收之前會調用到，具體的例子如圖所示

C. Java語言中Object類定義了哪11種方法

Java中所有類（包括用戶自己定義的類）都自動繼承Object類，即Object類是所有類的父類。

Object中常用方法：

public boolean equals（Object obj）

比較當前對象與obj是否為同一對象，返回值：ture/false

public 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)); //truex1行
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。

D. java中Object... 的用法是什麼意思

居然 整個樓裡面都答非所問了 看我的看我的哦 提問者都說的這么清楚了

這個問題很好

日常使用不定參數時候基本是Object...可以等同於Object[] obj一維數組理解的

數組本質是連續的指針地址 其中數組的頭指針是必須的 但是二者的不同在於何處呢？

很明顯
Obj...是針對方法傳入參數的 即只能在method（）內使用

即 不定參數只能作為方法的形參，不能用作變數

然後你看我建立2個test犯法

java的 數組結構在jvm的堆和棧上是不同的 但是我個人沒有理解這問題如果提問者了解歡迎回復我

有關不定參數的使用

public viod method(Object[] obj,Object...) {

Obj操了自己；

}

不過，不定參數有兩個規定：第一，方法的參數列表中最多隻有一個不定長度的參數；第二，就是不定長度的數組的位置必須是最後一個參數。不然不能通過編譯。

E. 請描述object中有哪些方法及其作用

查看一下API講解object的部分吧，這是一個超類，所有的類都是該類的子類。 超類，意思就是所有類的父類，有equals()、hashCode()、wait()、toString()等方法

F. python object 有哪些方法

調用這個方法將返回包含obj大多數屬性名的列表（會有一些特殊的屬性不包含在內）。obj的默認值是當前的模塊對象。
hasattr(obj, attr):
這個方法用於檢查obj是否有一個名為attr的值的屬性，返回一個布爾值。
getattr(obj, attr):
調用這個方法將返回obj中名為attr值的屬性的值，例如如果attr為』bar』，則返回obj.bar。
setattr(obj, attr, val):
調用這個方法將給obj的名為attr的值的屬性賦值為val。例如如果attr為』bar』，則相當於obj.bar = val。

G. Object下有哪些方法

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方法

該方法喚醒在該對象上等待的所有線程。

H. 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年的砌匠不知道前後梁有多少瓴子（魯班收徒的故事），您會怎麼想？

I. 面試題：簡述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

J. java object 有哪些方法

Java.lang.object類中有幾個方法不是final的，我們會經常用重寫它們，
protected Object clone() 創建並返回此對象的一個副本。
boolean equals(Object obj) 指示某個其他對象是否與此對象「相等」。
protected void finalize() 當垃圾回收器確定不存在對該對象的更多引用時，由對象的垃圾回收器調用此方法。
int hashCode() 返回該對象的哈希碼值。
String toString() 返回該對象的字元串表示。
1、clone()
我們為什麼要用clone()?
當我們需要一個與某個對像時一模一樣的對像時，但它們又是相互獨立的，對它們各自的操作不會影響到另外的一個，這時候用clone()就可以
實現，當然，其他的方法也可以實現，但是重寫clone()簡單，高效
有一個不沒重寫clone()的例子，能幫助我們更好的去理解clone(),如下：
public class Test
{
public static void main(String[] args){
A a1=new A();
A a2=new A();
a1.name="a1";
a2=a1;
a2.name="a2";
System.out.println("a1.name="+a1.name);
System.out.println("a2.name="+a2.name);

}

}
class A
{
public String name;

}
輸出結果為：a1.name=a2;
a2.name=a2;
下面這個是重寫了clone()的例子
public class Test
{
public static void main(String[] args) throws CloneNotSupportedException {
A a1=new A();
A a2=new A();
a1.name="a1";
a2=(A) a1.clone();
a2.name="a2";
System.out.println("a1.name="+a1.name);
System.out.println("a2.name="+a2.name);

}