输出的结果有点疑惑。求解释。

1. class Demo //extends Object
   
2. {
   
3.         private int num;
   
4.         Demo(int num)
   
5.         {
   
6.                 this.num = num;
   
7.         }
   
8.        
   
9.         public boolean equals(Object obj)//Object obj = new Demo();
   
10.         {
    
11. 
    
12.                 if(!(obj instanceof Demo))
    
13.                         return false;
    
14.                 Demo d = (Demo)obj;
    
15. 
    
16.                 return this.num == d.num;
    
17.         }
    
18.        
    
19. 
    
20.         public String toString()
    
21.         {
    
22.                 return "demo:"+num;
    
23.         }
    
24. 
    
25. 
    
26. }
    
27. class Person
    
28. {
    
29. }
    
30. 
    
31. 
    
32. class ObjectDemo
    
33. {
    
34.         public static void main(String[] args)
    
35.         {
    
36.                 Demo d1 = new Demo(4);
    
37.                 System.out.println(d1);//这句的结果是demo：4  ，实在不解，求解释。
    
38.                 Demo d2 = new Demo(7);
    
39.                 System.out.println(d2.toString());//这句的结果是demo：7 ，看起来结构是对的，但是num的值是怎么附加到toString函数中的呢？？
    
40.         }
    
41. }

复制代码

01.class Demo //extends Object 任何类都是object的子类，object的方法子类可以去覆写或者使用

02.{

03.        private int num;

04.        Demo(int num)

05.        {

06.                this.num = num;

07.        }

08.        

09.        public boolean equals(Object obj)//Object obj = new Demo();

10.        {

11.

12.                if(!(obj instanceof Demo))

13.                        return false;

14.                Demo d = (Demo)obj;

15.

16.                return this.num == d.num;

17.        }

18.        

19.

20.        public String toString() //你复写了toString方法，返回值是“demo”+num

21.        {

22.                return "demo:"+num;

23.        }

24.

25.

26.}

27.class Person

28.{

29.}

30.

31.

32.class ObjectDemo

33.{

34.        public static void main(String[] args)

35.        {

36.                Demo d1 = new Demo(4);

37.                System.out.println(d1);//这里输出的是对象，如果你在你的Demo类中覆写了object中的toString方法，结果就会默认去调用toString（）方法，如果你没有覆写，那么将输出地址值

38.                Demo d2 = new Demo(7);

39.                System.out.println(d2.toString());//这个就是你手动去调用的，输出结果必然是demo7

40.        }

41.}

假设有一个实例Object obj,则当System.out.println(obj);时，它其实是自动调用obj.toString()方法，然后输出该方法返回的string字符串
也就是说例子中System.out.println(obj)与 System.out.println(obj.toString)是一样的
由于你的Demo类 重写了toString()方法  所以当System.out.println(obj);时  调用的是   
public String toString()
  {
         return "demo:"+num;
     }

自然会返回  “demo：num"  的形式

至于 num的值   创建实例时由构造方法传进来的。

成员函数在多态调用时，编译看左边，运行看右边。
在多态中，成员变量的特点：
        无论编译和运行，都参考左边（引用型变量所属的类）。
在多态中，静态成员函数的特点：
        无论编译和运行都参考左边。

class Demo //extends Object
{
        private int num;
        Demo(int num)
        {
                this.num = num;
        }
        
        public boolean equals(Object obj)//Object obj = new Demo();
        {

                if(!(obj instanceof Demo))
                        return false;
                Demo d = (Demo)obj;

                return this.num == d.num;
        }
        

        public String toString()
        {
                return "demo:"+num;
        }


}
class Person
{
}


class ObjectDemo
{
        public static void main(String[] args)
        {
                Demo d1 = new Demo(4);
                System.out.println(d1);//这句的结果是demo：4  ，实在不解，求解释。
                Demo d2 = new Demo(7);
                System.out.println(d2.toString());//这句的结果是demo：7 ，看起来结构是对的，但是num的值是怎么附加到toString函数中的呢？？
        }
}
---------------------------------------------------------------------------------------------------------------------------------------
原因是这样的：
当执行代码Demo d1 = new Demo(4); 是就创建Demo对象，又因为new Demo(4);是代参数的，就会找到Demo中带参数的构造函数
把4的传递出去   要找的构造函数是：
Demo(int num)
        {
                this.num = num;
        }
这样 num的值就是4了。

当执行代码System.out.println(d1) 时会自动调用

public String toString()
        {
                return "demo:"+num;
        }
因为返回的值是num，所以结果是 demo：4


关于7的值其实是一样的，只不过在输出时直接调用了d2.toString()方法。

给你举个简单的一个例子吧：object 类中主要就是有这几个方法: public Object(); public boolean equals(Object obj); public int hashCode(); public String toString();那么现在就看看toString方法：
class Demo{
}
public class ObjectDemo{
          public static void main(String args[]){
                   Demo d = new Demo();
                   System.out.println("不加上toString()输出" + d);
                   System.out.println("加上toString()输出" + d.toString());
      }
}
运行发现结果都是一样的：也就是说对象输出的时候一定会调用Object类中的toString()方法打印内容

希望对楼主有所帮助。

Demo d1 = new Demo(4);
System.out.println(d1);
//对于非基础数据类型的对象而言，输出语句会默认调用该对象的toString方法。
比如你没有重写toString方法，它默认打印的结果是Demo@+哈希码值。
但是你重写了toString方法，输出语句就会调用你重写的toString方法。
你toString的方法中返回的是"demo"+num变量所组成的字符串。
你在初始化d1的时候调用的是1个int参数的构造方法，传入的num是4，所以会打印出"demo:4"
下面的也是一样，只不过是你自己手动的调用了toString方法。
Demo(int num) {
      this.num = num;
}
创建对象的时候你调用了这个构造方法。它的含义是你传进来的值，赋值给对象的num属性。即d2.num=7;
d2的toString方法会先在方法中找num，找不到的话，就会去所在的类里面找，而d2中num被你赋值为7，所以打印出来的就是"demo:7"

1. class Demo    // extends Object
   
2. {
   
3.         //定义了一个int类型的成员变量：
   
4.         private int num;
   
5.         //定义了此类的构造函数，在构造此类对象时，传了num的值：
   
6.         Demo(int num) {
   
7.                 this.num = num;
   
8.         }
   
9. 
   
10.         //重写了根类（Object）的equals方法：
    
11.         public boolean equals(Object obj)        // Object obj = new Demo();
    
12.         {
    
13.                 if (!(obj instanceof Demo))
    
14.                         return false;
    
15.                 Demo d = (Demo) obj;
    
16.                 return this.num == d.num;
    
17.         }
    
18.         
    
19.         //重写了根类（Object）的toString方法：
    
20.         public String toString() {
    
21.                 //这里的变量num是此类的成员变量，值是在创建对象时传进来的
    
22.                 return "demo:" + num;
    
23.         }
    
24. }
    
25. 
    
26. public class ObjectDemo {
    
27.         public static void main(String[] args) {
    
28.                 Demo d1 = new Demo(4); //创建了一个Demo类的具体对象
    
29.                 //这句是将一个对象打印到控制台：
    
30.                 System.out.println(d1);//在打印前，系统默认地会先调用对象的toString()方法，所以你在println()方法里写d1和d1.toString()的结果是一样的。
    
31.                 Demo d2 = new Demo(7);
    
32.                 System.out.println(d2.toString());
    
33.                 //num的值是你在创建一个对象叫d2时，将7赋值给了d2的变量num（倒数第二句代码），然后打印前，系统又调用了此对象的toString()方法，
    
34.                 //toString()方法是从这个d2对象里获取了变量num的值。
    
35.         }
    
36. }
    

复制代码

这个代码里没有涉及到多态问题，知识点是：
1. 所有类继承于Object类；
2. 重写父类的方法：重写Object类的equals()和toString()方法。

1 Demo d1 = new Demo(4);Demo d1 = new Demo(7);调用了带参数的构造方法,
2 System.out.println();语句自动调用了obj.toString方法,本应返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成,但你复写了toString()方法.本例Demo.toString()打出了4
3  private int num;
        Demo(int num)
        {
                this.num = num;
        }
以上代码把创建Demo对象时传入的值付给了num
public String toString()
        {
                return "demo:"+num;
        }
以上代码你复写了toString() 调用了num. 7就这么出来的.
------------------------------------------------------------------------------------
P.S.:
toString
public String toString()返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：

getClass().getName() + '@' + Integer.toHexString(hashCode())

返回：
该对象的字符串表示形式。

class Demo //extends Object
{
        private int num;
        Demo(int num)
        {
                this.num = num;
        }      
        public boolean equals(Object obj)//Object obj = new Demo();
        {
                if(!(obj instanceof Demo))
                        return false;
                Demo d = (Demo)obj;
               return this.num == d.num;
        }
        public String toString()
        {
                return "demo:"+num;
        }
}
class Person {}
class ObjectDemo
{
        public static void main(String[] args)
        {
                Demo d1 = new Demo(4);
                System.out.println(d1);//系统默认地会调用对象的toString()方法输出结果,多疑结果是demo:4
           Demo d2 = new Demo(7);
                System.out.println(d2.toString());//当程序执行到System.out.println(d2  时,d2 = new Demo(7),这是程序就跳转到Demo类去执行,
                                                              //最后还是调用toString();方法执行输出.
        }
}
其实老师上课的时候讲过,编译看左边,执行看右边