向上转型和向下转型

转型是在继承的基础上而言的。

向上转型：子类引用的对象转换为父类类型称为向上转型。

子类对象当成父类对象，只能调用父类的成员，如果子类重写了父类的方法就根据这个引用指向调用子类重写的这个方法（这个方法就是覆盖override，这个调用过程就称为“动态绑定”）。

向上转型时，父类指向子类引用对象会遗失除与父类对象共有的其他方法，也就是在转型过程中，子类的新有的方法都会遗失掉，在编译时，系统会提供找不到方法的错误。

public class Animal {
         public void eat(){
                   System.out.println("animal eatting...");
         }
}
class Bird extends Animal{
         public void eat(){
                   System.out.println("bird eatting...");
         }
         public void fly(){
                   System.out.println("bird flying...");
         }
}
class Main{      
         public static void main(String[] args) {
                   Animal b=new Bird(); //向上转型
                   b.eat();
         b.fly();  //此处提示在Animal中没有定义fly方法。
｝

向下转型：父类引用的对象转换为子类类型称为向下转型。

在向下转型过程中，分为两种情况：

情况一：如果父类引用的对象如果引用的是指向的子类对象，那么在向下转型的过程中是安全的。也就是编译是不会出错误的。

情况二：如果父类引用的对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现java.lang.ClassCastException错误。它可以使用instanceof来避免出错此类错误。

public class Girl {
         public void smile(){
                   System.out.println("girl smile()...");
         }
}
class MMGirl extends Girl{
         @Override
         public void smile() {
         System.out.println("MMirl smile sounds sweet...");
         }
         public void c(){
          System.out.println("MMirl c()...");
         }
}
class main{
      public static void main(String[] args) {
        Girl g1=new MMGirl(); //向上转型
        g1.smile();
        MMGirl mmg=(MMGirl)g1;    //向下转型,编译和运行皆不会出错
        mmg.smile();
        mmg.c();
        Girl g2=new Girl();
        //MMGirl mmg1=(MMGirl)g2; //不安全的向下转型,编译无错但会运行会出错
//mmg1.smile();
        //mmg1.c();
       if(g2 instanceof MMGirl){
         MMGirl mmg1=(MMGirl)g2;
         mmg1.smile();
         mmg1.c();
         }}