深入理解tostring
关键字: 深入理解tostring()
1. class A{int i;}
2.
3. public class VarArgs{
4. static void f(Object[] x){
5. for(int i=0;i<x.length;i++)
6. System.out.println(x[i]);
7. }
8. public static void main(String[] args){
9. f(new Object[]{
10. new Integer(47),new VarArgs(),
11. new Float(3.14),new Double(11.11)});
12. f(new Object[]{"one","two","three"});
13. f(new Object[]{new A(),new A(),new A()});
14. }
15. }
class A{int i;}
public class VarArgs{
static void f(Object[] x){
for(int i=0;i<x.length;i++)
System.out.println(x[i]);
}
public static void main(String[] args){
f(new Object[]{
new Integer(47),new VarArgs(),
new Float(3.14),new Double(11.11)});
f(new Object[]{"one","two","three"});
f(new Object[]{new A(),new A(),new A()});
}
}
运行结果为：
47
VarArgs@1ba34f2
3.14
11.11
one
two
three
A@13f5d07
A@f4a24a
A@cac268
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
我对此代码的理解：
java使用new objectname()创建了该对象的引用。每一个对象都从Object继承一个toString()方法。当使用System.out.println输出一个引用的时候实际上调用了该对象的toString()方法。对于没有toString方法的类，println则输出该实例的“地址”。
在打印的时候，如果你在你的代码中没有重载toString()方法，那么java将自动调用object的toString()方法，而object的toString()方法一般就是打印某个对象的地址，所以诸如这里的class A，由于你没有重载toString()方法，所以调用object的toString()方法，打印了地址。而对于某些类，诸如这里的Integer，Float，Double对象，由于java已经在Double重写了toString()，虽然你没有再次重写，但它还是会根据Double里已经存在的toString()方法打印了
danceflash对此代码中输出地址的不同理解 ，关于调用object的toString()方法这一点上完全同意
但是要注意的是：
打印出来的"A@13f5d07"并非他的"地址"，而是对象的所属类以及该对象的哈希值
以下是Object类的toString()方法的代码：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
其中：
getClass().getName()返回对象所属类的类名
hashCode()返回该对象的哈希值
Integer.toHexString(hashCode())将对象的哈希值用16进制表示
因此最后得到了这样的结果：A@13f5d07
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
下面给出另外一个例子：
1. public class B
2. {
3. public String toString()
4. {
5. return "This is a ";
6. }
7. }
8. public class A
9. {
10. public static void main(String[] args)
11. {
12. System.out.println(new B());
13. }
14. }
public class B
{
public String toString()
{
return "This is a ";
}
}
public class A
{
public static void main(String[] args)
{
System.out.println(new B());
}
}
输出结果：This is a
理解：因为在B中已经声明了toString方法，实际是对toString方法进行了重载了，此时System.out.println(object)会自动调用该object的toString方法输出。
java中任何class都是默认从Object扩展而来，都有一个toString()方法，System.out.println（object）会默认调用这个object的toString方法，如果在class里面，重写了这个toString（）方法，也就是说那么输出的时候，调用的toString方法就是class中所定义的了。
其实，System.out.println()的参数就是string ，他会把其中的参数转换为string类型，给你重写tostring方法，所以当把new b（）转化成string时，将调用tostring 函数，而此时调用的就是你定义的函数。
例子3：
1.
2. public class TestToString {
3. public static void main(String[] args) {
4.
5. System.out.println("d:=" +new Dog());
6. Dog d1=new Dog();
7. Dog d2=new Dog();
8. Dog d3=new Dog();
9. System.out.println(d1+" "+d2);
10. }
11. }
12.
13. class Dog {
14. public String toString() {
15. System.out.println("###");
16. return "I'm a cool dog!";
17. }
18. }
public class TestToString {
public static void main(String[] args) {
System.out.println("d:=" +new Dog());
Dog d1=new Dog();
Dog d2=new Dog();
Dog d3=new Dog();
System.out.println(d1+" "+d2);
}
}
class Dog {
public String toString() {
System.out.println("###");
return "I'm a cool dog!";
}
}
输出结果：
###
d:=I'm a cool dog!
###
###
I'm a cool dog! I'm a cool dog!