Java多态详解

分类:热门推荐日期:2024-04-17浏览:1评论:0

目录

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

                  • 编译类型看左边，运行类型看右边
                  • 可以调用父类的所有成员（需遵守访问权限）
                  • 不能调用子类的特有成员
                  • 运行效果看子类的具体实现
                    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 多态参数

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

                                  代码示例：

                                  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的时候换成哪个子类对象，等号左边调用方法都不会变化。
                                    • 提高程序的拓展性：定义方法的时候，使用父类类型作为参数，将来使用时，使用具体的子类类型操作

相关推荐

关于我们常见问题广告服务免责声明联系我们
Powered By Z-BlogPHP 1.7.3 Theme By 优美主题
Copyright Your WebSite.Some Rights Reserved. 浙ICP备2023018783号