先看下代码：

1. 
   
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. }
    
12. 
    
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. }
    
22. 
    
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


我想问的是父类子类有相同的变量声明，为什么变量取决于引用而不是实际的对象？

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);
执行的结果是：
子类静态变量
子类常量
子类静态常量

静态成员是存在于方法区内，实际的对象是在堆内存中，对象的引用是在栈内存中。subClass变量是ParentClass类的引用，指向ParentClass自己的静态成员，同时指向了堆内存中SubClass类的实际对象。subClass2 变量是SubClass类的引用，指向SubClass自己的静态成员，同时指向了堆内存中SubClass类的实际对象。
静态成员可以直接通过类名调用，说明静态成员是与是否创建实际的对象无关的。

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. }

复制代码