学步园

1. 方法重载（Overload）
   静态的，编译期间决定调用哪个方法；
   只与句柄的类型有关，而与对象的实际类型无关；
2. 方法覆盖 （Override）
   动态的，只能在运行期间才能决定调用哪个方法 ；
   最终调用的方法，只与对象的实际类型有关，而与句柄类型无关；
   不能覆盖private, final和static方法,一个包内可见的方法不能被另一个包的类覆盖；
可以看到overload注重的是句柄，而override注重的是对象类型。

//here's the code
class Parent{
  public static void m(int a){
   System.out.println("parent");                    //1
  }
}
class Child extends Parent{
  public static void m(int a){
   System.out.println("child int");//2
  }
      public static void m(String s){
       System.out.println("child string");  //3
      }
                                                                              }
public  class TT {
 /**
  * @param args
  */
 public static void main(String[] arg){
   Parent p=new Child();
   p.m(1);                //4
   //p.m("s");     //5

 }
}
显然这是一个静态函数重载或者是覆盖的问题。如果是一般的函数，应该输出child int，且5是可以运行的，但是结果是parent。why？
应为static是存储在全局区的，函数的存储实际上是带上类名称，换言之，类名也是函数一个参数。可能类似m(int a,class parent/child) 。所以实际上这是一个静态函数的重载overload，而重载只和句柄类型有关，结果就是parent，且5句不能运行（无法将 Parent 中的 m2(int) 应用于 (java.lang.String)）；
总结：静态函数只能overload！

public class Parent {

public static void m(int a){System.out.println("parent int");} //1 

}

class Child extends Parent{
public static void m(int a){System.out.println("child int");} //2
public static void m(String s){System.out.println("child string");} //3

public static void main(String[] args){
Chlid p=new Child();
p.m(1); //4
p.m("s"); //5
}
}

输出：
child int
child string