本文详细介绍了Java中的继承和多态概念，包括继承的作用、实现方式及其带来的代码复用性和类层次结构清晰的优点；同时深入探讨了多态的定义、实现方法（如方法重载与重写），并通过具体实例展示了多态的应用。
-----------------------------------------------个人初学，如有错误，欢迎指正-----------------------------------------------
Java学习笔记之继承和多态
一、简介
面向对象的三大特征就是封装、继承和多态。本篇博文主要介绍后两者，即继承和多态。内容主要有：
1、继承的定义以及使用
2、继承的程序实例
3、多态的定义以及实现
4、多态程序实例
二、继承
2.1什么是继承
继承是使用已存在的类作为基础来建立新类，可以理解为一个对象从另一个对象获取属性的过程。在Java中，类的继承是单继承，即一个子类只能拥有一个父类。比如，类A继承自类B，我们可以把B类称作A类的父类，A类称为B类的子类，与此同时，类A则不能再有其他父类(单继承)。
2.2继承是用来做什么的
从上面的定义可以看出来，继承是使用已存在的类作为基础来建立新类，既然有基础，那当然比从0开始重新建立一个类要高效，所以：
1、继承可以提高代码的复用性，减少代码冗余
2、继承是树形结构，这可以很清晰的体现出类的层次关系
3、继承是实现多态的前提
下面举一个例子：
//定义一个鸟类
public class Bird {
public static void main(String[] args) {
Waterfowl w = new Waterfowl();
w.Fly();//继承父类飞行技能
w.Sleep();//继承父类睡眠技能
w.Swimming();//自己独特的技能
}
//飞行
public void Fly(){
System.out.println("鸟类会飞！");
}
//觅食
public void Eat(){
System.out.println("鸟会觅食！");
}
//睡觉
public void Sleep(){
System.out.println("鸟会睡觉！");
}
}
//水鸟，继承自鸟类
class Waterfowl extends Bird{
public void Swimming(){
System.out.println("水鸟会游泳！");
}
} 鸟类会飞！
鸟会睡觉！
水鸟会游泳！
虽然水鸟类Waterfowl类实体内并没有定义飞行以及睡觉等方法，但是因为它与父类Bird的继承关系，所以父类的公用方法子类就可以公用，这样子类Waterfowl就不用再写代码去实现飞行和睡觉等功能了，代码的冗余度就会降低。那么，如果子类要重新定义飞行功能呢，那么就用到多态的。
鸟会睡觉！
水鸟会游泳！
虽然水鸟类Waterfowl类实体内并没有定义飞行以及睡觉等方法，但是因为它与父类Bird的继承关系，所以父类的公用方法子类就可以公用，这样子类Waterfowl就不用再写代码去实现飞行和睡觉等功能了，代码的冗余度就会降低。那么，如果子类要重新定义飞行功能呢，那么就用到多态的。
三、多态
3.1什么是多态
多态是允许程序不同类的对象，对同一消息做出响应。可以理解为，程序发出指令后，类对象(函数)可以有多种不同的响应方式(返回结果)。
3.2如何实现多态
1、同一个类中，对方法进行重载
2、继承父类，对父类的子方法进行重写
下面是小例子：
//同一个类中，对方法Add重载
public class ExampleDemo {
public static void main(String[] args) {
Add(1,2);
Add(1.5,2.5);
Add(1.5,1);
Add(2,3.5);
Add("hello",9573);
Add(9573,"ABC");
}
public static void Add(int a,int b){
System.out.println("整数运算："+a+"+"+b+" = "+(a+b));
}
public static void Add(double a, double b){
System.out.println("小数运算："+a+"+"+b+" = "+(a+b));
}
public static void Add(double a, int b){
System.out.println("混合运算："+a+"+"+b+" = "+(a+b));
}
public static void Add(int a, double b){
System.out.println("混合运算："+a+"+"+b+" = "+(a+b));
}
public static void Add(String a, int b){
System.out.println("字符与数字连接："+a+"+"+b+" = "+a+b);
}
public void Add(int a, String b){
System.out.println("字符与数字连接："+a+"+"+b+" = "+a+b);
}
}运行结果：
整数运算：1+2 = 3
小数运算：1.5+2.5 = 4.0
混合运算：1.5+1 = 2.5
混合运算：2+3.5 = 5.5
字符与数字连接：hello+9573 = hello9573
字符与数字连接：9573+ABC = 9573ABC
小数运算：1.5+2.5 = 4.0
混合运算：1.5+1 = 2.5
混合运算：2+3.5 = 5.5
字符与数字连接：hello+9573 = hello9573
字符与数字连接：9573+ABC = 9573ABC
可以看到，对方法Add发送相同的消息，即都是进行加法运算，但程序都能给出相应不同结果。
第二个例子：
//子类A继承父类ExampleDemo，重写Add方法
class A extends ExampleDemo{
//当字符与数字混合运算时，将字符串反转后与数字连接再打印
public static void Add(int a,String b){
StringBuffer sb = new StringBuffer();
sb.append(b);
System.out.println(b+"反转后"+sb.reverse());
System.out.println(a+"+"+b+" = "+a+sb.toString());
}
public static void Add(String a, int b){
StringBuffer sb = new StringBuffer();
sb.append(a);
System.out.println(a+"反转后"+sb.reverse());
System.out.println(a+"+"+b+" = "+sb.toString()+b);
}
}
//子类B继承父类ExampleDemo，重写Add方法
class B extends ExampleDemo{
//当字符与数字混合运算时，将数字反转后与字符串连接再打印
public static void Add(int a,String b){
StringBuffer sb = new StringBuffer();
sb.append(a);
System.out.println(a+"反转后"+sb.reverse());
System.out.println(a+"+"+b+" = "+sb.toString()+b);
}
public static void Add(String a, int b){
StringBuffer sb = new StringBuffer();
sb.append(b);
System.out.println(b+"反转后"+sb.reverse());
System.out.println(a+"+"+b+" = "+a+sb.toString());
}
}
public static void main(String[] args) {
ExampleDemo E = new ExampleDemo();
ExampleDemo eA = new A();
ExampleDemo eB = new B();
A a = new A();
B b = new B();
E.Add("hello",9573);//1
eA.Add("hello",9573);//2
eB.Add("hello",9573);//3
a.Add("hello",1234);//4
a.Add(1.2, 2.8);//5
b.Add("hello",1234);//6
b.Add(1, 3.5);//7
}
去掉父类方法Add的Static关键字后：
public class ExampleDemo {
public static void main(String[] args) {
ExampleDemo E = new ExampleDemo();
ExampleDemo eA = new A();
ExampleDemo eB = new B();
A a = new A();
B b = new B();
E.Add("hello",9573);//1
eA.Add("hello",9573);//2
eB.Add("hello",9573);//3
a.Add("hello",1234);//4
a.Add(1.2, 2.8);//5
b.Add("hello",1234);//6
b.Add(1, 3.5);//7
}
public void Add(int a,int b){
System.out.println("整数运算："+a+"+"+b+" = "+(a+b));
}
public void Add(double a, double b){
System.out.println("小数运算："+a+"+"+b+" = "+(a+b));
}
public void Add(double a, int b){
System.out.println("混合运算："+a+"+"+b+" = "+(a+b));
}
public void Add(int a, double b){
System.out.println("混合运算："+a+"+"+b+" = "+(a+b));
}
public void Add(String a, int b){
System.out.println("字符与数字连接："+a+"+"+b+" = "+a+b);
}
public void Add(int a, String b){
System.out.println("字符与数字连接："+a+"+"+b+" = "+a+b);
}
}
//子类A继承父类ExampleDemo，重写Add方法
class A extends ExampleDemo{
//当字符与数字混合运算时，将字符串反转后与数字连接再打印
public void Add(int a,String b){
StringBuffer sb = new StringBuffer();
sb.append(b);
System.out.println(b+"反转后"+sb.reverse());
System.out.println(a+"+"+b+" = "+a+sb.toString());
}
public void Add(String a, int b){
StringBuffer sb = new StringBuffer();
sb.append(a);
System.out.println(a+"反转后"+sb.reverse());
System.out.println(a+"+"+b+" = "+sb.toString()+b);
}
}
//子类B继承父类ExampleDemo，重写Add方法
class B extends ExampleDemo{
//当字符与数字混合运算时，将数字反转后与字符串连接再打印
public void Add(int a,String b){
StringBuffer sb = new StringBuffer();
sb.append(a);
System.out.println(a+"反转后"+sb.reverse());
System.out.println(a+"+"+b+" = "+sb.toString()+b);
}
public void Add(String a, int b){
StringBuffer sb = new StringBuffer();
sb.append(b);
System.out.println(b+"反转后"+sb.reverse());
System.out.println(a+"+"+b+" = "+a+sb.toString());
}
}
关于重载和重写的区别：
1、重载要求方法在参数的个数，顺序，类型上至少有一个不同。重写则必须遵照父类的方法参数，不能做更改。
2、重载时类内部之间的关系，重写是类与类的关系。重写则必须有继承关系，而且，不能扩大父类方法的范围，比如父类的方法时私有的(Private)，子类重写的时候，不能将方法改为公用的(Public)或者保护的(Protected)。如果父类的方法抛出异常，则子类不能比父类抛出更多的异常。简而言之，重写只能缩小范围，不能扩大范围。
扫一扫
1674
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
