韩顺平循序渐进学java 第10.11讲继承.重载.覆盖

10.1 继承-四大特征之三

10.1.1 概念

继承可以解决代码复用，让编程更加接近人类思维。当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类（比如刚才的Student），在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来声明继承父类：

class 子类 extends 父类

这样，子类就会自动拥有父类的定义的属性和方法。

10.1.2 注意

注意：父类的public修饰符的属性和方法，protected修饰符的属性和方法，默认修饰符的属性和方法被子类继承了，但是父类的private修饰符的属性和方法不能被子类继承。

10.1.3 说明

1、子类最多只能继承一个父类（指直接继承）；

2、Java中所有类都是Object类的子类；

3、JDK6中有202个包，3777个类、接口、异常、枚举、注释和错误；

4、在做开发时，强烈建议多查看jdk帮助文档；

5、在使用类时，实在不知道怎么办，google之。

10.2 方法重载（overload）

10.2.1 引出问题

编写一个类，编写方法可以接收两个整数，返回两个数中较大的数。

问题1：如果要求可以接收两个float型的数，返回较大数？

问题2：如果要求可以接收三个int型的数，返回较大数？

10.2.2 概念

方法重载就是类的一种功能的多种实现方式，到底采用哪种方式，取决于调用者给出的参数。

10.2.3 注意事项

1、方法名相同；

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

3、只是方法返回类型不一样，不能构成重载；

4、只是方法修饰符不一样，也不能构成重载。

10.3 方法覆盖（override）

10.3.1 引出问题

子类可以继承父类的属性和方法，这样可以提高代码的复用性。假设要求大家些三个类猫、狗、猪，这三个都是动物，动物必然存在相同的特点。首先我们根据类的抽象特征，将它们的相同点提取出来，形成一个父类Animal，然后继承。

问题来了，怎么解决父类和子类方法的异同！

10.3.2 概念

方法覆盖就是子类有一个方法，和父类的某个方法的返回类型、名称、参数一样，那么就说子类的方法覆盖了父类的那个方法。

10.3.3 注意事项

1、子类的方法的返回类型、方法名称、参数要和父类方法的完全一样。

2、子类方法不能缩小父类方法的访问权限。

方法重载代码演示：

 1 /**日期：2016-03-04
 2  * 功能：方法重载的演示
 3  */
 4 public class Practice1
 5 {
 6     public static void main(String []args)
 7     {
 8         Abc abc1=new Abc();
 9         System.out.println(abc1.getMax(5,4));
10     }
11 }
12
13 class Abc
14 {
15     public int getMax(int a,int b)
16     {
17         if(a>b)
18         {
19             return a;
20         }else
21         {
22             return b;
23         }
24     }
25     public float getMax(float a,int b) //参数的类型不同
26     {
27         if(a>b)
28         {
29             return a;
30         }else
31         {
32             return b;
33         }
34     }
35 }

方法覆盖代码演示：

 1 /**日期：2016-03-04
 2  * 功能：方法覆盖的演示
 3  */
 4 public class Practice2
 5 {
 6     public static void main(String []args)
 7     {
 8         //普通方法如下：
 9         Cats cat=new Cats();
10         cat.cry();
11         Dogs dog=new Dogs();
12         dog.cry();
13         //多态方法如下：
14         Animals an=new Cats(); //这里也体现了多态
15         an.cry(); //这里也体现了多态
16         an=new Dogs();
17         an.cry(); //这里体现出多态的优势，就是可以用Animals实例化一次，
18         //多次调用Animals的子类；如果不用多态，用到狗时要实例化个狗，
19         //用到猫时要实例化个猫，如果子类非常多的时候会非常麻烦。
20     }
21 }
22
23 class Animals
24 {
25     public void cry()
26     {
27         System.out.println("不知道什么动物叫！");
28     }
29 }
30
31 class Cats extends Animals
32 {
33     public void cry()
34     {
35         System.out.println("喵喵叫！");
36     }
37 }
38
39 class Dogs extends Animals
40 {
41     public void cry()
42     {
43         System.out.println("汪汪叫！");
44     }
45 }

运行结果：

1 喵喵叫！
2 汪汪叫！
3 喵喵叫！
4 汪汪叫！

转载于:https://www.cnblogs.com/PistonType/p/5243873.html