向上转型与向下转型

package girlfriend;

import org.w3c.dom.ls.LSOutput;

/**
 * @author liu$
 * @version 1.0
 * @description: TODO
 * @date $ $
 */
//编译时，看左边；运行时，看右边。
//若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
//多态情况下，
//“看左边”看的是父类的引用（父类中不具备子类特有的方法）
//“看右边”看的是子类的对象（实际运行的是子类重写父类的方法）
public class test {

    public static void main(String[] args) {

        class Animal {

            public boolean equals(Object obj) {
                return super.equals(obj);
            }

            public void move() {
                System.out.println("动物可以移动");
            }
        }

        //子类继承父类的属性、方法 同时拥有自己特殊的方法
        class Dog extends Animal {
            public void move() {
                System.out.println("狗可以跑和走");
            }

            public void bark() {
                System.out.println("狗可以吠叫");
            }
        }

        class TestDog {
            //  形参类型只写一种Animal即可，如果没有向上转型，要写Dog，Fish，Cat等多种形参，那就累死了。
            public static void doEat(Animal h) {
                h.move();
            }

            public static void main(String args[]) {
                Animal a = new Animal(); // Animal 对象
                // 下一行就是向上转型，需要Animal，给个Dog，也行吧，但是不能执行Dog类的特有方法了。
                Animal b = new Dog();

                // 下一行需要Dog，给它Animal，肯定不行，编译出错！
                //        Dog d =new Animal();
                Dog c = new Dog();
                a.move();// 执行 Animal 类的方法
                b.move();//执行 Dog 类的方法
                //        b.bark()  该方法使用失败
                c.bark();
                //下两行体现了向上转型的精髓，假如没有向上转型，面对不同的实参，形参要写很多种，那样该方法要写多少个呀！！！！
                doEat(new Dog()); //狗可以跑和走
                doEat(new Animal()); //动物可以移动
                System.out.println(a.equals(b));
            }

        }


    }



}
//向下转型
//先将一个子类向上转型到另一个子类的父类，然后令另一个子类赋值为
//例如先将woman向上转型为human
//Person p1 = new Woman();
//Man p = (Man)p1 ;