父类不能强转为子类，除非....../对“多态”的理解

     首先，引入“多态”、“动态绑定”、“静态绑定”的概念：
    一个对象变量可以指示多种实际类型的现象被称为多态。在运行时能够自动地选择调用哪个方法的现象称为动态绑定。（调用方法依赖于隐式参数即具体类的实际类型，在运行时调用）如果是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;

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

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