javaclasstoobject
1. java中Object類是怎麼回事，幹嘛使的舉例說明！
Object類的作用：m a r k - t o- w i
n：在java中，因為所有的類都有共性，所以java的締造者們把java設計成這樣：所有的類都是Object類的直接或間接子類，而且把上述所有類
的共性都放在Object類中。這樣就可以達到代碼重用。All classes in java are subclasses of
Objectclass。
Object類的equals和toString的用法：
下面一組兩個例子，馬克-to-
win：第一個例子是用的父類Object的equals和toString方法，Object的equals是比較對象在內存當中的地址，當然不一樣
了。而Company的equals方法是自己寫的，比較的他們的name屬性，只要name一樣，對象的equals返回的就是真。另外，Object
的toString方法列印出來就是Company@1b67f74，這是Sun公司編的。而後面一個例子的toString方法時咱們自己編的。
例：2.1.1---本章源碼
class CompanyMark_to_win {
private String name;
CompanyMark_to_win(String name) {
this.name = name;
}
/*
public String toString() {
return name;
}
public boolean equals(Object o) {
if (!(o instanceof CompanyMark_to_win))
return false;
CompanyMark_to_win c = (CompanyMark_to_win) o;
return name.equals(c.name);。。。。。。。。。。。。。。。。。。。。。
更多詳情，請網上找「馬克-to-win」，參考他的網站或他的網路空間：java第三章的內容。
給個鏈接：http://tieba..com/p/3139989381
2. java中 this.getClass().getCLassLoder()是什麼意思
getClass()：取得當前對象所屬的Class對象
getClassLoader()：取得該Class對象的類裝載器
類裝載器負責從Java字元文件將字元流讀入內存，並構造Class類對象，在你說的問題哪裡，通過它可以得到一個文件的輸入流
getClass :
public final Class getClass()
Returns the runtime class of an object. That Class object is the object that is locked by static synchronized methods of the represented class.
Returns:
the object of type Class that represents the runtime class of the object.
getClassLoader
public ClassLoader getClassLoader()
Returns the class loader for the class. Some implementations may use null to represent the bootstrap class loader. This method will return null in such implementations if this class was loaded by the bootstrap class loader.
If a security manager is present, and the caller´s class loader is not null and the caller´s class loader is not the same as or an ancestor of the class loader for the class whose class loader is requested, then this method calls the security manager´s checkPermission method with a RuntimePermission("getClassLoader") permission to ensure it´s ok to access the class loader for the class.
If this object represents a primitive type or void, null is returned.
Returns:
the class loader that loaded the class or interface represented by this object.
Throws:
SecurityException - if a security manager exists and its checkPermission method denies access to the class loader for the class.
See Also:
ClassLoader, SecurityManager.checkPermission(java.security.Permission), RuntimePermission
Class.getClassLoader()的一個小陷阱：）
昨天我的code總在Integer.class.getClassLoader().getResource("*********");這一句拋出空指針異常，定位為getClassLoader()返回null，查了一下jdk的文檔，原來這里還有一個陷阱：
jdk中關於getClassLoader（）的描述：
/**
* Returns the class loader for the class. Some implementations may use
* null to represent the bootstrap class loader. This method will return
* null in such implementations if this class was loaded by the bootstrap
* class loader.
*
* <p> If a security manager is present, and the caller's class loader is
* not null and the caller's class loader is not the same as or an ancestor of
* the class loader for the class whose class loader is requested, then
* this method calls the security manager's <code>checkPermission</code>
* method with a <code>RuntimePermission("getClassLoader")</code>
* permission to ensure it's ok to access the class loader for the class.
*
* <p>If this object
* represents a primitive type or void, null is returned.
．．．．．
上面的英文可以用下面的話來理解：
裝載類的過程非常簡單：查找類所在位置，並將找到的Java類的位元組碼裝入內存，生成對應的Class對象。Java的類裝載器專門用來實現這樣的過程，JVM並不止有一個類裝載器，事實上，如果你願意的話，你可以讓JVM擁有無數個類裝載器，當然這除了測試JVM外，我想不出還有其他的用途。你應該已經發現到了這樣一個問題，類裝載器自身也是一個類，它也需要被裝載到內存中來，那麼這些類裝載器由誰來裝載呢，總得有個根吧？沒錯，確實存在這樣的根，它就是神龍見首不見尾的Bootstrap ClassLoader. 為什麼說它神龍見首不見尾呢，因為你根本無法在Java代碼中抓住哪怕是它的一點點的尾巴，盡管你能時時刻刻體會到它的存在，因為java的運行環境所需要的所有類庫，都由它來裝載，而它本身是C++寫的程序，可以獨立運行,可以說是JVM的運行起點,偉大吧。在Bootstrap完成它的任務後，會生成一個AppClassLoader(實際上之前系統還會使用擴展類裝載器ExtClassLoader，它用於裝載Java運行環境擴展包中的類),這個類裝載器才是我們經常使用的，可以調用ClassLoader.getSystemClassLoader() 來獲得，我們假定程序中沒有使用類裝載器相關操作設定或者自定義新的類裝載器，那麼我們編寫的所有java類通通會由它來裝載，值得尊敬吧。AppClassLoader查找類的區域就是耳熟能詳的Classpath，也是初學者必須跨過的門檻，有沒有靈光一閃的感覺，我們按照它的類查找范圍給它取名為類路徑類裝載器。還是先前假定的情況，當Java中出現新的類，AppClassLoader首先在類傳遞給它的父類類裝載器，也就是Extion ClassLoader，詢問它是否能夠裝載該類，如果能，那AppClassLoader就不幹這活了，同樣Extion ClassLoader在裝載時，也會先問問它的父類裝載器。我們可以看出類裝載器實際上是一個樹狀的結構圖，每個類裝載器有自己的父親，類裝載器在裝載類時，總是先讓自己的父類裝載器裝載(多麼尊敬長輩),如果父類裝載器無法裝載該類時，自己就會動手裝載，如果它也裝載不了，那麼對不起，它會大喊一聲：Exception，class not found。有必要提一句，當由直接使用類路徑裝載器裝載類失敗拋出的是NoClassDefFoundException異常。如果使用自定義的類裝載器loadClass方法或者ClassLoader的findSystemClass方法裝載類，如果你不去刻意改變，那麼拋出的是ClassNotFoundException。
這里jdk告訴我們：如果一個類是通過bootstrap 載入的，那我們通過這個類去獲得classloader的話，有些jdk的實現是會返回一個null的，比如說我用 new Object().getClass().getClassLoader()的話，會返回一個null，這樣的話上面的代碼就會出現NullPointer異常．所以保險起見我們最好還是使用我們自己寫的類來獲取classloader（"this.getClass().getClassLoader()「），這樣一來就不會有問題。
3. java中的toString()是什麼方法
toString
public String toString()返回該對象的字元串表示。通常，toString 方法會返回一個「以文本方式表示」此對象的字元串。結果應是一個簡明但易於讀懂。建議所有子類都重寫此方法。
Object 類的 toString 方法返回一個字元串，該字元串由類名（對象是該類的一個實例）、at 標記符「@」和此對象哈希碼的無符號十六進製表示組成。換句話說，該方法返回一個字元串，它的值等於：
getClass().getName() + '@' + Integer.toHexString(hashCode())
toString 是源自java Object類，在Object 內 定義為：返回 一個 類名@hashcode的字元串，可以overridden 用來返回 你認為有用的信息，
toStrng 沒有arguments
override：public String toString（）{
// insert you code
return "informations"
}
因為在java中 Object類是基類，所以每個類都會有toString方法。
System.out.println（Object）實際上就是調用 object的toString方法。
我們用的比較多的就是 String類的toString 方法，String類重寫了Object的toString方法，用於返回String的字元串值。
因為它是object裡面已經有了的方法，而所有類都是繼承object，所以「所有對象都有這個方法」
它通常只授姜了方便輸出，比如System.out.println(xx)，括弧裡面(_kuo4 hao4 li3 mian4)的「xx」如果不是String類型的話，就自動調用xx的toString()方法
總而言之，它只是sun公司開發java的時候為了方便所有類的字(de0 shi2 hou4 wei4 le0 fang1 bian4 suo3 you3 lei4 de0 zi4)符串操作而特意加入的一個方法
//toString改個名字試試看
}
A obj=new A();
System.out.println(obj);
會得到輸出:xxxx@xxxxxxx的類名加地址形式
System.out.println(obj.getString());
會得到輸出:this is A
toString的好處是在碰到「println」之類的輸出方法時會自動調用，不用顯式打出來
因為它是Object裡面已經有了的方法，而所有類都是繼承Object，所以「所有對象都有這個方法」。
它通常只是為了方便輸出，比如System.out.println(xx)，括弧裡面的「xx」如果不是String類型的話，就自動調用xx的toString()方法
總而言之，它只是sun公司開發java的時候為了方便所有類的字元串操作而特意加入的一個方法
回答補充：
寫這個方法的用途就是為了方便操作，所以在文件操作裡面可用可不用
例子1：
public class A{
public String toString(){return "this is A";}
}
如果某個方法裡面有如下句子：
A obj=new A();
System.out.println(obj);
會得到輸出:this is A
例子2：
public class A{
public String getString(){return "this is A";}//toString改個名字試試看
}
A obj=new A();
System.out.println(obj);
會得到輸出:xxxx@xxxxxxx的類名加地址形式
System.out.println(obj.getString());
會得到輸出:this is A
看出區別了嗎，toString的好處是在碰到「println」之類的輸出方法時會自動調用，不用顯式打出來。
toString()是重寫了父類Object的方法，目的是把該對象以字元串的形式表達出來，
一般的實體類都要重寫toString() 、equals()、hashCode()等方法方法,如User ,Student等實體類
如果一個類用來處理一些業務的就沒必要重寫toStirng()
在commons-lang包中都封裝了這些方法，
1）public boolean equals(Object obj){
return EqualsBuilder.reflectionEquals(this.obj);
}
2）public int hashCode(){
return HashCodeBuilder.reflectionHashCode(this);
}
3）public String toStirng(){
teturn ToStringBuilder.reflectionToString(this);
}
Object 類的 toString 方法返回一個字元串，該字元串由類名（對象是該類的一個實例）、at 標記符「@ 」和此對象哈希碼的無符號十六進製表示組成。換句話說，該方法返回一個字元串，它的值等於：
getClass().getName() + '@' + Integer.toHexString(hashCode())
例如：com.struts2.User@de6ced
而重寫該類的toString()方法後，將返回該類裡面的toString（）方法的返回值！
view plain to clipboardprint?
package com.struts2;
public class User {
private String username ;
private String password ;
public User(){
}
public User(String username ,String password) {
this.username=username ;
this.password= password ;
}
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;
}
public String toString(){
return this.username+this.password ;
}
public static void main(String[] args) {
System.out.println(new User("張三","123456"));
}
}
1．toString（）方法Object類具有一個toString()方法，你創建的每個類都會繼承該方法。它返回對象的一個String表示，並且對於調試非常有幫助。然而對於默認的toString()方法往往不能滿足需求，需要覆蓋這個方法。
toString（）方法將
1．toString（）方法Object類具有一個toString()方法，你創建的每個類都會繼承該方法。它返回對象的一個String表示，並且對於調試非常有幫助。然而對於默認的toString()方法往往不能滿足需求，需要覆蓋這個方法。
toString（）方法將對象轉換為字元串。看以下代碼：
package sample;
class Villain {
private String name;
protected void set(String nm) {
name = nm;
}
public Villain(String name) {
this.name = name;
}
public String toString() {
return "I'm a Villain and my name is " + name;
}
}
public class Orc extends Villain {
private int orcNumber;
public Orc(String name, int orcNumber) {
super(name);
this.orcNumber = orcNumber;
}
public void change(String name, int orcNumber) {
set(name);
this.orcNumber = orcNumber;
}
public String toString() {
return "Orc" + orcNumber + ":" + super.toString();
}
public static void main(String[] args) {
Orc orc = new Orc("Limburger", 12);
System.out.println(orc);
orc.change("Bob", 19);
System.out.println(orc);
}
}
結果：
[email protected]@11b86e7
如果去掉注釋，即加入2個toString（）方法後，得到
結果：
Orc12:I'm a Villain and my name is LimburgerOrc19:I'm a Villain and my name is Bob
2．在容器類中使用toString()
編寫一個工具類，用於在控制台輸出Iterator。
import java.util.Iterator;
public class Printer {
static void printAll(Iterator e){
while(e.hasNext()){
System.out.println(e.next());
}
}
}
在Hamster類中重寫父類的toString（）方法。
public class Hamster {
private int hamsterNumber;
public Hamster(int hamsterNumber){
this.hamsterNumber=hamsterNumber;
}
public String toString(){
return "This is Hamster #"+hamsterNumber;
}
}
在HamsterMaze類中使用容器類載入Hamster類對象並輸出結果。
import java.util.ArrayList;
import java.util.List;
public class HamsterMaze {
@SuppressWarnings("unchecked")
public static void main(String[] args){
List list=new ArrayList();
for(int i=0;i<3;i++)
list.add(new Hamster(i));
Printer.printAll(list.iterator());
}
}
結果：
This is Hamster #0This is Hamster #1This is Hamster #2
3．一個實現toString()的通用的Bean
在作一個項目時發現,許多bean需要實現toString()方法,就實現一個通用的bean,然後通過其他繼承即可。
import java.lang.reflect.Field;
public class BaseBean {
public String toString() {
StringBuffer sb = new StringBuffer();
try {
Class t = this.getClass();
Field[] fields = t.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
field.setAccessible(true);
sb.append("{");
sb.append(field.getName());
sb.append(":");
if (field.getType() == Integer.class) {
sb.append(field.getInt(this));
} else if (field.getType() == Long.class) {
sb.append(field.getLong(this));
} else if (field.getType() == Boolean.class) {
sb.append(field.getBoolean(this));
} else if (field.getType() == char.class) {
sb.append(field.getChar(this));
} else if (field.getType() == Double.class) {
sb.append(field.getDouble(this));
} else if (field.getType() == Float.class) {
sb.append(field.getFloat(this));
} else
sb.append(field.get(this));
sb.append("}");
}
} catch (Exception e) {
e.printStackTrace();
}
return sb.toString();
}
}
測試類
public class TestBean extends BaseBean {
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public static void main(String[] args) {
TestBean testBean = new TestBean();
testBean.setId(9);
System.out.println(testBean.toString());
}
}
結果
{id:9}
Exception()
構造詳細消息為 null 的新異常。
Exception(String message)
構造帶指定詳細消息的新異常。
Exception(String message, Throwable cause)
構造帶指定詳細消息和原因的新異常。
Exception(Throwable cause)
在java中，如果一個對象未重寫toString()方法，那麼它將會調用父類的toString()，如果父類也沒有重寫這個方法，那麼就迭代往上調用，直到Object的toString()方法。
我們在列印這個toStirng()方法的時候，會出現XXXX@e29820字樣，那麼@後面的值到底是什麼呢，它是對象所在的內存地址么？下面我們來證明：
package oliver.examination.part1;
import java.util.ArrayList;
import java.util.List;
public class ObjectToStringTest {
private static final int SIZE=10000;
public static void main(String[] args)
{
//創建列表存放對象
List<Object> list = new ArrayList<Object>();
int existNumber=0;
//新建SIZE個對象，如果toStirng代表的是內存地址，地址是不會重復的，
//那麼list中應該不會存在重復的元素。
//list的大小應該為SIZE
for(int i=0;i<SIZE;i++){
Object obj = new Object();
if(list.contains(obj.toString())){
System.out.println("對象："+obj.toString()+"已存在!");
existNumber++;
}else
list.add(obj.toString());
}
System.out.println("列表List的大小:"+list.size());
System.out.println("重復元素的個數："+existNumber);
System.out.println
//清空list
list.clear();
existNumber=0;
//新建一個對象的時候，變數名是對這個對象的應用（相當於對象的"地址"）
//利用這個原理，我們再測試
for(int i=0;i<SIZE;i++){
Object obj = new Object();
if(list.contains(obj)){
System.out.println("對象："+obj+"已存在!");
existNumber++;
}else
list.add(obj.toString());
}
System.out.println("列表List的大小:"+list.size());
System.out.println("重復元素的個數："+existNumber);
}
}
運行結果如下：
對象：java.lang.Object@922804已存在!
對象：java.lang.Object@e29820已存在!
列表List的大小:9998
重復元素的個數：2
列表List的大小:10000
重復元素的個數：0
查看Object源代碼：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());