Java多态详解

Posted 2023-04-07 无贪则喜

目录

• 1. 基本介绍
• • 1.1 多态的概念
  • 1.2 多态的具体体现
  • 1.3 入门案例
• 2. 多态的转型
• • 2.1 向上转型
  • 2.2 向下转型
  • 2.3 代码示例
  • 2.4 转型的异常
  • • 2.4.1 类型转换异常
    • 2.4.2 instanceof 比较操作符
• 3.动态绑定（重点）
• 4. 应用
• • 4.1 多态数组
  • 4.2 多态参数
• 5. 多态的优点

1. 基本介绍

1.1 多态的概念

• 多态是方法或对象具有多种形态，是面向对象的第三大特征。
• 多态的前提是两个对象（类）存在继承关系，多态是建立在封装和继承基础之上的。

1.2 多态的具体体现

对象的多态是多态的核心和重点。

规则：

• 一个对象的编译类型与运行类型可以不一致
• 编译类型在定义对象时，就确定了，不能改变，而运行类型是可以变化的
• 编译类型看定义对象时 = 号的左边，运行类型看 = 号的右边

1.3 入门案例

说明：

• 定义一个 Person 类 作为父类，定义 Student 类 和 Teacher 类作为子类继承父类；
• Person 类 拥有 mission() 方法；
• Student 类 和 Teacher 类 重写父类的 mission() 方法；
• 最后在 main 函数中利用多态形式创建对象。

代码如下：

（1）定义父类 Person 类：

package Polymorphism;

public class Person 
	public void mission() 	
		System.out.println("人要好好活着！");
	

（2）定义子类 Student 类：

package Polymorphism;

public class Student extends Person 
	@Override
	public void mission() 	
		System.out.println("学生要好好学习！");
	

（3）定义子类 Teacher 类

package Polymorphism;

public class Teacher extends Person 
	@Override
	public void mission() 	
		System.out.println("老师要好好教书！");
	

（4）在 Test01 类中编写 main 函数，体现多态性

package Polymorphism;

//多态性
public class Test01 
	public static void main(String[] args) 
		//多态形式，创建对象
		//注意编译类型看等号左边，运行类型看等号右边
		Person p1 = new Student();  
		
		//此时调用的是 Student 类 的 mission() 方法
		p1.mission();
		
		//多态形式，创建对象
		Person p2 = new Teacher();
		
		//此时调用的是 Teacher 类 的 mission() 方法
		p2.mission();
	

（5）运行结果

学生要好好学习！
老师要好好教书！

2. 多态的转型

2.1 向上转型

1. 本质：父类的引用指向子类的对象

2. 特点：

• 编译类型看左边，运行类型看右边
• 可以调用父类的所有成员（需遵守访问权限）
• 不能调用子类的特有成员
• 运行效果看子类的具体实现

3. 语法：

父类类型 引用名 = new 子类类型();
//右侧创建一个子类对象，把它当作父类看待使用

2.2 向下转型

1. 本质：一个已经向上转型的子类对象，将父类引用转为子类引用

2. 特点：

• 只能强制转换父类的引用，不能强制转换父类的对象
• 要求父类的引用必须指向的是当前目标类型的对象
• 当向下转型后，可以调用子类类型中所有的成员

3. 语法：

子类类型 引用名 = (子类类型) 父类引用;
//用强制类型转换的格式，将父类引用类型转为子类引用类型

2.3 代码示例

说明：

• 定义一个 Person 类 作为父类，定义 Student 类 和 Teacher 类作为子类继承父类；
• Person 类 拥有 mission() 方法；
• Student 类 和 Teacher 类 重写父类的 mission() 方法 并且 分别拥有各自的特有的 score() 方法 和 salary() 方法；
• 最后在 main 函数中 演示转型。

代码如下：

（1）定义类：

package Poly_;

public class Person 
	public void mission() 	
		System.out.println("人要好好活着！");
	


class Student extends Person 	
	@Override
	public void mission() 	
		System.out.println("学生要好好学习！");
	
	
	public void score() 
		System.out.println("学生得到好成绩！");
	


class Teacher extends Person 
	@Override
	public void mission() 	
		System.out.println("老师要好好教书！");
	
	
	public void salary() 	
		System.out.println("老师得到高工资！");
	

（2）在 Test02 类中编写 main 函数，演示转型

package Poly_;

//转型演示
public class Test02 
	public static void main(String[] args) 
		//向上转型（自动类型转换）
		Person p1 = new Student();
		
		//调用的是 Student 的 mission
		p1.mission(); 
		
		//向下转型
		Student s1 = (Student)p1;
		
		//调用的是 Student 的 score
		s1.score();
	

（3）运行结果：

学生要好好学习！
学生得到好成绩！

2.4 转型的异常

2.4.1 类型转换异常

说明：使用强转时，可能出现异常，对2.3代码示例中的 Test02类 重新编写，演示转型异常

代码如下：

//异常演示
public class Test02 
	public static void main(String[] args) 
		//向上转型
		Person p1 = new Student();
		
		//调用的是 Student 的 mission
		p1.mission(); 
		
		//向下转型
		Teacher t1 = (Teacher) p1;
		
		//运行时报错
		p1.salary();
	

解释：这段代码在运行时出现了 ClassCastException 类型转换异常，原因是 Student 类与 Teacher 类 没有继承关系，因此所创建的是Student 类型对象在运行时不能转换成 Teacher 类型对象。

2.4.2 instanceof 比较操作符

为了避免上述类型转换异常的问题，我们引出 instanceof 比较操作符，用于判断对象的类型是否为XX类型或XX类型的子类型。

• 格式：对象 instanceof 类名称
• 解释：这将会得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的实例
• 代码示例 ：

package Poly_;

//演示 instanceof 的使用
public class Test03 
	public static void main(String[] args) 
		//向上转型
		Person p1 = new Student();
		
		//调用的是 Student 的 mission
		p1.mission();
		
		//向下转型
		//利用 instanceof 进行判断
		if(p1 instanceof Student) 	//判断对象 p1 是否是 Student 类 的实例
			Student s1 = (Student)p1;
			s1.score();  //调用的是 Student 的 score
			//上面这两句也可简写为 ((Student) p1).score();
		
		else if(p1 instanceof Teacher) //判断对象 p1 是否是 Teacher 类 的实例
			Teacher t1 = (Teacher)p1;
			t1.salary(); //调用的是 Teacher 的 salary
			//同理，上面这两句也可简写为 ((Teacher) p1).salary();
		
	

• 运行结果：

学生要好好学习！
学生得到好成绩！

3.动态绑定（重点）

• 当调用对象方法的时候，该方法会和该对象的运行类型绑定
• 当调用对象属性时，没有动态绑定机制，即哪里声明，哪里使用。
• 代码示例：

package dynamic_;

//演示动态绑定
public class DynamicBinding 
	public static void main(String[] args) 
		//向上转型（自动类型转换）
		//程序在编译阶段只知道 p1 是 Person 类型
		//程序在运行的时候才知道堆中实际的对象是 Student 类型	
		Person p1 = new Student();  
		
		//程序在编译时 p1 被编译器看作 Person 类型
		//因此编译阶段只能调用 Person 类型中定义的方法
		//在编译阶段，p1 引用绑定的是 Person 类型中定义的 mission 方法（静态绑定）
		//程序在运行的时候，堆中的对象实际是一个 Student 类型，而 Student 类已经重写了 mission 方法
		//因此程序在运行阶段对象中绑定的方法是 Student 类中的 mission 方法（动态绑定）
		p1.mission();
	


//父类
class Person 
	public void mission() 	
		System.out.println("人要好好活着！");
	


//子类
class Student extends Person 
	@Override
	public void mission() 	
		System.out.println("学生要好好学习！");
	

• 运行结果：

学生要好好学习！

4. 应用

4.1 多态数组

多态数组：数组的定义类型为父类类型，里面保存的实际元素类型为子类类型。
代码示例：（循环调用基类对象，访问不同派生类的方法）

1. 说明：

• 定义一个 Person 类 作为父类，定义 Student 类 和 Teacher 类 作为子类继承父类；
• Person 类 拥有 name(姓名) 属性 以及 mission() 方法；
• Student 类 和 Teacher 类 拥有各自特有的 score 和 salary 属性,，除此之外，重写父类的 mission() 方法 ；
• 要求：最后在 main 函数中 创建一个 Person 对象 、一个 Student 对象 和 一个 Teacher 对象，统一放在数组里，并调用每个对象的 mission() 方法。

2. 代码如下：

（1）父类 Person 类：

package polyarr;

public class Person 
	private String name;
	
	public Person(String name) 
		this.name = name;
	
	
	// getter 和 setter
	public String getName() 
		return name;
	
	public void setName(String name) 
		this.name = name;
	

	// mission() 方法
	public String mission() 	
		return name + "\\t" + "要好好活着";
	

（2）子类 Student 类

package polyarr;

public class Student extends Person 
	private double score;

	public Student(String name, double score) 
		super(name);
		this.score = score;
	

	public double getScore() 
		return score;
	

	public void setScore(double score) 
		this.score = score;
	
	
	//重写父类的say方法
	@Override
	public String mission() 	
		return super.mission() + " score =" + score + " 要好好学习！";
	

（3）子类 Teacher 类

package polyarr;

public class Teacher extends Person 
	private double salary;

	public Teacher(String name, double salary) 
		super(name);
		this.salary = salary;
	

	public double getSalary() 
		return salary;
	

	public void setSalary(double salary) 
		this.salary = salary;
	
	
	//重写父类的 mission 方法
	@Override
	public String mission() 	
		return super.mission() + " salary =" + salary + " 要好好教书！";
	

（4）PolyArray 类 中编写 main 函数

package polyarr;

/*
 * 演示多态数组
 * 创建一个 Person 对象 
 * 创建一个 Student 对象 
 * 创建一个 Teacher 对象
 * 统一放在数组里，并调用每个对象的 mission() 方法。
 */
public class PolyArray 
	public static void main(String[] args) 
		Person[] persons = new Person[3];
		persons[0] = new Person("小汤");
		persons[1] = new Student("小韬", 100);
		persons[2] = new Teacher("小蒲", 10000);
		
		//循环遍历多态数组，调用 mission
		for(int i = 0; i < persons.length; i++) 
			//此处涉及动态绑定机制
			// Person[i] 编译类型是 Person ,运行类型根据实际情况由 JVM 判断
			System.out.println(persons[i].mission());  
		
	

（5）运行结果：

小汤	要好好活着！
小韬	要好好活着！ score = 100.0 要好好学习！
小蒲	要好好活着！ salary = 10000.0 要好好教书！

4.2 多态参数

多态参数：方法定义的形参类型为父类类型，实参类型允许为子类类型。
代码示例：

1. 说明：

• 定义一个 Person 类 作为父类，定义 Student 类 和 Teacher 类作为子类继承父类；
• Person 类 拥有 name(姓名) 属性
• Student 类 和 Teacher 类 拥有各自 特有 的 study() 和 teach() 方法 ；
• 要求：最后在 main 函数中 编写 test() 方法 ，功能是调用 Student 类 的 study() 或 Teacher 类 的 teach() 方法，用于演示 多态参数 的使用。

2. 代码如下：

package polyparameter;

//演示多态参数
public class PolyParameter  
	public static void main(String[] args) 
		Student s1 = new Student("小蓝同学");
		Teacher t1 = new Teacher("小绿老师");
		
		//需先 new 一个当前类的实例化，才能调用 test 方法
		PolyParameter polyParameter = new PolyParameter();
		
		//实参是子类
		polyParameter.test(s1);
		polyParameter.test(t1);		
	

	//定义方法test，形参为 Person 类型(形参是父类)
	//功能：调用学生的study或教师的teach方法
	 public void test(Person p) 
        if (p instanceof Student)
            ((Student) p).study();   //向下转型
        
        else if (p instanceof Teacher)
            ((Teacher) p).teach();  //向下转型
          
	 

 
//父类
class Person 
	private String name;
	
	//有参构造
	public Person(String name) 
		this.name = name;
	
	
	// getter 和 setter
	public String getName() 
		return name;
	
	public void setName(String name) 
		this.name = name;
	


//子类
class Student extends Person 

	public Student(String name) 
		super(name);
	

	// study() 方法
	public void study() 	
		System.out.println(super.getName() + "\\t" + "正在好好学习");
	


class Teacher extends Person 

	public Teacher(String name) 
		super(name);
	

	// teach() 方法
	public void teach() 	
		System.out.println(super.getName() + "\\t" + "正在好好教书");
	

3. 运行结果：

小蓝同学	正在好好学习
小绿老师	正在好好教书

5. 多态的优点

• 代码更加灵活：无论右边new的时候换成哪个子类对象，等号左边调用方法都不会变化。
• 提高程序的拓展性：定义方法的时候，使用父类类型作为参数，将来使用时，使用具体的子类类型操作

Java中的封装，继承和多态（详解）

目录

• 封装
• 继承
• 多态
• • 接口
• 一些建议和小结
• 写在最后的话

封装

所谓的封装就是把类的属性和方法使用private修饰，不允许类的调用者直接访问，我们定义如下一个类，可以看到所有的成员变量和成员方法都使用private修饰了，我们现在来使用一下这个类。

当我们使用的时候编译器给出了下面这样的报错。
告诉我们说是private访问控制，那么这是什么意思呢？我们来看看另外一张图，那么这张图代表这什么呢？在看这张图之前，我们先来看看四者都提到的包，那么包又是什么呢，包可以简单理解为一个文件夹，把类放到放到包里面，也就相当于是专门的文件夹里面，这不是我们说的重点，知道就行，类都知道吧，不知道的先去看看博主这篇博客类和对象再回来继续往下。
ps：稍微记一下这张图中的内容。


有了上面的基础我们现在再来看private，他的使用范围只有 同一个包中的同一个类中使用（这个范围也就是他的权限），我们就记住只能在我们定义的那个类中使用就好了，别问为什么，因为这就是语法，记住就好了，记准确了是当前类中，不能外部引用，否则就会出现上面那样的报错。既然不能直接从外部引用，那么类的调用者总得有个办法使用吧，不然实现这个类干嘛，这个时候就是我们在设计类的时候要提供的公开的方法了，那么上述的代码应该写成如下形式。

ps：这里重写了toString方法才会是下面的输出形式。
上面就是调用了，那么有的读者可能就会问了，那你的eat方法还是private的呀，我还是不能调用啊，这里我解释一下，这是因为我是为了演示private的作用而在eat方法前面加的private，运行时我将它注释掉了，至于实际上像eat这样需要被类的调用者直接使用的方法，肯定是不能使用private修饰的，至于用什么访问权限修饰这就是类的设计者根据日后业务的需要而决定了。
封装的第一个作用就是为了不直接被外部使用，提高代码的安全性，第二个作用就是降低类的使用者的学习成本，不需要知道类的实现，只需要学会调用就好了，封装差不多就介绍完了，接下来聊聊继承。

继承

所谓继承本质就是实现代码的复用，防止重复的代码多次书写，当一个类继承一个类的时候，该类中就会拥有另外一个类中的所有代码，举个例子看下面代码

可以看到继承的语法形式是class 子类名 extends 父类名，继承类就是子类，也叫派生类，被继承的类称为父类，基类或者超类（名字一般不做区分，均可使用），语法形式很简单，我们来聊聊其中的细节，首先Java是单继承的， 一个子类只能有一个父类，但是一个子类可以当作另外一个类的父类，即可以B继承A，然后C继承B，代码如下，那么B会拥有A中的代码，C会拥有A、B的代码。

下面讲的普通类继承知识都是基于父类是公开的并单独位于一个.java文件的。
我们定义一个这样的Animal类当作父类：

当访问使用private修饰的属性时就会报错，这个就是上面封装的知识了，只能在定义的类中使用。

当去掉private不加任何修饰符时为包访问权限（对应上面的default范围，至于default关键字的使用在接口当中会提到），当前包底下的类才能使用Animal中的属性。


当使用protected修饰时，是可以在子类中调用的，那么下面为什么会报错呢，那是因为调用的方式不对，这里我们需要改变访问方式并使用到super关键字。


改为如下调用，在子类中调用，并使用super关键字，而不是通过实例化对像调用，上面那张图除了提到包还提到了类，小伙伴们注意到了吗？不记得的小伙伴们就往上翻再看看那张图吧。

至于public没啥好说的，哪都能用。
上面呢介绍了继承普通类的知识，现在我们来看看不太正常的类，抽象类，抽象类是指被abstract修饰，包含抽象方法的类，如下就是一个抽象类，首先是类名前面添加了abstract关键字，其次是其中包含了一个抽象方法，什么是抽象方法，就是没有被具体实现的方法，如下图的work方法，没有方法体，并被abstract修饰，不加的话会报错，被abstract修饰的类中可以没有抽象方法，这是语法允许的（jdk1.8测出来的），但是建议同步使用，要么既有abstract修饰类又有abstract方法，要么都没有，不然使用了abstract修饰类又不加abstract方法这不是闹吗，除非你不想这个类直接被实例化，注意一点，abstract修饰的类不能直接被实例化，需要被继承之后通过子类调用父类的构造方法，对从父类继承过来的字段进行初始化，注意这些继承过来的字段和方法都到了子类中了，但是子类能不能使用和如何使用就和给的权限（使用了什么访问修饰符限定）相关了，并没有实例化产生一个父类对象，有些地方说会实例化一个父类对象这是不对的，说一个极端的说法，父类为抽象类你能实例化吗？


当一个普通类继承一个抽象类的时候需要重写抽象类的所有抽象方法，如果不想重写的话就需要声明为抽象类，看下面代码


继承主要是为了代码的复用，减少代码的重复书写和为多态打一个基础，接下来我们聊聊多态

多态

多态是一种思想，是同一份代码，不同的传参（子类）调用会产生不同的效果，绝对不是写死的代码
多态是建立在继承机制上的一种机制，想要了解多态就必须知道向上转型，那么什么是向上转型呢，所谓的向上转型就是使用父类对象的引用，引用子类对象看下面代码


Teacher是People的一个子类，使用People引用引用一个Teacher对象，向上转型是自动发生的，不需要进行强制类型转换，发生向上转型一般有三种情况
1.像上面代码一样，让父类引用直接引用子类对象时。
2.子类作为函数调用时的实参，使用父类形参接收时。
3.子类作为父类返回值函数的返回值时。
总的说就是父类引用引用了子类对象

红色的框表示第二种，橘黄色的框表示第三种
ps：不难理解吧QAQ
与向上转型对应的还有向下转型，就是将父类对象赋值给子类引用，一般很少用的，就简单的提一下吧，因为他发生条件比较严格，首先是不能直接强制类型转换，看下面代码（已经将People类变成了类）

其次是需要父类引用引用子类的对象（发生过向上转型），最后需要强制转换为对应的子类对象，像下面这样

ps：这东西用起来挺奇怪的，不太建议使用
到这里相信你应该知道什么叫做向上转型了，但是这还不足以接触多态，我们需要先来聊聊另外一个知识点，动态绑定，所谓动态绑定也叫运行时绑定，我们先来看看代码

首先可以看到三个输出，第一个输出睡觉，第三个输出教书没问题吧，问题就出在第二个上面，我明明调用的是people的work方法，为什么输出的不是睡觉，而是教书呢？这就是发生了动态绑定，所谓动态绑定就是使用父类引用引用子类对象然后（向上转型）去调用父类和子类相同的方法（返回值（构成父子类关系也可以，也就是协变类型），方法名，形参列表完全相同）换句话说也就是说在子类中重写了父类的方法，这样的重写需要注意一些点，那就是子类重写的方法的访问权限必须不小于父类的方法的权限也就是说父类为public子类就必须为public因为public是最大的权限，权限对应上图的 √ 的个数√越多权限越大，静态方法不能重写，被final修饰的方法（密封方法）不能重写。
ps：与动态绑定对应的还有静态绑定，这里就不多说了…
好了，知道了向上转型和动态绑定就可以了解多态了，看代码

是不是觉得很神奇，明明是指向了同一份代码却打印了不同的结果，这就是多态，我不管你怎么实现的方法，只要你有这个方法我就能帮你调用，并且这里如果是子类对象会发生向上转型，进而发生动态绑定，形成多态，上面是通过继承来实现的多态，接下来我们再来讲一个东西实现多态，接口

接口

那么接口是什么呢，接口也可以想象成一个类，但是它既然单独出现，肯定说明它和类有有所不同，首先接口由interface关键字定义，并且其中的所有方法都默认为public abstract的，所有字段都默认为public static final的，下面几种定义方式并无区别，
然后类似与继承，接口可以通过implements被实现，实现也很简单，和继承抽象类一样重写所有的抽象方法即可，同样接口不能被直接实例化。

有了上面的了解，我们来用接口实现多态，看下面代码，也和类实现多态没什么很大区别，也类似与发生了向上转型和动态绑定，实现接口和继承类的一个很大区别就是一个类只能继承一个类，但是一个类可以实现多个接口


其中接口也可以扩展接口，看下面代码

从jdk1.8开始接口中可以包含默认方法了需要使用default关键字修饰，和类的成员方法一样，看下面代码，到这里接口就差不多聊完了，小结一下

一些建议和小结

1.建议字段的访问权限能给小绝不给大，能使用private修饰的字段一定要用private，提高安全性。
2.继承的层次不要太深，建议最多继承三层，使用final修饰可以让类无法被继承。
3.抽象类的出现就是为了继承之后重写发生动态绑定。
4.能使用接口就不要使用抽象类，因为类只能单继承，但是接口可以“多继承”，更加的灵活。
5.多态的核心都是让调用者不必关注对象的具体类型. 这是降低用户使用成本的一种重要方式。
6.抽象类和接口的核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 接口中只能包含静态常量，子类必须重写所有的抽象方法。
7.接口中的方法和字段定义都只写必要部分，尽量简洁像博主上面一样

写在最后的话

以上就是博主这段时间学习的主要内容了，也查了不少资料，限于博主水平有限，文章难免有说错或表述不清的地方，欢迎小伙伴们在评论区或私信博主指出，最后希望本篇博客能对小伙伴们有所帮助，好了本篇博客到此就结束了，我们下篇博客见。