重写和重载

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

[java]  view plain  copy

1. class Animal {  
2.       public void eat(){  
3.           System.out.println ("Animal is eating.");  
4.       }  
5.   }  
6.    
7.   class Horse extends Animal{  
8.       public void eat(){  
9.           System.out.println ("Horse is eating.");  
10.       }  
11.   }  

2、对于从父类继承来的抽象方法，要么在子类用重写的方式设计该方法，要么把子类也标识为抽象的。所以抽象方法可以说是必须要被重写的方法。
3、重写的意义。
重写方法可以实现多态，用父类的引用来操纵子类对象，但是在实际运行中对象将运行其自己特有的方法。

[java]  view plain  copy

1. public class Test {  
2.       public static void main (String[] args) {  
3.           Animal h = new Horse();  
4.           h.eat();    
5.       }  
6.   }  
7.   
8.   class Animal {  
9.       public void eat(){  
10.           System.out.println ("Animal is eating.");  
11.       }  
12.   }  
13.    
14.   class Horse extends Animal{  
15.       public void eat(){  
16.           System.out.println ("Horse is eating.");  
17.       }  
18.       public void buck(){  
19.       }  
20.   }  

一个原则是：使用了什么引用，编译器就会只调用引用类所拥有的方法。如
4、重写方法的规则。
若想实现一个合格重写方法，而不是重载，那么必须同时满足下面的要求！
A、重写规则之一：重写方法不能比被重写方法限制有更严格的访问级别。
（但是可以更广泛，比如父类方法是包访问权限，子类的重写方法是public访问权限。）
比如：Object类有个toString()方法，开始重写这个方法的时候我们总容易忘记public修饰符，编译器当然不会放过任何教训我们的机会。出错的原因就是：没有加任何访问修饰符的方法具有包访问权限，包访问权限比
B、重写规则之二：参数列表必须与被重写方法的相同。
C、重写规则之三：返回类型必须与被重写方法的返回类型相同。
父类方法A：void eat(){} 子类方法B：int eat(){} 两者虽然参数相同，可是返回类型不同，所以不是重写。
父类方法A：int eat(){}    子类方法B：long eat(){} 返回类型虽然兼容父类，但是不同就是不同，所以不是重写。
D、重写规则之四：重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少，更有限或者不抛出异常。

[java]  view plain  copy

1. import java.io.*;  
2.  public class Test {  
3.      public static void main (String[] args) {  
4.          Animal h = new Horse();  
5.          try {  
6.              h.eat();    
7.          }  
8.          catch (Exception e) {  
9.          }  
10.      }  
11.  }  
12.   
13.  class Animal {  
14.      public void eat() throws Exception{  
15.          System.out.println ("Animal is eating.");  
16.          throw new Exception();  
17.      }  
18.  }  
19.   
20.  class Horse extends Animal{  
21.      public void eat() throws IOException{  
22.          System.out.println ("Horse is eating.");  
23.          throw new IOException();  
24.      }  
25.  }  

这个例子中，父类抛出了检查异常Exception，子类抛出的IOException是Exception的子类，也即是比被重写的方法抛出了更有限的异常，这是可以的。如果反过来，父类抛出IOException，子类抛出更为宽泛的Exception，那么不会通过编译的。
注意：这种限制只是针对检查异常，至于运行时异常RuntimeException及其子类不再这个限制之中。
E、重写规则之五：不能重写被标识为final的方法。
F、重写规则之六：如果一个方法不能被继承，则不能重写它。
比较典型的就是父类的private方法。下例会产生一个有趣的现象。

[java]  view plain  copy

1. public class Test {  
2.        public static void main (String[] args) {  
3.            //Animal h = new Horse();  
4.            Horse h = new Horse();  
5.            h.eat();  
6.        }  
7.    }  
8.   
9.    class Animal {  
10.        private void eat(){  
11.            System.out.println ("Animal is eating.");  
12.        }  
13.    }  
14.     
15.    class Horse extends Animal{  
16.        public void eat(){  
17.            System.out.println ("Horse is eating.");  
18.        }  

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

[java]  view plain  copy

1. Animal h = new Horse();  
2.    //Horse h = new Horse();  
3.    h.eat();  

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

[java]  view plain  copy

1. public class Test {  
2.        static void method(byte b){  
3.            System.out.println ("method:byte");  
4.        }  
5.        static void method(short s){  
6.            System.out.println ("method:short");  
7.        }  
8.        static void method(int i){  
9.            System.out.println ("method:int");  
10.        }  
11.        static void method(float f){  
12.            System.out.println ("method:float");  
13.        }  
14.        static void method(double d){  
15.            System.out.println ("method:double");  
16.        }  
17.        public static void main (String[] args) {  
18.            method((byte)1);  
19.            method('c');  
20.            method(1);  
21.            method(1L);  
22.            method(1.1);  
23.            method(1.1f);  
24.        }  
25.    }  

输出结果：
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、带对象引用参数的方法重载。

[java]  view plain  copy

1. class Animal {}  
2.    class Horse extends Animal{}  
3.     
4.    public class Test {  
5.        static void method(Animal a){  
6.            System.out.println ("Animal is called.");  
7.        }  
8.        static void method(Horse h){  
9.            System.out.println ("Horse is called.");  
10.        }  
11.        public static void main (String[] args) {  
12.            Animal a = new Animal();  
13.            Horse h = new Horse();  
14.            Animal ah = new Horse();  
15.             
16.            method(a);  
17.            method(h);  
18.            method(ah);  
19.         }  
20.    }  

输出结果是：
Animal is called.
Horse is called.
Animal is called.
前两个输出没有任何问题。第三个方法为什么不是输出“Horse is called.”呢？还是那句老话，要看引用类型而不是对象类型，方法重载是在编译时刻就决定的了，引用类型决定了调用哪个版本的重载方法。
4、重载和重写方法区别的小结。
如果能彻底弄明白下面的例子，说明你对重载和重写非常了解了，可以结束这节的复习了。

[java]  view plain  copy

1. class Animal {  
2.       public void eat(){  
3.           System.out.println ("Animal is eating.");    
4.       }  
5.   }  
6.   class Horse extends Animal{  
7.       public void eat(){  
8.           System.out.println ("Horse is eating.");    
9.       }  
10.       public void eat(String food){  
11.           System.out.println ("Horse is eating " + food);  
12.       }  
13.   }  
14.    
15.   public class Test {  
16.       public static void main (String[] args) {  
17.           Animal a = new Animal();  
18.           Horse h = new Horse();  
19.           Animal ah = new Horse();  
20.            
21.           a.eat();  
22.           h.eat();  
23.           h.eat("apple");  
24.           ah.eat();  
25.           //a.eat("apple");  
26.           //ah.eat("apple");  
27.        }  
28.   }  

四个输出分别是什么？被注释的两条语句为什么不能通过编译？
第一条：a.eat(); 普通的方法调用，没有多态，没什么技术含量。调用了Animal类的eat()方法，输出：Animal is eating.
第二条：h.eat(); 普通的方法调用，也没什么技术含量。调用了Horse类的eat()方法，输出：Horse is eating.
第三条：h.eat("apple"); 重载。Horse类的两个eat()方法重载。调用了Horse类的eat(String food)方法，输出：Horse is eating apple
第四条：ah.eat(); 多态。前面有例子了，不难理解。输出：Horse is eating.
第五条：a.eat("apple"); 低级的错误，Animal类中没有eat(String food)方法。因此不能通过编译。
第六条：ah.eat("apple"); 关键点就在这里。解决的方法还是那句老话，不能看对象类型，要看引用类型。Animal类中没有eat(String food)方法。因此不能通过编译。
小结一下：多态不决定调用哪个重载版本；多态只有在决定哪个重写版本时才起作用。
重载对应编译时，重写对应运行时。
三、静态方法的重载与重写（覆盖）。
1、静态方法是不能被覆盖的。可以分两种情况讨论：
A、子类的非静态方法“覆盖”父类的静态方法。
这种情况下，是不能通过编译的。

[java]  view plain  copy

1. class Father{  
2.      static void print(){  
3.          System.out.println ( " in father   method " );  
4.      }  
5. }  
6. class Child extends Father{  
7.      void print(){  
8.          System.out.println ( " in child method " );  
9.      }  
10. }  

static方法表示该方法不关联具体的类的对象，可以通过类名直接调用，也就是编译的前期就绑定了，不存在后期动态绑定，也就是不能实现多态。子类的非静态方法是与具体的对象绑定的，两者有着不同的含义。
B、子类的静态方法“覆盖”父类静态方法。
这个覆盖依然是带引号的。事实上把上面那个例子Child类的print方法前面加上static修饰符，确实能通过编译！但是不要以为这就是多态！多态的特点是动态绑定，看下面的例子：

[java]  view plain  copy

1. class Father{  
2.      static void print(){  
3.          System.out.println ( " in father   method " );  
4.      }  
5. }  
6. class Child extends Father{  
7.      static void print(){  
8.          System.out.println ( " in child method " );  
9.      }  
10. }  
11.   
12. class Test{  
13.      public static void main (String[] args) {  
14.          Father f = new Child();  
15.          f.print();  
16.      }  
17. }  

输出结果是：in father method
从这个结果可以看出，并没有实现多态。
但是这种形式很迷惑人，貌似多态，实际编程中千万不要这样搞，会把大家搞懵的！
它不符合覆盖表现出来的特性，不应该算是覆盖！
总而言之，静态方法不能被覆盖。
2、静态方法可以和非静态方法一样被重载。
这样的例子太多了，我不想写例程了。看看java类库中很多这样的例子。
如java.util.Arrays类的一堆重载的binarySearch方法。
在这里提一下是因为查资料时看到这样的话“sun的SL275课程说，静态方法只能控制静态变量（他们本身没有），静态方法不能被重载和覆盖……”
大家不要相信啊！可以重载的。而且静态与非静态方法可以重载。
从重载的机制很容易就理解了，重载是在编译时刻就决定的了，非静态方法都可以，静态方法怎么可能不会呢？ 

=================================================================

方法覆盖必须满足下列条件

(1) 子类的方法的名称及参数必须和所覆盖的方法相同

(2) 子类的方法返回类型必须和所覆盖的方法相同

(3) 子类方法不能缩小所覆盖方法的访问权限

(4) 子类方法不能抛出比所覆盖方法更多的异常

重载方法必须满足下列条件

(1) 方法名必须相同

(2) 方法的参数签名必须相同

(3) 方法的返回类型和方法的修饰符可以不相同

 顺便说说方法覆盖和重载的区别

初次见到这两个单词并没有什么特别的感觉，但是时间长了，却发现书上一会儿用override，一会儿又用overload，搞得我的迷迷糊。于是就做了个总结，希望能对和我一样对这两个概念模糊不清的网友有一个帮助。
override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

四、方法重写与方法重载的区别
通过上面例子的分析，我们可以将方法重写和重载的区别总
结成这样一个表格，如下：

区别点	重载	重写（覆写）
英文	Overloading	Overiding
定义	方法名称相同，参数的类型或个数不同	方法名称、参数类型、返回值类型全部相同
	对权限没有要求	被重写的方法不能拥有更严格的权限
范围	发生在一个类中	发生在继承类中

 五、示例

1. public class Java10_2 extends Person  
2. {  
3.     public Java10_2()  
4.     {  
5.         System.out.println("My name is "+this.name+" I am "+this.age+" years old"+" and I like "+this.like);  
6.     }  
7.     public Java10_2(String str,int i,String str1)  
8.     {  
9.         this.name=str;  
10.         this.age=i;  
11.         this.like=str1;  
12.         System.out.println("My name is "+this.name+" I am "+this.age+" years old"+" and I like "+this.like);  
13.     }  
14.     public void ask()  
15.     {  
16.         System.out.println("We like her!");  
17.         super.ask();  
18.     }  
19.     public static void main(String args[])  
20.     {  
21.         Java10_2 java=new Java10_2();  
22.         Java10_2 java1=new Java10_2("张雪",23,"sing");  
23.         java1.ask();  
24.     }  
25. }  
26. class Person   
27. {  
28.     String name;  
29.     int age;  
30.     String like;   
31.     public void ask()  
32.     {  
33.         System.out.println("Do you like her?");  
34.     }  
35. }