转型（java）（.net）

/**
 * 父类
 */
class Animal {
    public void eat() {
        //输出 父类吃。。。。
    }
}
class Bird extends Animal {
    public void eat() {
        // 鸟儿吃。。。
    }
    public void fly() {
        // 鸟儿飞
    }
}
/**
 * 父类人类
 */
public class Human {
    public void sleep() {
        // 人类
    }
}
class Male extends Human {
    public void sleep() {
        // 男人
    }
}
class Female extends Human {
    public void sleep() {
        // 女人
    }
}
public class Sys {
    public static void main(String[] args) {
        Animal b = new Bird(); //向上转型  
        b.eat();
        //  b.fly(); b虽指向子类对象，但此时子类作为向上的代价丢失和父类不同的fly()方法  
        sleep(new Male());
        sleep(new Female()); //传入的参数是子类-----！！  
    }
    public static void sleep(Human h) //方法的参数是父类------！！！  
        {
            h.sleep();
        }
}

子类重写的父类的  eatting...
男人 sleep..
女人 sleep..

详解：

1.  向上转型的实现         

            Animal b=new Bird(); //向上转型
            b.eat(); // 调用的是子类的eat()方法
            b.fly(); // 报错!!!!!-------b虽指向子类对象，但此时子类作为向上转型的代价丢失和父类不同的fly()方法------
2.为何不直接Bird b=new Bird();b.eat() 呢？

   这样就没有体现出面向对象的抽象的编程思想呀，降低了代码的可扩展性.

3.向上转型的好处？

           sleep(new Male());//调用方法时传入的参数是子类
           sleep(new Female());

             public static void sleep(Human h) //方法的参数是父类

            {

             h.sleep();

             }

如上代码就是用的向上转型，若是不用向上转型，那么有多少个子类就得在这儿写多少种不同的睡觉方法~~~~~~

 class Fruit {
     public void myName() {
         // 水果
     }
 }

 class Apple extends Fruit {
     public void myName() {
         // 苹果
     }
     public void myMore() {
         苹果1233333
     }
 }

 public class Sys {
     public static void main(String[] args) {
         Fruit a = new Apple(); //向上转型  
         a.myName();

         Apple aa = (Apple) a; //向下转型,编译和运行皆不会出错(正确的)  
         aa.myName(); //向下转型时调用的是子类的  
         aa.myMore();;

         Fruit f = new Fruit();
         Apple aaa = (Apple) f; //-不安全的---向下转型,编译无错但会运行会出错  
         aaa.myName();
         aaa.myMore();
     }
 }

我是子类  苹果...
我是子类  苹果...
我是你的小呀小苹果~~~~~~
出错。。。。。。。。

详解：

1.正确的向下转型    

                    Fruit a=new Apple(); //向上转型
                    a.myName(); 
                    Apple aa=(Apple)a; //向下转型,编译和运行皆不会出错(正确的)
                    aa.myName();
                    aa.myMore();

a指向子类的对象，所以子类的实例aa也可以指向a啊~~

向下转型后因为都是指向子类对象，所以调用的当然全是子类的方法~~

2.不安全的向下转型

               Fruit f=new Fruit();
               Apple aaa=(Apple)f; //-不安全的---向下转型,编译无错但会运行会出错
               aaa.myName();
                aaa.myMore(); 

f是父类对象，子类的实例aaa肯定不能指向父类f啊~~~

3.Java为了解决不安全的向下转型问题，引入泛型的概念

4.为了安全的类型转换，最好先用 if(A instanceof  B) 判断一下下~~