静态修饰的变量和方法存在方法区，类一旦被加载就会固定存在
如果子类继承父类静态的方法不能被子类覆盖。
例如

1. class A{
   
2. static         int    num=3;
   
3. public   static  void a(){
   
4. System.out.println("a");
   
5. }
   
6. }
   
7. class B extends A{
   
8. static int  num=4;
   
9. public static  void a(){
   
10. System.out.println("b");
    
11. }
    
12. }
    
13. 
    
14. public class Test1 {
    
15. public static void main(String[] args) {
    
16. A a = new B();
    
17. a.a();
    
18. System.out.println(a.num);
    
19. }}

复制代码

这段代码，方法a(),如有静态修饰，输出的是父类的内容，如果没有静态修饰，输出的是子类的内容
那为什么a.num不管有没有静态修饰，输出的都是父类的变量值呢

这跟静态无关，我记得基础视频有这么句话：编译看左边，运行看右边。这句话是在向上转型那一块讲的，但是说的只是成员方法，成员变量的话却有不同，无论是编译还是运行都看左边。

。。。。。。。。。。。。。。。。。。。。

这个跟静不静态没关系，毕老师总结果，多态里 同名成员变量看左边的~因为人家父类里本来就有这个成员所以就不去子类去找了

先贴代码

1. class Father {
   
2.         static String sayHi() {
   
3.                 return "Father say Hi";
   
4.         }
   
5. 
   
6.         String name() {
   
7.                 return "name is father";
   
8.         }
   
9. }
   
10. 
    
11. class Son extends Father {
    
12.         static String sayHi() {
    
13.                 return "Son say Hi";
    
14.         }
    
15. 
    
16.         String name() {
    
17.                 return "name is son";
    
18.         }
    
19. }
    
20. 
    
21. class Differ {
    
22.         public static void main(String args[]) {
    
23.                 Father s = new Son();
    
24.                 System.out.println(s.sayHi() + "--->" + s.name());
    
25.         }
    
26. }

复制代码

输出结果为
Father say Hi--->name is son
“Father say Hi”是父类方法的输出，而“name is son”是子类方法的输出，这是由于sayHi是一个静态方法，它没有运行时多态的特性，它的调用在s声明时就已经确定好了
造成这种区别的原因很简单，实例方法总是和某个对象绑定在一起，而静态方法则没有与某个对象绑定在一起也就无从查找调用时该对象实际所属的类别

建议楼主可以看下这篇文章http://blog.sina.com.cn/s/blog_600046120100wdza.html