Java 从入门到进阶之路（十一）

以前的文章咱们介绍了一下 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>、void 和 基本类型时子类和父类必须相同

　　　　2>、引用类型时子类必须小于或等于父类

　　2）、参数列表相同

二、两小：

　　1）、子类方法的返回值类型小于或等于父类

　　2）、子类方法所抛出的异常小于或等于父类

三、一大

　　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)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

重载和重写能够用下面这张图来形象的表示。重载咱们能够认为是多种表现形式，每种表现形式都能实现本身的功能。重写是在原有基础上增强本身的功能。