毕老师视频中讲到 静态只能覆盖静态 我试了一下貌似不能覆盖i，不知是不是我理解错了 ？

1. /*
   
2. 方法重写(override)
   
3. 1.子类覆盖父类，必须保证子类权限大于等同于父类权限，才可以覆盖。
   
4. */
   
5. class ExtendsDemo
   
6. {
   
7. public static void main(String[] args)
   
8. {
   
9. Parent p1= new Parent();
   
10. p1.show();//父类5
    
11. Child c1=new Child();
    
12. c1.show();//子类4
    
13. Parent p2= new Child();
    
14. p2.show();//子类4
    
15. p2.method();//输出Parent
    
16. System.out.println(p2.a);//5
    
17. }
    
18. }
    
19. class Parent
    
20. {
    
21. public int a=5;
    
22. void show()
    
23. {
    
24. System.out.println("父类"+a);
    
25. }
    
26. static void method()
    
27. {
    
28. System.out.println("Parent");
    
29. }
    
30. }
    
31. class Child extends Parent
    
32. {
    
33. public int a =4;
    
34. void show()
    
35. {
    
36. System.out.println("子类"+a);
    
37. }
    
38. static void method()
    
39. {
    
40. System.out.println("Child");
    
41. }
    
42. }

复制代码

Mark~~~~~~

static方法属性类级别的方法，是不可以被覆盖的。只有可能被重载。
如下：

1. public class Human {
   
2.         public static void p(){
   
3.                 System.out.println("human");
   
4.         }
   
5. }

复制代码

1. public class Person extends Human {
   
2. //         @Override // 这里加上表示覆盖的注解，编译器是会报错的
   
3.         public static void p(){
   
4.                 System.out.println("human");
   
5.         }
   
6. }       

复制代码

还要理解的是，覆盖的作用就是为了多态，static不属于对象所有，这样你用什么类调用具体的调用就是你所用的类，跟具体对象没关系。从这点上也说明static方法是不可以被覆盖的。

确实已经覆盖了父类的方法
写成parent s=new parent();就可以调用子类中的覆盖的方法了
Parent s=new Child();是多态
多态的特点:父类的引用指向子类的对象
静态函数以及成员变量具有其特殊性,因为它们都是在类加载的时候,就已经加载到内存里了.
Parent s=new Child();父类引用在使用方法或成员变量时,应该遵循下面步骤:
           1,在父类中是不是存在该方法或者成员变量.
           2,如果存在,编译通过
           3,如果调用的是成员变量,只看父类中的成员变量.
           4,调用的方法是静态的,即使子类重写了该方法,jvm也会优先选择调用父类的
           5,一般函数子类如果有覆盖,就调用子类的

static 的属性和方法都是不能覆盖的，因为static修饰的部分都是与对象无关的，只与类有关.
两个类的同名同参数的静态方法是分属于两个类的，各不相干，只是名字相同而已.
所以你用父类调用的,输出的就是父类的方法.
如果你仔细看一下老师的视频老师强调的是非静态绝对不能覆盖静态,而且静态覆盖静态没有意义.
有可能是老师的小mistake.或者你会意错了.

首先，毕老师没有说错，
Parent p2= new Child();
看这里，注意这里是多态了。

p2.show();//子类4
这里运行的是子类的show方法；

p2.method();//输出Parent
你的p2是什么类型的？是父类的吧？！这里和没有new对象就是直接调用父类的静态方法不是一样吗？
记住一句话，编译看左边，运行看右边，句话只是适用于一般方法的情况，而对于静态方法，你就得看他到底是什么类型的！！！。
如果你要验证毕老师是不是说错了，你可以这样：
new Child().method();
也就是创建一个子类，调用覆盖了的静态方法。也可以不创建子类的对象直接用类名调用也可以。

System.out.println(p2.a);//5

1. class Parent
   
2. {
   
3.         static int a = 1;
   
4.         int b = 2;
   
5.         void show()
   
6.         {
   
7.                 System.out.println("Parent show run."+"a="+a+",b+"+b);
   
8.         }
   
9.         static void method()
   
10.         {
    
11.                 System.out.println("Parent static menthod run."+"a="+a);
    
12.         }
    
13. }
    
14. 
    
15. class Child extends Parent
    
16. {
    
17.         static int a = 3;
    
18.         int b = 4;
    
19.         void show()
    
20.         {
    
21.                 System.out.println("Child show run."+"a="+a+",b+"+b);
    
22.         }
    
23.         static void method()
    
24.         {
    
25.                 System.out.println("Child static menthod run."+"a="+a);
    
26.         }
    
27. }
    
28. 
    
29. public class TestClass
    
30. {
    
31.         public static void main(String[] args){
    
32.                 Parent p = new Parent();
    
33.                 Child c = new Child();
    
34.                 Parent pc = new Child();
    
35. 
    
36.                 System.out.println("a="+p.a+",b="+p.b);
    
37. 
    
38.                 p.show();
    
39.                 p.method();
    
40. 
    
41.                 System.out.println("----------------------");
    
42. 
    
43.                 System.out.println("a="+c.a+",b="+c.b);
    
44.                
    
45.                 c.show();
    
46.                 c.method();
    
47. 
    
48.                 System.out.println("----------------------");
    
49.                
    
50.                 System.out.println("a="+pc.a+",b="+pc.b);
    
51. 
    
52.                 pc.show();
    
53.                 pc.method();
    
54.         }
    
55. }

复制代码

运行结果：
a=1,b=2
Parent show run.a=1,b+2
Parent static menthod run.a=1
----------------------
a=3,b=4
Child show run.a=3,b+4
Child static menthod run.a=3
----------------------
a=1,b=2
Child show run.a=3,b+4
Parent static menthod run.a=1

大家都知道非静态方法的继承覆盖的原则，即向上转型时从他的实例中可而已看出来，但是静态方法却不是像非静态方法那样工作，虽然静态方法可以被继承但是为什么不能覆盖呢？
    原因是这样的，静态方法跟其他非静态方法不一样的区别在于静态方法不用NEW一个实例就可以调用的，即它的调用是根据他的类型来判断的，所以我总结一句话就是：静态方法的继承和覆盖是跟着引用类型的，而非静态方法是跟着实例本身的。