本文共 2458 字，大约阅读时间需要 8 分钟。

     首先，引入“多态”、“动态绑定”、“静态绑定”的概念：

    一个对象变量可以指示多种实际类型的现象被称为多态。在运行时能够自动地选择调用哪个方法的现象称为动态绑定。（调用方法依赖于隐式参数即具体类的实际类型，在运行时调用）如果是private方法 ，static方法，final方法或者构造器，那么编译器将可以准确地知道调用哪个方法，这种调用方式成为静态绑定。     现在有父类Employee和其子类Mannager。     父类Employee:

package inheritance;import java.time.*;public class Employee {   private String name;private double salary;private LocalDate hireDay;public Employee(String name,double salary,int year,int month,int day){   this.name=name;this.salary=salary;hireDay=LocalDate.of(year,month,day);}public String getName(){   return name;}    public double getSalary() {           return salary;    }    public LocalDate getHireDay() {           return hireDay;    }    public void raiseSalary(double byPercent)    {   double raise=salary*byPercent/1000;    salary+=raise;}}

子类Mannager:

class Mannager extends Employee {           private double bonus;        public double getBonus() {               return bonus;        }        public void setBonus(double bonus) {               this.bonus = bonus;        }        public Mannager(String name, double salary, int year, int month, int day) {               super(name, salary, year, month, day);            bonus = 0;        }    }}

    接下来，先创建一个子类Mannager的数组，并初始化。

Mannager[] mannagers = new Mannager[10];

再将子类Mannager的数组mannagers转换成父类Employee类的数组：

Employee[] staff=mannagers;

     是合法的。父类Employee是可以接受子类Employee类的，因为managers[0]引用的是一个子类Mannager对象，那它一定也是父类Employee对象。 同时，需要注意的是，此时staff[0]和mannagers[0]引用的是同一个对象，是Mannager类型的。

所以： 1.如果这时使staff[0]引用父类Employee对象，比如：

staff[0]=new Employee("j",1,2,3,5);

    是非法的，编译可通过，但是运行时会报错：Exception in thread “main” java.lang.ArrayStoreException: inheritance.Employee 。

这是因为此时的staff[0]引用子类Mannager类对象，该对象变量的类型为子类Mannager，坚决不能够引用父类Employee类型的对象。（也就是本篇博客的标题：父类不能强转为子类）。     而如果我让staff引用的是Employee类型的数组：

Employee[] staff=new Employee[10];

     这时执行staff[0]=new Employee(“j”,1,2,3,5);

    自然是合法的。      接下来，恢复Employee[] staff=mannagers;使用强制类型转换。

Mannager boss=(Mannager) staff[0];

    在之前“staff[0]引用子类Mannager类对象”的基础上，该强制类型转换是合法的，正是体现了“ 多态”的概念。

如果我们这时让staff引用的是Employee类型的数组，即

Employee[] staff=new Employee[10];

    再使用强制类型转化，

Mannager boss=(Mannager) staff[0];

    也是合法的。因为staff[ i ]引用了一个父类Employee对象，它还可以引用子类Mannager对象的。

但是，如果是

staff[1]=new Employee("j",1,1,2,3);        Mannager boss=(Mannager) staff[1];

    使staff[1]引用了父类Employeenew出来的对象，再想进行强制转换，是会抛ClassCast异常的。

如果是

Mannager m=new Mannager("g",1,2,3,4);        Employee e=new Employee("f",4,3,2,1);        Mannager m1=(Mannager)e;

    这样的强制转换是非法的。

结题：父类不能强转为子类，除非对象本身引用的就是子类。