重写(OverWrite)和重载(OverLoad)及各发生在哪个时期(编译期or运行期)

重写(OverWrite)：

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

在面向对象原则里，重写意味着可以重写任何现有方法。

方法的重写规则

* 参数列表必须完全与被重写方法的相同；

* 返回类型必须完全与被重写方法的返回类型相同；

* 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。

* 父类的成员方法只能被它的子类重写。

* 声明为final的方法不能被重写。

* 声明为static的方法不能被重写，但是能够被再次声明。

* 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。

* 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。

* 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

* 构造方法不能被重写。

* 如果不能继承一个方法，则不能重写这个方法。

方法的重写发生在运行时。因为在编译时，编译器是无法知道我们到底是调用父类的方法还是子类的方法，相反的，只有在实际运行的时候，我们才知道应该调用哪个方法。这个也是java运行时多态的体现。

重载(OverLoad)：

对于类的方法（包括从父类中继承的方法），如果有两个方法的方法名相同，但参数不一样，则一个方法是另一个方法的重载方法。

重载方法必须满足以下条件：

（1）方法名相同；

（2）方法的参数类型、个数、顺序至少有一项不同；

（3）方法的返回值类型可以不同；

（4）方法的修饰符可以不同；

 在一个类中不允许定义两个方法名相同，并且参数签名也完全相同的方法。因为假如存在这样的方法，Java虚拟机在运行时就无法决定到底执行哪个方法，参数签名是指参数的类型、个数和顺序。

注意：重载方法跟其返回类型没有关系。

方法的重载发生在编译时。在编译过程中，编译器必须根据参数类型以及长度来确定到底是调用的哪个方法，这也是Java编译时多态的体现。

import java.math.BigDecimal;
import java.util.*;

/**
 * Created by ZhangAnmy on 18/9/23.
 */
public class OverLoadTest {
    public static String classify(Set<?> set){
        return "set";
    }

    public static String classify(List<?> list){
        return "list";
    }

    public static String classify(Collection<?> col){
        return "collection";
    }

    public static void main(String[] args)
    {
        Collection<?>[] collection={
                new HashSet<String>(),
                new ArrayList<BigDecimal>(),
                new HashMap<String,String>().values()
        };

        for(Collection<?> collection1 : collection)
        {
            System.out.println(classify(collection1));
        }
    }
}

运行结果：

collection

collection

collection

classify方法被重载了，而要调用哪个重载方法是在编译时做出决定的。对于for循环的三次迭代，参数编译时类型都是相同的：Collection<?>，每次迭代的运行时期的类型是不相同的，但这个不影响重载方法的选择。因为该参数的编译时类型为Collection<?>,所以，唯一合适的重载方法是第三个classify(Collection<?>），在循环的每次迭代中，都会调用这个重载方法。

与多态的父类引用指向子类对象，编译时看父类，运行时看子类不同的是，在重载的方法选择过程中，对象的运行时类型并不影响哪个重载版本被执行，选择工作是在编译时期完成的，完全基于参数的编译时期的类型。 但是多态的父类引用指向子类对象与这个不一样。举例如下：

public class Fu { 
    String name(){ 
        return "fu"; 
    } 
} 

public class Zi extends Fu { 
    String name(){ 
        return "zi"; 
    } 
} 

public class Sun extends Zi { 
    String name(){ 
        return "Sun"; 
    } 
} 

public static void main(String[] args) {
     ArrayList list = new ArrayList(); 
     list.add(new Fu()); 
     list.add(new Zi()); 
     list.add(new Sun()); 

     for (Fu item : list) 
     { 
        System.out.println(item.name()); 
     } 
   } 
} 

运行结果：

fu

zi

sun

尽管每次循环迭代过程中编译时期的类型都是Fu，运行时是各自的类型，当调用被覆盖的方法时，对象编译时期的类型不影响哪个方法被执行。