多态，及向上下转型

/*
 多态：多种形态
    重点说的是对象的多态性。
 
class 动物{

}
 
class 狗   extends 动物{

}
狗  x = new 狗();
动物  x = new 狗(); 狗对象(实例)即使狗类型，又是动物类型。多态性
 
 多态在程序中的体现：父类的引用或者接口的引用指向了子类的对象。
 
 ! 多态的好处：提高了代码的拓展性
        多态的弊端：不能使用子类的特有方法
        多态的前提：
        1.必须有关系，继承，实现
        2.通常有覆盖
 */

/*
  多态中对成员的调用。
  1.成员变量
     当子父类中出现同名成员变量时。
 ！！！无论编译或者运行，都看等号的左边就行了
  2.成员函数

    出现一模一样的函数时，
    多态调用，
    编译时，看的是引用变量所属的类中的方法。
    运行时，看的是对象所属的类中的方法。
    
    简单说：编译看左边，运行看右边。
    
    成员方法动态绑定到当前对象上 
  3.静态函数

    出现一模一样的函数时，
    多态调用，
    编译和运行是看引用变量所属的类中的方法
    简单的说：编译运行看左边。
 
   真正调用静态方法是不需要对象的，直接类名调用，因为静态方法绑定在类上。
 */

/*
 向下转型和向上转型的用法。
 
 */
abstract class AnimalDTD2{
 abstract void eat();
}
class Dog2 extends AnimalDTD2{
 public void eat()
 {
  System.out.println("骨头");
 }
 void lookHome()
 {
  System.out.println("看家");
 }
}
class Cat2 extends AnimalDTD2{
 public void eat()
 {
  System.out.println("鱼");
 }
 void catchMouse()
 {
  System.out.println("抓老鼠");
 }
}
public class DuoTaiDemo2 {
 /**
  * @param agrs
  */
 /**
  * @param agrs
  */
 /**
  * @param agrs
  */
 public static void main(String[] agrs)
 {
  AnimalDTD2 a = new Cat2();//向上转型。
  a.eat();
  /*
   向上转型的好处：隐藏了子类型，提高了代码的扩展性。
                      弊端：只能使用父类中的功能，不能使用子类特有功能。功能被限定了。
                     
  如果不需要面对子类型，通过提高扩展性，或者使用父类的功能即可完成操作，就使用向上转型。  
   */
  //如果需要子类的特有功能呢？
  if(!(a instanceof Dog2))
  {
   System.out.println("类型不匹配");
  // return ;
   //throw new Exception("ClassCastException:类型不匹配");
  }
     Dog2 d = (Dog2)a;//向下转型       通过转换类型
  a.eat();
     d.lookHome();
  /*
   向下转型的好处：可以使用子类型的特有功能。
                      弊端：面对具体的子类型，向下转型有风险。
                      容易发生ClassCastException.只要转换类型和对象类型不匹配就会发生。
                      想要安全，必须进行判断，判断一个对象是否匹配某一个类型。
                      需要使用一个关键字 instanceof         对象    instanceof  类型
                     
   什么时候用向下转型：需要子类型的特有方法时，但是一定要判断。
   */
 }
}