1、重写只能出现在继承关系之中。当一个类继承它的父类方法时，都有机会重写该父类的方法。一个特例是父类的方法被标识为final。重写的主要优点是能够定义某个子类型特有的行为。

复制代码

 class Animal {

       public void eat(){

           System.out.println ("Animal is eating.");

       }

   }

   class Horse extends Animal{

       public void eat(){

           System.out.println ("Horse is eating.");

       }

   }

复制代码

2、对于从父类继承来的抽象方法，要么在子类用重写的方式设计该方法，要么把子类也标识为抽象的。所以抽象方法可以说是必须要被重写的方法。

3、重写的意义。

重写方法可以实现多态，用父类的引用来操纵子类对象，但是在实际运行中对象将运行其自己特有的方法。

复制代码

   public class Test {

       public static void main (String[] args) {

           Animal h = new Horse();

           h.eat();  

       }

   }

   class Animal {

       public void eat(){

           System.out.println ("Animal is eating.");

       }

   }

   class Horse extends Animal{

       public void eat(){

           System.out.println ("Horse is eating.");

       }

       public void buck(){

       }

   }

复制代码

　　一个原则是：使用了什么引用，编译器就会只调用引用类所拥有的方法。如果调用子类特有的方法，如上例的h.buck(); 编译器会抱怨的（编译错误）。也就是说，编译器只看引用类型，而不是对象类型。

4、重写方法的规则。

　　若想实现一个合格重写方法，而不是重载，那么必须同时满足下面的要求！

A、重写规则之一：重写方法不能比被重写方法限制有更严格的访问级别。

（但是可以更广泛，比如父类方法是包访问权限，子类的重写方法是public访问权限。）

　　比如：Object类有个toString()方法，开始重写这个方法的时候我们总容易忘记public修饰符，编译器当然不会放过任何教训我们的机会。出错的原因就是：没有加任何访问修饰符的方法具有包访问权限，包访问权限比public当然要严格了，所以编译器会报错的。

B、重写规则之二：参数列表必须与被重写方法的相同。

　　重写有个孪生的弟弟叫重载，也就是后面要出场的。如果子类方法的参数与父类对应的方法不同，那么就是你认错人了，那是重载，不是重写。

C、重写规则之三：返回类型必须与被重写方法的返回类型相同。

　　父类方法A：void eat(){} 子类方法B：int eat(){} 两者虽然参数相同，可是返回类型不同，所以不是重写。

　　父类方法A：int eat(){} 子类方法B：long eat(){} 返回类型虽然兼容父类，但是不同就是不同，所以不是重写。

D、重写规则之四：重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少，更有限或者不抛出异常。

复制代码

   import java.io.*;

   public class Test {

       public static void main (String[] args) {

           Animal h = new Horse();

           try {

               h.eat();  

           }

           catch (Exception e) {

           }

       }

   }

   class Animal {

       public void eat() throws Exception{

           System.out.println ("Animal is eating.");

           throw new Exception();

       }

   }

   class Horse extends Animal{

       public void eat() throws IOException{

           System.out.println ("Horse is eating.");

           throw new IOException();

       }

   }

复制代码

　　这个例子中，父类抛出了检查异常Exception，子类抛出的IOException是Exception的子类，也即是比被重写的方法抛出了更有限的异常，这是可以的。如果反过来，父类抛出IOException，子类抛出更为宽泛的Exception，那么不会通过编译的。

注意：这种限制只是针对检查异常，至于运行时异常RuntimeException及其子类不再这个限制之中。

E、重写规则之五：不能重写被标识为final的方法。

F、重写规则之六：如果一个方法不能被继承，则不能重写它。

　　比较典型的就是父类的private方法。下例会产生一个有趣的现象。

复制代码

   public class Test {

       public static void main (String[] args) {

           //Animal h = new Horse();

           Horse h = new Horse();

           h.eat();

       }

   }

   class Animal {

       private void eat(){

           System.out.println ("Animal is eating.");

       }

   }

   class Horse extends Animal{

       public void eat(){

           System.out.println ("Horse is eating.");

       }

   }

复制代码

　　这段代码是能通过编译的。表面上看来违反了第六条规则，但实际上那是一点巧合。Animal类的eat()方法不能被继承，因此Horse类中的 eat()方法是一个全新的方法，不是重写也不是重载，只是一个只属于Horse类的全新的方法！这点让很多人迷惑了，但是也不是那么难以理解。

　　main()方法如果是这样：

   Animal h = new Horse();

   //Horse h = new Horse();

   h.eat();

　　编译器会报错，为什么呢？Horse类的eat()方法是public的啊！应该可以调用啊！请牢记，多态只看父类引用的方法，而不看子类对象的方法！

方法的重载

　　重载是友好的，它不要求你在调用一个方法之前转换数据类型，它会自动地寻找匹配的方法。方法的重载是在编译时刻就决定调用哪个方法了，和重写不同。最最常用的地方就是构造器的重载。

1、基本数据类型参数的重载。

复制代码

   public class Test {

       static void method(byte b){

           System.out.println ("method:byte");

       }

       static void method(short s){

           System.out.println ("method:short");

       }

       static void method(int i){

           System.out.println ("method:int");

       }

       static void method(float f){

           System.out.println ("method:float");

       }

       static void method(double d){

           System.out.println ("method:double");

       }

       public static void main (String[] args) {

           method((byte)1);

           method('c');

           method(1);

           method(1L);

           method(1.1);

           method(1.1f);

       }

   }

复制代码

输出结果：

复制代码

method:byte

method:int

method:int

method:float

method:double

method:float

复制代码

　　可以看出：首先要寻找的是数据类型正好匹配方法。如果找不到，那么就提升为表达能力更强的数据类型，如上例没有正好容纳long的整数类型，那么就转换为 float类型的。如果通过提升也不能找到合适的兼容类型，那么编译器就会报错。反正是不会自动转换为较小的数据类型的，必须自己强制转换，自己来承担转变后果。

　　char类型比较特殊，如果找不到正好匹配的类型，它会转化为int而不是short，虽然char是16位的。

2、重载方法的规则。

A、被重载的方法必须改变参数列表。

参数必须不同，这是最重要的！不同有两个方面，参数的个数，参数的类型，参数的顺序。

B、被重载的方法与返回类型无关。

也就是说，不能通过返回类型来区分重载方法。

C、被重载的方法可以改变访问修饰符。

没有重写方法那样严格的限制。

D、被重载的方法可以声明新的或者更广的检查异常。

没有重写方法那样严格的限制。

E、方法能够在一个类中或者在一个子类中被重载。

3、带对象引用参数的方法重载。

复制代码

   class Animal {}

   class Horse extends Animal{}

   public class Test {

       static void method(Animal a){

           System.out.println ("Animal is called.");

       }

       static void method(Horse h){

           System.out.println ("Horse is called.");

       }

       public static void main (String[] args) {

           Animal a = new Animal();

           Horse h = new Horse();

           Animal ah = new Horse();

           method(a);

           metho