数组的定义类型为父类型，里面保存的实际元素类型为子类型。

应用案例：

  • 要求创建一个Person对象，2个Student对象和2个Teacher对象，统一放在数组中，并调用每个对象的say方法。
  • 如何调用子类特有的方法，比如Teacher有一个teach，Student有一个study，怎么调用？

image.pngimage.png

Person

  1. package test;
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         //应用实例:现有一个继承结构如下：要求创建1个Person对象、
  6.         // 2个Student 对象和2个Teacher对象, 统一放在数组中，并调用每个对象say方法
  8.         //父类的引用可以指向子类的对象
  9.         Person[] persons = new Person[5];
  10.         persons[0] = new Person("jack", 20);
  11.         persons[1] = new Student("mary", 18, 100);
  12.         persons[2] = new Student("smith", 19, 30.1);
  13.         persons[3] = new Teacher("scott", 30, 20000);
  14.         persons[4] = new Teacher("king", 50, 25000);
  16.         //循环遍历多态数组，调用say
  17.         for (int i = 0; i < persons.length; i++) {
  18.             // person[i] 编译类型是 Person ,运行类型是是根据实际情况由JVM来判断
  19.             System.out.println(persons[i].say());//动态绑定机制
  21.             //编译类型Person中不含有这两个方法
  22. //            persons[i].teach();//报错！！！
  23. //            persons[i].study();//报错！！！
  25.             //解决方案： 使用 类型判断 + 向下转型.
  26.             if (persons[i] instanceof Student) {//判断person[i] 的运行类型是不是Student
  27.                 Student student = (Student) persons[i];//向下转型
  28.                 student.study();
  29.                 //也可以使用一条语句 ((Student)persons[i]).study();
  30.             } else if (persons[i] instanceof Teacher) {
  31.                 Teacher teacher = (Teacher) persons[i];
  32.                 teacher.teach();
  33.             } else if (persons[i] instanceof Person) {
  34.                 //就是Person类型，不做处理
  35.             } else {
  36.                 System.out.println("你的类型有误, 请自己检查...");
  37.             }
  38.         }
  39.     }
  40. }

Student

  1. package test;
  3. public class Student extends Person {
  4.     private double score;
  6.     public Student(String name, int age, double score) {
  7.         super(name, age);
  8.         this.score = score;
  9.     }
  11.     public double getScore() {
  12.         return score;
  13.     }
  15.     public void setScore(double score) {
  16.         this.score = score;
  17.     }
  18.     //重写父类say
  20.     @Override
  21.     public String say() {
  22.         return "学生 " + super.say() + " score=" + score;
  23.     }
  24.     //特有的方法
  25.     public void study() {
  26.         System.out.println("学生 " + getName() + " 正在学java...");
  27.     }
  28. }

Teacher

  1. package test;
  3. public class Teacher extends Person {
  4.     private double salary;
  6.     public Teacher(String name, int age, double salary) {
  7.         super(name, age);
  8.         this.salary = salary;
  9.     }
  11.     public double getSalary() {
  12.         return salary;
  13.     }
  15.     public void setSalary(double salary) {
  16.         this.salary = salary;
  17.     }
  18.     //写重写父类的say方法
  20.     @Override
  21.     public String say() {
  22.         return "老师 " + super.say() + " salary=" + salary;
  23.     }
  24.     //特有方法
  25.     public void teach() {
  26.         System.out.println("老师 " + getName() + " 正在讲java课程...");
  27.     }
  28. }

Main

  1. package test;
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         //应用实例:现有一个继承结构如下：要求创建1个Person对象、
  6.         // 2个Student 对象和2个Teacher对象, 统一放在数组中，并调用每个对象say方法
  8.         //父类的引用可以指向子类的对象
  9.         Person[] persons = new Person[5];
  10.         persons[0] = new Person("jack", 20);
  11.         persons[1] = new Student("mary", 18, 100);
  12.         persons[2] = new Student("smith", 19, 30.1);
  13.         persons[3] = new Teacher("scott", 30, 20000);
  14.         persons[4] = new Teacher("king", 50, 25000);
  16.         //循环遍历多态数组，调用say
  17.         for (int i = 0; i < persons.length; i++) {
  18.             // person[i] 编译类型是 Person ,运行类型是是根据实际情况由JVM来判断
  19.             System.out.println(persons[i].say());//动态绑定机制
  21.             //编译类型Person中不含有这两个方法
  22. //            persons[i].teach();//报错！！！
  23. //            persons[i].study();//报错！！！
  25.             //解决方案： 使用 类型判断 + 向下转型.
  26.             if (persons[i] instanceof Student) {//判断person[i] 的运行类型是不是Student
  27.                 Student student = (Student) persons[i];//向下转型
  28.                 student.study();
  29.                 //也可以使用一条语句 ((Student)persons[i]).study();
  30.             } else if (persons[i] instanceof Teacher) {
  31.                 Teacher teacher = (Teacher) persons[i];
  32.                 teacher.teach();
  33.             } else if (persons[i] instanceof Person) {
  34.                 //就是Person类型，不做处理
  35.             } else {
  36.                 System.out.println("你的类型有误, 请自己检查...");
  37.             }
  38.         }
  39.     }
  40. }

image.png