class Vehicle {

  public void drive() {

     System.out.println("Vehicle: drive");

  }

}

class Car extends Vehicle {

  public void drive() {

     System.out.println("Car: drive");

  }

}

public class Test {

  public static void main (String args []) {

    Vehicle v;

    Car c;

    v = new Vehicle();

    c = new Car();

    v.drive();

    c.drive();

    v = c;

    v.drive();

  }

}//

Vehicle: drive

Car: drive

Car: drive

为什么是这个结果

前两个不必说。第三个就是多态。父类引用指向子类对象。方法能不能调用看左边父类有没有该方法，具体如何实现看子类有没有覆盖该方法，覆盖了的话就按子类的方法实现

第三个属于多态了   
你可以这样看：v = c；v=.drive()； 因为继承的关系两个对象引用才能相互赋值，第一句就是v和c指向同一个地址，指向了c的对象所在的内存当中，调用的当然也是C当中的方法了。

1. class Vehicle
   
2. //父类
   
3. {
   
4.   public void drive() {
   
5.      System.out.println("Vehicle: drive");
   
6.   }
   
7. }
   
8. class Car extends Vehicle
   
9. //子类继承父类
   
10. {
    
11.   public void drive() {
    
12.      System.out.println("Car: drive");
    
13.   }
    
14. }
    
15. public class Test {
    
16.   public static void main (String args []) {
    
17.     Vehicle v;
    
18.     Car c;
    
19.     v = new Vehicle();//建立子类对象
    
20.     c = new Car();  //建立父类对象
    
21.     v.drive();
    
22.     c.drive();
    
23.     v = c;//这里是个多态
    
24.     v.drive();//所以这里的v.drive直接调用子类的c.drive
    
25.    
    
26.   }
    
27. }
    
28. /*
    
29. Vehicle: drive
    
30. Car: drive
    
31. Car: drive
    
32. 这是个人的理解，不知是否正确
    
33. */

复制代码

v = c;
v.drive();
既然你说到了多态问题，这个有个简单总结的：编译时候看左边（即v），运行时看右边(c)
1.编译--  假设你v=c 的时候，v 没有drive()这方法，而在c 有drive()，则会报错，为什么呢？因为编译时v根本就没有drive()方法。
2. 运行--   编译通过后 ，即v有drive()方法，根据运行时看右边(c)，既然c 复写父类的drive()方法，实际上是调用 c.drive()吧。。偶是这样理解的，请采纳下。

     v = c; //就是向上转型，子类型的引用转成父类型的引用。在执行时，会执行子类对象中的相应的drive()方法，所以结果当然是"Car: drive"。