Java多态详解

这篇具有很好参考价值的文章主要介绍了Java多态详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

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. 特点

  • 编译类型看左边,运行类型看右边
  • 可以调用父类的所有成员(需遵守访问权限)
  • 不能调用子类的特有成员
  • 运行效果看子类的具体实现
  1. 语法
父类类型 引用名 = new 子类类型();
//右侧创建一个子类对象,把它当作父类看待使用

2.2 向下转型

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

  2. 特点

  • 只能强制转换父类的引用,不能强制转换父类的对象
  • 要求父类的引用必须指向的是当前目标类型的对象
  • 当向下转型后,可以调用子类类型中所有的成员
  1. 语法
子类类型 引用名 = (子类类型) 父类引用;
//用强制类型转换的格式,将父类引用类型转为子类引用类型

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() 方法。
  1. 代码如下

(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 多态参数

多态参数:方法定义的形参类型父类类型,实参类型允许为子类类型。
代码示例文章来源地址https://www.toymoban.com/news/detail-406025.html

  1. 说明
  • 定义一个 Person 类 作为父类,定义 Student 类 和 Teacher 类作为子类继承父类
  • Person 类 拥有 name(姓名) 属性
  • Student 类 和 Teacher 类 拥有各自 特有 的 study() 和 teach() 方法
  • 要求:最后在 main 函数中 编写 test() 方法 ,功能是调用 Student 类 的 study() 或 Teacher 类 的 teach() 方法,用于演示 多态参数 的使用。
  1. 代码如下
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" + "正在好好教书");
	}
}
  1. 运行结果:
小蓝同学	正在好好学习
小绿老师	正在好好教书

5. 多态的优点

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

到了这里,关于Java多态详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • C++类和对象-多态->多态的基本语法、多态的原理剖析、纯虚函数和抽象类、虚析构和纯虚析构

    #includeiostream using namespace std; //多态 //动物类 class Animal { public:     //Speak函数就是虚函数     //函数前面加上virtual,变成虚函数,那么编译器在编译的时候就不能确定函数调用了。     virtual void speak()     {         cout \\\"动物在说话\\\" endl;     } }; //猫类 class Cat

    2024年02月20日
    浏览(38)
  • 【JavaSE专栏56】Java面向对象编程:深入理解类、对象、属性和方法的核心概念

    博主 默语带您 Go to New World. ✍ 个人主页—— 默语 的博客👦🏻 《java 面试题大全》 🍩惟余辈才疏学浅,临摹之作或有不妥之处,还请读者海涵指正。☕🍭 《MYSQL从入门到精通》数据库是开发者必会基础之一~ 🪁 吾期望此文有资助于尔,即使粗浅难及深广,亦备添少许微薄

    2024年02月07日
    浏览(41)
  • 面向对象(类/继承/封装/多态)详解

    面向对象编程(Object-Oriented Programming,OOP)是一种广泛应用于软件开发的编程范式。它基于一系列核心概念,包括类、继承、封装和多态。在这篇详细的解释中,我们将探讨这些概念,并说明它们如何在PHP等编程语言中实现。 类是OOP的基础。它是一种用于创建对象的蓝图或模

    2024年02月08日
    浏览(63)
  • C++类和对象——多态详解

    目录 1.多态的基本语法 2.多态的原理剖析 示例:计算机类  3.纯虚函数和抽象类 示例:制作饮品 4.虚析构和纯虚析构  示例:电脑组装 代码示例:   空类的大小为1  加了virtual后会变为4或8个字节,这恰好是一个指针的大小   vfptr是一个虚函数(表)指针 当子类重写父类的

    2024年02月22日
    浏览(38)
  • 面向对象详解,面向对象的三大特征:封装、继承、多态

    一、面向对象与面向过程 面向对象编程 (Object-Oriented Programming,简称OOP)和 面向过程编程 (Procedural Programming,简称PP)是两种不同的 编程范式 。 面向对象编程强调把问题分解成对象,通过封装、继承和多态等机制,来处理对象之间的关系 。每个对象都可以独立地处理自

    2024年02月21日
    浏览(53)
  • 【C++】面向对象---多态(万字详解)

           🔥🔥 欢迎来到小林的博客!!       🛰️博客主页:✈️小林爱敲代码       🛰️文章专栏:✈️小林的C++之路       🛰️欢迎关注:👍点赞🙌收藏✍️留言       今天给大家讲解多态,多态是面向对象的一个重要内容。也非

    2024年02月01日
    浏览(40)
  • Java 代理模式的基本概念、使用场景、应用示例和实现方法

    代理模式是一种常见的设计模式,在 Java 开发中被广泛应用。它允许我们通过添加一个代理对象来控制对另一个对象的访问,从而提供了一种间接访问实际对象的方法。本文将详细介绍 Java 代理模式的基本概念、使用场景、应用示例和实现方法等相关内容。 代理模式是一种结

    2024年02月05日
    浏览(59)
  • 【JAVA】多态的概念与实际利用

    个人主页:【😊个人主页】 系列专栏:【❤️初识JAVA】 在面向对象(OOP)的程序设计语言中,多态与封装、继承合称为OOP的三大特性。在今天,我们就来学习一下JAVA中的多态是什么样子的。、 指一个对象在不同情况下可以表现出不同的行为。Java多态性分为两种:编译时多态

    2024年02月08日
    浏览(52)
  • 【JavaSE】面向对象编程思想之多态(图文详解)

    目录 1. 多态的概念 2. 多态实现条件 3. 重写 4. 向上转型和向下转型 4.1 向上转型 4.2 向下转型 5. 多态的优缺点 6. 避免在构造方法中调用重写的方法 多态的概念:通俗来说,就是多种形态, 具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态。  总的来说

    2024年02月14日
    浏览(45)
  • 大语言模型的预训练[1]:基本概念原理、神经网络的语言模型、Transformer模型原理详解、Bert模型原理介绍

    预训练属于迁移学习的范畴。现有的神经网络在进行训练时,一般基于反向传播(Back Propagation,BP)算法,先对网络中的参数进行随机初始化,再利用随机梯度下降(Stochastic Gradient Descent,SGD)等优化算法不断优化模型参数。而预训练的思想是,模型参数不再是随机初始化的

    2024年02月17日
    浏览(52)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包