之前的文章我們介紹了一下 Java 中的繼承，接下來我們繼續看一下 Java 中的繼承。

在有些時候，我們通過類繼承的方式可以獲取父類的方法，但是有些時候父類為我們提供的方法並不完全符合我們的需求，這時候我們就要對類方法進行重寫，如下：

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         Student student = new Student();
 4         student.name = "張三";
 5         student.age = 18;
 6         student.city = "北京";
 7         student.userInfo(); // 我叫張三，今年18歲
 8 
 9         Teacher teacher = new Teacher();
10         teacher.name = "李四";
11         teacher.age = 28;
12         teacher.city = "上海";
13         teacher.userInfo(); // 我叫李四，今年28歲，來自上海
14     }
15 }
16 
17 class Person {
18     String name;
19     int age;
20 
21     void userInfo() {
22         System.out.println("我叫" + name + "，今年" + age + "歲");
23     }
24 }
25 
26 class Student extends Person {
27     String city;
28 }
29 
30 class Teacher extends Person {
31     String city;
32 
33     void userInfo() {
34         System.out.println("我叫" + name + "，今年" + age + "歲，" + "來自" + city);
35     }
36 }

在上面的程式碼中，我們分別定義了 Student 和 Teacher 兩個列，且都繼承了 Person 類，不同的是我們在 Teacher 類中定義了一個和父類 Person 類相同的 userInfo() 方法，方法中發發明和引數相同，方法體不同，這其實就是類方法的重寫。

重寫需要遵循“兩同兩小一大”原則（一般都是相同）：

1、兩同

　　1）、方法名稱相同

　　　　1>、void 和 基本型別時子類和父類必須相同

　　　　2>、引用型別時子類必須小於或等於父類

　　2）、引數列表相同

2、兩小：

　　1）、子類方法的返回值型別小於或等於父類

　　2）、子類方法所丟擲的異常小於或等於父類

3、一大

　　1）、子類的訪問許可權大於或等於父類

上面的例子我們其實已經說了“兩同”了，下面我們看一下“兩小”中的 子類方法的返回值型別小於或等於父類

 1 class Person {
 2     String name;
 3     int age;
 4 
 5     void userInfo() {
 6         System.out.println("我叫" + name + "，今年" + age + "歲");
 7     }
 8 
 9     double num(){ return 1.23; }
10 
11     Person person(){ return null; }
12 
13     Student student(){ return null; }
14 }
15 
16 class Student extends Person {
17 
18     double num(){ return 4.56; }
19 
20 //    int num(){ return 8; }  編譯錯誤，基本型別必須相同
21 
22     Student person(){ return null; }
23 
24 //    Person student(){ return null; } 編譯錯誤，引用型別時必須小於或等於父類
25 }·

方法重寫（Override）很容易讓我們想起來之前說過的方法過載（Overload），我們再來看一下之前說過的過載。

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         Aoo aoo = new Aoo(); // 建立一個 Aoo 物件
 4         aoo.foo(); // foo 無參
 5         aoo.foo(123); // foo 整型引數123
 6         aoo.foo("abc"); // foo 字串引數zhangsan
 7         aoo.foo("abc",123); // foo 字串+整型引數abc123
 8         aoo.foo(123,"abc"); // foo foo 整型+字串引數123abc
 9     }
10 }
11 
12 class Aoo {
13     void foo() {
14         System.out.println("foo 無參");
15     }
16 
17     void foo(int num) {
18         System.out.println("foo 整型引數" + num);
19     }
20 
21     void foo(String str) {
22         System.out.println("foo 字串引數" + str);
23     }
24 
25     void foo(String str, int num) {
26         System.out.println("foo 字串+整型引數" + str + num);
27     }
28 
29     void foo(int num, String str) {
30         System.out.println("foo 整型+字串引數" + num + str);
31     }
32 }

過載規則:

• 被過載的方法必須改變引數列表(引數個數或型別不一樣)；
• 被過載的方法可以改變返回型別；
• 被過載的方法可以改變訪問修飾符；
• 被過載的方法可以宣告新的或更廣的檢查異常；
• 方法能夠在同一個類中或者在一個子類中被過載。
• 無法以返回值型別作為過載函式的區分標準。

重寫與過載之間的區別

方法的重寫(Overriding)和過載(Overloading)是java多型性的不同表現，重寫是父類與子類之間多型性的一種表現，過載可以理解成多型的具體表現形式。

• (1)方法過載是一個類中定義了多個方法名相同,而他們的引數的數量不同或數量相同而型別和次序不同,則稱為方法的過載(Overloading)。
• (2)方法重寫是在子類存在方法與父類的方法的名字相同,而且引數的個數與型別一樣,返回值也一樣的方法,就稱為重寫(Overriding)。
• (3)方法過載是一個類的多型性表現,而方法重寫是子類與父類的一種多型性表現。

過載和重寫可以用下面這張圖來形象的表示。過載我們可以認為是多種表現形式，每種表現形式都能實現自己的功能。重寫是在原有基礎上加強自己的功能。

&n