黑马程序员技术交流社区

标题: 为什么变量取决于引用而不是实际对象 [打印本页]
作者: 张凯    时间: 2012-7-23 07:24
标题: 为什么变量取决于引用而不是实际对象
先看下代码：

  2. ParentClass:
  3. package com.design;
  4. class ParentClass {
  5. public static String staticField = "父类静态变量";
  6. public final String finalField = "父类常量";
  7. public static final String staticFinalField = "父类静态常量";
  8. public static void getStr(){
  9. System.out.println("child output");
  10. }
  11. }

  13. SubClass:
  14. package com.design;
  15. public class SubClass extends ParentClass {
  16. public static String staticField = "子类静态变量";
  17. public final String finalField = "子类常量";
  18. public static final String staticFinalField = "子类静态常量";
  19. public static void getStr(){
  20. System.out.println("child output");
  21. }

  23. public static void main(String[] args) {
  24. //这里到底发生了什么？
  25. ParentClass subClass = new SubClass(); //(1)
  26. System.out.println(subClass.staticField);
  27. System.out.println(subClass.finalField);
  28. System.out.println(subClass.staticFinalField);
  29. subClass.getStr();
  30. //为什么与(1)不同呢 SubClass subClass2 = new SubClass();
  31. System.out.println(subClass2.staticField);
  32. System.out.println(subClass2.finalField);
  33. System.out.println(subClass2.staticFinalField);
  34. subClass2.getStr();
  35. }
  36. }
复制代码
运行结果：
父类静态变量
父类常量
父类静态常量
child output
子类静态变量
子类常量
子类静态常量
child output


我想问的是父类子类有相同的变量声明，为什么变量取决于引用而不是实际的对象？
作者: 姬仁贵    时间: 2012-7-23 08:11
public static void main(String[] args)
{
//这里到底发生了什么？
ParentClass subClass = new SubClass(); //这句话是父类的引用指向子类对象，是多态的体现形式。
System.out.println(subClass.staticField);
System.out.println(subClass.finalField);
System.out.println(subClass.staticFinalField);
subClass.getStr();
//为什么与(1)不同呢
SubClass subClass2 = new SubClass(); //这里是子类的引用指向子类对象
System.out.println(subClass2.staticField);
System.out.println(subClass2.finalField);
System.out.println(subClass2.staticFinalField);
subClass2.getStr();
}


ParentClass subClass = new SubClass();//这句话是父类的引用指向子类对象，是多态的体现形式。
在多态中，成员变量的特点：
无论在编译和运行，都参考左边（引用型变量所属的类）。
当父类和子类出现重名变量的时候，多态情况下看的是左边（引用型变量所属的类）。
所以：
System.out.println(subClass.staticField);
System.out.println(subClass.finalField);
System.out.println(subClass.staticFinalField);
执行的结果是：
父类静态变量
父类常量
父类静态常量
System.out.println(subClass2.staticField);
System.out.println(subClass2.finalField);
System.out.println(subClass2.staticFinalField);
执行的结果是：
子类静态变量
子类常量
子类静态常量

作者: 梁志仲    时间: 2012-7-23 08:17
静态成员是存在于方法区内，实际的对象是在堆内存中，对象的引用是在栈内存中。subClass变量是ParentClass类的引用，指向ParentClass自己的静态成员，同时指向了堆内存中SubClass类的实际对象。subClass2 变量是SubClass类的引用，指向SubClass自己的静态成员，同时指向了堆内存中SubClass类的实际对象。
静态成员可以直接通过类名调用，说明静态成员是与是否创建实际的对象无关的。
作者: 左建飞    时间: 2012-7-23 09:13
  1. public static void main(String[] args) {
  2. //这里到底发生了什么？
  3. ParentClass subClass = new SubClass(); //多态的使用。父类的引用指向了自己的子类对象。相当于对SubClass()做了类型的提升，使它向上转型。所以下面的SubClass在调用方法时，都是调用的父类方法。如果这时想使用子类的方法，应向下转型，SubClass subClass1=(SubClass)subClass;这时subClass1才能调用子类方法。
  4. System.out.println(subClass.staticField);
  5. System.out.println(subClass.finalField);
  6. System.out.println(subClass.staticFinalField);
  7. subClass.getStr();
  8. //为什么与(1)不同呢 SubClass subClass2 = new SubClass(); //这里没有使用多态，没有发生转型。还是子类引用指向子类对象。
  9. System.out.println(subClass2.staticField);
  10. System.out.println(subClass2.finalField);
  11. System.out.println(subClass2.staticFinalField);
  12. subClass2.getStr();
  13. }
复制代码




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