A. Java中 toString方法始終沒有一個全面的認識，什麼是toString方法為什麼需要重寫
Object 類的 toString 方法
返回一個字元串，該字元串由類名（對象是該類的一個實例）、at
標記符「@」和此對象哈希碼的無符號十六進製表示組成。換句話說，該方法返回一個字元串，它的值等於：
getClass().getName() + '@' + Integer.toHexString(hashCode())
2. 對象如果沒有父類，默認繼承Object。
如果沒重寫toString方法，則默認是Object的toString方法返回值：類名@哈希瑪值；
如果重寫，則如以下返回你想返回的字元串(對象的描述)；
public class Person {
private String name ;
。。。
public String toString() {
return "name" = name;
}
}
B. 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());
}
C. JAVA中字元串輸出和拼接問題重寫了toString方法，結果為什麼是ilovejava,而不是lovejavai。代碼如下
這個類似於四則混合運算里的運算順序的問題，System.out.println("LOVE "+new Test())，中，new Test()的優先順序更高，所以會先構造Test實例。然後調用字元串的"+"運算，+的底層我記得還是使用了StringBuilder，所以"LOVE "+new Test()可以等價於：
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("LOVE").append(new Test().toString());
return stringBuilder.toString();
調用你的toString()方法時首先輸出了"I "，返回"java"然後stringBuilder實際返回為：
stringBuilder.append("LOVE").append("java ").toString();
所所以你的System.out.println("LOVE "+new Test())等價於System.out.println("LOVE java")，加上先輸出的"I "，最終結果就是"I LOVE java "了。
D. java中如何將一個函數輸出的結果,用tostring轉成字元串形式
重寫object類的toString()方法，因為任何類都繼承與object,重寫了toString方法後，Sysout.out.print（）方法裡面會調用toString() 方法,調用這個toString後就會返回字元串的形式。
不信你試試就知道了！給分吧。
E. 方法的重載與重寫
1、重載: 方法名相同，參數列表不同 。 重載是一個類裡面，寫了多了同名的方法，各個方法的返回值類型可以不一樣。要注意區分重載方法可以通過參數列表的個數，類型和順序。但是不推薦用順序來進行重載，這會讓代碼可讀性極差。
2、重寫： 也叫覆蓋，指在子類中定義一個與父類中方法同名同參數列表的方法。因為子類會繼承父類的方法，而重寫就是將從父類繼承過來的方法重新定義一次，重新填寫方法中的代碼。重寫一般是指父類和子類之間，子類重寫了父類的一個方法，當然方法名是一樣的，而且不能改變父類方法的返回值，比如說父類是返回String，子類重寫了這個方法，想返回一個int，那是不行的，也得返回String。
F. ToString("#.##")
ToString("#.##") 返回該對象的字元串表示。通常，toString 方法會返回一個「以文本方式表示」此對象的字元串。結果應是一個簡明但易於讀懂的信息表達式。
建議所有子類都重寫此方法。Object類的 toString 方法返回一個字元串，該字元串由類名（對象是該類的一個實例）、at標記符「@」和此對象哈希碼的無符號十六進製表示組成。換句話說，該方法返回一個字元串，它的值等於：
getClass().getName() + '@' + Integer.toHexString(hashCode())
返回：該對象的字元串表示形式。
G. 重寫下面的函數，使其返回下一個非空白字元而不僅僅是下一個字元。
只要判斷空白字元就好了
一般來說 輸入的空白字元 都是空格 換行。 如果有其它的 你可以再加。
charget_first(void)
{
intch;
while(1)
{
ch=getchar();
if(ch!=''&&ch!=' '&&ch!=' ')break;//非空白字元退出循環。
}
while(getchar()!=' ');
//continue;//其實這個continue沒什麼意義。上面加一個分號就好。
returnch;
}
H. 初學者求教:java中重寫方法 Arrays.toString() 的疑惑
Card[] cards = new Card[54]; // 這是一個數組，是一個普通對象。
Player[] players = new Player[3]; // 這是一個數組，是一個普通對象。
第一行，調用了數組 cards 上索引為 0 的元素的 toString 方法，對應於 Card 類的 toString 方法。
第二行，調用了數組 cards 的 toString 方法，對應於 Card[] 類的 toString 方法，繼承自 Object 類。
第三行，調用了 Arrays 類的 toString 方法，傳入參數是數組 cards ，具體可查找該方法的源碼。
第四行，調用了數組 players 上索引為 0 的元素的 toString 方法，對應於 Player 類的 toString 方法。
第五行，調用了數組 players 的 toString 方法，對應於 Player[] 類的 toString 方法，繼承自 Object 類。
第六行，調用了 Arrays 類的 toString 方法，傳入參數是數組 players ，具體可查找該方法的源碼。
簡單說一下 Arrays.toString() ，它返回是由數組內所有元素的字元串化（toString）合並而成的字元串對象。
因此：
1. 不是同一個 toString 方法，任何對象都可調用自身的 toString 方法。
2. 因為 Player 類的 toString 方法內曾調用了「 Arrays.toString(cards) 」。
4. 任何對象都可調用自身的 toString 方法，數組是對象。
5. 數組是對象，一樣有對應的類型，其類型一樣繼承自 Object 類，繼承了 toString 方法。
最後，有任何疑問請追問。