黑马程序员技术交流社区

标题: Object的多态问题 [打印本页]

作者: 聖手｀书生 时间: 2013-4-6 11:09
标题: Object的多态问题
输出的结果有点疑惑。求解释。

复制代码

33333.jpg (7.91 KB, 下载次数: 34)

作者: 庞立森 时间: 2013-4-6 11:29
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.}

作者: 原满 时间: 2013-4-6 11:37
假设有一个实例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的值创建实例时由构造方法传进来的。

作者: Friendy89 时间: 2013-4-6 11:37
成员函数在多态调用时，编译看左边，运行看右边。
在多态中，成员变量的特点：
无论编译和运行，都参考左边（引用型变量所属的类）。
在多态中，静态成员函数的特点：
无论编译和运行都参考左边。

作者: 田光峰 时间: 2013-4-6 12:13
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()方法。

作者: 秦久启 时间: 2013-4-6 12:26
给你举个简单的一个例子吧：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()方法打印内容

希望对楼主有所帮助。

作者: 王梦南 时间: 2013-4-6 12:43
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"

作者: 刘焕新 时间: 2013-4-6 16:19
本帖最后由刘焕新于 2013-4-6 16:36 编辑

class Demo // extends Object
{
//定义了一个int类型的成员变量：
private int num;
//定义了此类的构造函数，在构造此类对象时，传了num的值：
Demo(int num) {
this.num = num;
}
//重写了根类（Object）的equals方法：
public boolean equals(Object obj) // Object obj = new Demo();
{
if (!(obj instanceof Demo))
return false;
Demo d = (Demo) obj;
return this.num == d.num;
}
//重写了根类（Object）的toString方法：
public String toString() {
//这里的变量num是此类的成员变量，值是在创建对象时传进来的
return "demo:" + num;
}
}
public class ObjectDemo {
public static void main(String[] args) {
Demo d1 = new Demo(4); //创建了一个Demo类的具体对象
//这句是将一个对象打印到控制台：
System.out.println(d1);//在打印前，系统默认地会先调用对象的toString()方法，所以你在println()方法里写d1和d1.toString()的结果是一样的。
Demo d2 = new Demo(7);
System.out.println(d2.toString());
//num的值是你在创建一个对象叫d2时，将7赋值给了d2的变量num（倒数第二句代码），然后打印前，系统又调用了此对象的toString()方法，
//toString()方法是从这个d2对象里获取了变量num的值。
}
}

复制代码

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

作者: 董霁辉 时间: 2013-4-6 16:28
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())

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

作者: lcjasas 时间: 2013-4-6 17:22
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();方法执行输出.
      }
}
其实老师上课的时候讲过,编译看左边,执行看右边

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2