如果p是父类Parent的对象，而c是子类Child的对象，则语句c = p是正确的吗？

不可以!

不可以，会抛出classCastException类型转换异常。
这涉及到了向上转型和向下转型。
当一个父类引用指向子类对象的时候，子类对象向上转型成了父类类型。向上转型是自动转换的。这就是继承间的多态体现。
当子类引用指向父类对象时，就是向下转型，需要强制转换。

举例：

1. class Person
   
2. {
   
3.         public String toString()
   
4.         {
   
5.                 return "person";
   
6.         }
   
7. }
   
8. class Child extends Person
   
9. {
   
10.         public String toString()
    
11.         {
    
12.                 return "child";
    
13.         }
    
14. }
    
15. 
    
16. public class MyTest
    
17. {
    
18.         public static void main(String[] args)
    
19.         {
    
20.                 Person p=new Person();
    
21.                 Child c=new Child();
    
22.                 //向上转型，自动转型
    
23.                 p=c;
    
24.                 //向下转型，强制转换。在这里判断如果p是Child类型就可以转换
    
25.                 if(p instanceof Child)
    
26.                 {
    
27.                         c=(Child)p;
    
28.                         System.out.println("p是Child类型");
    
29.                 }
    
30.                 else
    
31.                         System.out.println("p不是Child类型");
    
32.                 System.out.println(p);
    
33.                 //System.out.println(c);
    
34.         }
    
35. }

复制代码

希望你能明白

不可以的。 在java里，向上转型是自动进行的，但是向下转型却不是，需要我们自己定义强制进行
c=(Parent)p;进行强制转化，也就是向下转型

楼上的回答已经很精彩了，
对于父类对象想转换为子类，必须强制准换才行，不能使默认的。
但这个例子主要不是多态，多态是向上转型的。
下边我给lz介绍一下多态吧：
把不同的子类（child1和child2）对象都当作父类（parent）来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。
因此，程序就具备了通用性和可扩展性，正是面向对象的核心所在。
多态的3个条件：
1、要有继承关系，正如：class Child extends Parent;
2、要有方法的重写：我们想要用多态实现什么功能，就要将这个功能的方法从父类重写，用来之后的动态绑定；
3、父类引用指向子类对象原则。
下边我给楼主一个小例子，以示多态的条件，及优点。
大家都知道ArrayList和LinkedList都实现了List接口，这可以说是一种继承关系。
ArrayList是顺序存储，查询方便，增删繁琐；
LinkedList是链式存储，查询繁琐 但增删容易；
我们定义集合的时候如果用了多态，就可以根据我们后来的情况选择来决定到底用哪个集合了、
代码：

1. package org.qyx.online;
   
2. 
   
3. import java.util.*;
   
4. 
   
5. public class TestCastDown {
   
6.         public static void main(String[] args) {
   
7.                 List list=new ArrayList();
   
8.                 /*
   
9.                  *     只把上面这句改为
   
10. new LinkedList() 就可以了，其他什么都不用动，岂不快哉！--------可扩展
    
11.                         用父类引用指向子类对象的好处就是：
    
12.                         我们的list虽然是ArrayList，但只能执行List接口里边实现来的东西，约束它不能整出自己的东西，
    
13.                         不然换成LinkedList可能就不好使了--------通用
    
14.                 */
    
15.                 list.add("l1");
    
16.                 list.add("l2");
    
17.                 list.add("l3");
    
18.                 list.add("l4");
    
19.         }
    
20. }
    

复制代码

{:soso_e189:}明白了
thank you

错误！错误！  
父类引用可以指向子类对象
父类引用也可以接受子类对象
而且我认为多态中还有容易出问题的地方是  （当然初学者）
在多态中成员函数的特点
　　在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有编译报错
　　在运行时期：参阅对象所属的类中是否有调用的方法
　　简单的总结就是：成员函数在多态的调用时，编译看左边有木有，运行看右边有木有
在多态中，成员变量的特点：
　　无论编译和运行，都参考左边 即引用类型所属的类
在多态中，静态成员函数的特点
     静态函数在继承中没有覆盖的情况
　　无论编译和运行，都参考左边