多态中上溯造型怎么理解啊    看来很多遍 还是不怎么明白  模模糊糊的

举个例子来说：
public   abstract   class  Animal {
     public  abstract  void  eat(){}
     public void sleep()
     {
        System.out.println("动物睡觉！");
     }
}

class Dog extends Animal
{
   public void eat()
   {
       System.out.println("狗吃骨头");
    }

    public void Guard()
   {
      System.out.println("狗看家！");
   }
}

public class Main {

    public static void upCasting(Animal animal)
    {
        animal.sleep();
        animal.eat();
    }
    public static void main(String[] args) {
        Animal dog = new Dog();
        upcasting(dog);
    }
}

由于upCasting(Animal animal)方法的参数是 Animal类型的，因此如果传入的参数是 Animal的子类，传入的参数就会被转换成父类Animal类型，这样你创建的Dog对象能使用的方法只是Animal中的签名方法；也就是说，在上溯的过程中，Dog的接口变窄了，它本身的一些方法（例如：guard方法）就不可见了。如果你想使用Dog中存在而Animal中不存在的方法（比如guard方法），编译时不能通过的。

zhangbingyuan 发表于 2014-4-8 15:12
举个例子来说：
public   abstract   class  Animal {
     public  abstract  void  eat(){}

恩   阅读了好几遍  明白了

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。
赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说，父亲的行为像儿子，而不是儿子的行为像父亲。
实际上就是父类引用指向具体子类引用.但是使用的方法只能是父类中定义的共性方法,但是对以后体系的扩展很有帮助

嗯 各位都讲得很好啊

多态就是某一事物的多种存在形态，父类型引用指向了子类型对象。
例：父类  动物   
      子类  猫       猫 x =new 猫()； =====  动物  y=new 猫()；
也就是父类的引用也可以接受自己的子类对象，那当需要定义什么方法，又是子类中都有的那种方法是，就i可以用父类对象定义，那样的话，只要是这个父类的子类就都可以使用，以后再添加子类的时候，也不用单独给它定义这个方法了，直接调用即可。不如这个例子
abstract class Dongwu//父类动物
{
        abstract void eat();
}

class mao extends Dongwu//子类 猫 继承父类动物
{
        public void eat()
        {
                System.out.println("吃鱼");
        }
        public void zhulaoshu()
        {
                System.out.println("抓老鼠");
        }
}
class gou extends Dongwu//子类狗继承父类动物
{
        public void eat()
        {
                System.out.println("吃骨头");
        }
        public void kanjia()  
        {
                System.out.println("看家");
        }
}

public class duotaifuxiDemo {
        public static void main(String[] args)
        {
                Dongwu c=new mao()；//父类引用执行子类对象 类型提升 向上转型
                c.eat();//但只能访问父类中的成员
                mao d=(mao)c;//强制将父类父类的引用转换成子类类型 向下转换
                d.zhulaoshu();//访问子类成员
        fangfa(new mao());//可以直接调用吃的方法
                fangfa(new gou());
        }
    public static void fangfa(Dongwu44 a)//用父类建立吃的方法
        {
                a.eat();
        }


}  
instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)

       public static void fangfa(Dongwu44 a)
        {
                a.eat();
                if(a instanceof mao)//用 instanceof 判断类型 然后强制转换为子类型 就可以调用子类型中的特有成员了
                {
                        mao c=(mao)a;
                        c.zhulaoshu();
                       
                }
                if(a instanceof gou)
                {
                        gou d=(gou)a;
                        d.kanjia();
                }
               
        }