子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口
如果子类重写了父类的方法，就根据这个引用指向调用子类重写的这个方法，不是调用父类的，，这个调用过程就称为“动态绑定”。
”动态绑定“的意义：如果父类是接口意味则父类是没办法实现方法的，必须要子类去实现，这时如果发生了向上转型，如果不实行动态绑定的话，子类就会陷入无方法可用的困境。而采用动态绑定的话，子类就算发生了向上转型也能实现重写的方法，而则恰恰是接口存在的意义。而代理功能就刚好是这种模式。
示例代码
public class UpClass {
public static void main(String[] args) {
/*这里注意调用的是子类的构造方法
Animal aBird = new Bird();
等价于
1.new Bird(); 这里调用父类的构造方法，然后再调用子类自己的构造方法
2.Aniaml aBird = 子类的引用
*/
Animal aBird = new Bird();
aBird.eat();//注意这里调用的是子类的方法，不是父类的，因为重写了父类的eat()方法
//aBird.fly();错误，向上转型会丢失子类方法
System.out.println("-----------------");
Animal animal = new Animal();
animal.eat();
}
}
class Animal{
public Animal() {
System.out.println("Animal initialization");
}
public void eat() {
System.out.println("animal eat");
}
}
class Bird extends Animal{
public Bird() {
System.out.println("Bird initialization");
}
@Override
public void eat() {
System.out.println("bird eat");
}
public void fly() {
System.out.println("bird can fly");
}
}
结果：
Animal initialization
Bird initialization
bird eat
-----------------
Animal initialization
animal eat
Animal aBird = new Bird();
就是一个典型的向上转型，子类对象当成父类对象，只能调用父类的成员
注意：
如果子类重写了父类的方法，就根据这个引用指向调用子类重写的这个方法，不是调用父类的，在上例子表示为调用Bird.eat(),而不是Animal.eat(),这个方法就是覆盖override）。这个调用过程就称为“动态绑定”。
某种程度上来说，向上转型能且只能调用子类的两种方法，，一是子类的构造方法，二是子类重写父类的方法
向上转型时，父类指向子类引用对象会遗失除与父类对象共有的其他方法，也就是在转型过程中，子类的新有的方法都会遗失掉，在编译时，系统会提供找不到方法的错误。在上例中aBird.fly()出现错误就是这个原因向下转型：
父类引用的对象转换为子类类型称为向下转型。
1 public class Person {
2 public void smile(){
3 System.out.println("Person smile!");
4 }
5 }
6
7 class Girl extends Person{
8 public void smile() {
9 System.out.println("Girl smile!");
10 }
11
12 public void sing(){
13 System.out.println("Girl sing!");
14 }
15 }
16
17 class main{
18 public static void main(String[] args) {
19 Person person=new Girl(); //向上转型
20 person.smile();
21
22 Girl girl=(Girl)person; //向下转型,编译和运行皆不会出错
23 girl.smile();
24 girl.sing();
25
26 Person person1=new Person();
27 //Girl girl1=(Girl)person1; //不安全的向下转型,编译无错但会运行会出错
28 //girl1.smile();
29 //girl1.sing();
30
31 if(person1 instanceof Girl){
32 Girl girl1=(Girl)person1;
33 girl1.smile();
34 girl1.sing();
35 }
36 } 在向下转型过程中，分为两种情况：
情况一：如果父类引用的对象引用的是指向的子类对象，那么在向下转型的过程中是安全的。也就是编译是不会出错误的。
情况二：如果父类引用的对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现java.lang.ClassCastException错误。它可以使用instanceof来避免出错此类错误。
总结：
1、父类引用可以指向子类对象，子类引用不能指向父类对象。
2、把子类对象直接赋给父类引用叫向上转型，向上转型不用强制转型。
如Father father = new Son();
3、把指向子类对象的父类引用赋给子类引用叫向下转型，要强制转型。
如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son）father；
其中father前面的（Son）必须添加，进行强制转换。
4、向上转型会丢失子类特有的方法,但是子类重写父类的方法，子类方法有效；
5、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁
