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 向上转型

本质：父类的引用指向子类的对象
特点：

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

语法：

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

2.2 向下转型

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

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

语法：

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

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 多态数组

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

说明：

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

代码如下：

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

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

说明：

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

代码如下：

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" + "正在好好教书");
	}
}

运行结果：

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

5. 多态的优点

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

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/38941.html

Java多态详解

目录

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. 多态的优点

发表回复

Java多态详解

目录

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. 多态的优点

相关推荐

发表回复