java进阶---多态
多态的概述
什么是多态
同一个对象,在不同时刻表现出来的不同形态
多态的前提
- 要有继承或实现关系
- 要有方法的重写
- 要有父类引用指向子类对象
多态的具体实现
对象的多态是多态的核心和重点
规则:
- 一个对象的编译类型与运行类型可以不一致
- 编译类型在定义对象时,就确定了,不能改变,而运行类型是可以变化的
- 编译类型看定义对象=号的左边, 运行类型看=号的右边
代码演示
class Animal {
public void eat(){
System.out.println("动物吃饭");
}
}
class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
public class Test1Polymorphic {
/*
多态的前提:
1. 要有(继承 \ 实现)关系
2. 要有方法重写
3. 要有父类引用, 指向子类对象
*/
public static void main(String[] args) {
// 当前事物, 是一只猫
Cat c = new Cat();
// 当前事物, 是一只动物
Animal a = new Cat();
a.eat();
}
}
多态中的成员访问特点
成员访问特点
- 成员变量 :编译看父类,运行看父类
- 成员方法 :编译看父类,运行看子类
代码演示
class Fu{
int num=10;
public void method(){
System.out.println("Fu..method")
}
}
class Zi extends Fu{
int num=20;
public void method(){
System.out.println("Zi...method")
}
}
public class Test{
public static void main(String[] args){
Fu f=new Zi();
System.out.println(f.num);
f.method();
}
}
//输出: 10 Zi..method
多态的好处和弊端
好处
提高程序的扩展性,定义方法时候,使用父类型作为参数,在使用的时候,使用具体的子类型参与操作
弊端
不能使用子类的特有成员
多态中的转型
向上转型
父类的引用指向子类对象就是向上转型
特点
- 编译类型看左边,运行类型看右边
- 可以调用父类的所有成员(须遵守访问权限)
- 不能调用子类的特有成员
- 运行效果看子类的具体实现
向下转型
一个已经向上转型的子类对象, 将父类引用转为子类引用
格式: 子类型 对象名 = (子类型) 父类的引用;
特点
- 只能强制转换父类的引用,不能强制转换父类的对象
- 要求父类的引用必须指向的是目标类型的对象
- 当向下转型后,可以调用子类类型中所有的成员
代码演示
class Fu {
public void show(){
System.out.println("Fu..show...");
}
}
class Zi extends Fu {
@Override
public void show() {
System.out.println("Zi..show...");
}
public void method(){
System.out.println("我是子类特有的方法, method");
}
}
public class Test3Polymorpic {
public static void main(String[] args) {
// 1. 向上转型 : 父类引用指向子类对象
Fu f = new Zi();
f.show();
// 多态的弊端: 不能调用子类特有的成员
// f.method();
// A: 直接创建子类对象
// B: 向下转型
// 2. 向下转型 : 从父类类型, 转换回子类类型
Zi z = (Zi) f;
z.method();
}
}
多态中转型存在的风险和解决方案
风险
如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException
解决方案
关键字
instanceof
使用格式
变量名 instanceof 类型
通俗的理解: 判断关键字左边的变量,是否是右边的类型,返回Boolean类型结果
动态绑定
- 当调用方法时,该方法会和该对象的运行内存绑定
- 当调用对象属性时,没有动态绑定机制,即哪里声明,哪里使用
应用
多态数组
多态数组:数组的定义类型为父类类型,里面保存的实际元素为子类类型
代码演示
public class person{
private String name;
public Person(String name){
this.name=name;
}
//get和set方法
public String getName(){
return name;
}
public Void setName(String name){
this.name=name;
}
//mission()方法
public String mission(){
return name + "\t" + "做人要厚道";
}
}
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 + " 要好好学习！";
}
}
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 + " 要好好教书！";
}
}
//开始演示多态数组
//创建一个Person对象
//创建一个Student对象
//创建一个Teacher对象
//统一放在数组里 并调用每个对象的missio()方法
public class Arr{
public static void main(String [] args){
Person[] persons = new Person[3];
Persons[0] = new Person("小白");
Persons[1] = new Student("小王",12);
Persons[2] = new Teacher("老黑",1000);
//循环遍历多态数组
for(int i; i < Persons.length; i++){
//此位置涉及动态绑定机制
//Persons[i]编译类型是Person , 运行类型根据实际情况由JVM判断
System.out.prinln(Persons[i].mission())
}
}
}
//运行结果
小白 做人要厚道！
小王 做人要厚道！ score = 12 要好好学习！
老黑 做人要厚道！ salary = 1000 要好好教书！
多态参数
方法定义的形参类型为父类类型,实参类型允许为子类类型
代码演示
//演示多态参数
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" + "正在好好教书");
}
}
//运行结果
小蓝同学 正在好好学习
小绿老师 正在好好教书