【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就不用再写代码去实现飞行和睡觉等功能了，代码的冗余度就会降低。那么，如果子类要重新定义飞行功能呢，那么就用到多态的。

三、多态

        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

可以看到， 对 方法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)。如果父类的方法抛出异常，则子类不能比父类抛出更多的异常。简而言之，重写只能缩小范围，不能扩大范围。