最近对将子类对象赋值给父类对象有点心得,想和大家分享一下.但本人程度有限,请各位指正和批判 .
　　言归正传,下面是几个小例子,请大家看一看.
　　
　　一
　　 父类：
　　public class Supclass
　　{
　　　　public void print()
　　　　{
　　　　　 System.out.println("this is 父类print()法子"+"——此时对象"+this.toString());
　　　　}
　　}
　　
　　子类：
　　public class Subclass extends Supclass
　　{
　　　　public static void main(String[] args)
　　　　{
　　　　　 Supclass sup=new Subclass();
　　　　　 sup.print();
　　　　　 System.out.println("此时对象"+sup.toString());
　　　　}
　　}
　　
　　　效果：this is 父类print()法子——此时对象是Subclass@126b249
　　　　　　此时对象是Subclass@126b249
　　　阐明：
　　　 Supclass sup=new Subclass();
　　　 虽然声明的对象是父类对象，但实际的内存空间是子类对象的。
　　　 继承父类的法子public void print()被调用，输出的是子类对象名字解析。
　　
　　结论：编译时声明的对象是父类对象，但运行时却是子类对象.子类没有重写父类的法子，则此　时的对象调用继承父类的法子。
　　
　　二
　　　父类：
　　public class Supclass
　　{
　　　　public void print()
　　　　{
　　　　　 System.out.println("this is 父类print()法子"+"——此时对象"+this.toString());
　　　　}
　　}
　　
　　　子类：
　　public class Subclass extends Supclass
　　{
　　　　　　public void print()
　　　　{
　　　　　 System.out.println("this is 子类print()法子"+"——此时对象"+this.toString());
　　　　}
　　　　public static void main(String[] args)
　　　　{
　　　　　 Supclass sup=new Subclass();
　　　　　 sup.print();
　　　　　 System.out.println("此时对象"+sup.toString());
　　　　}
　　}
　　
　　　 效果：this is 子类print()法子——此时对象是Subclass@126b249
　　　　　　 此时对象是Subclass@126b249
　　　 阐明：
　　　 我在上个例子的根基上，重写了父类的print()法子，此时的调用的是子类的print()法子。
　　
　　结论：在上个例子结论的根基上，我得到了一个结论：此时对象运行时确凿子类对象，如果子类没有从写父类的法子，
　　　　　则此时的对象调用继承父类的法子；否则，此时的对象调用子类法子.
　　
　　问题： 我们是不是可以从上面的测试得到的这样结论: 将子类对象赋值给父类对象(即Supclass sup=new Subclass()),
　　　　　 我们得到的就是子类对象,即sup就是子类对象??????
　　测试三
　　　父类：
　　 public class Supclass
　　{
　　　　　　protected String className="父类属性";
　　　　public void print()
　　　　{
　　　　　 System.out.println("this is 父类print()法子"+"——此时对象"+this.toString());
　　　　}
　　}
　　
　　　子类：
　　public class Subclass extends Supclass
　　{　　　
　　　　　　protected String className="子类属性";
　　　　　　public void print()
　　　　{
　　　　　 System.out.println("this is 子类print()法子"+"——此时对象"+this.toString());
　　　　}
　　　　public static void main(String[] args)
　　　　{
　　　　　 Supclass sup=new Subclass();
　　　　　 System.out.println("此时的属性时:"+sup.className);
　　　　}
　　}
　　
　　　效果：此时的属性时：父类属性
　　
　　　阐明：我在第一个测试的根基上,给父类添了一个属性className,在子类重写了这个属性.
　　　　　　但我输出此时对象的属性时,却是父类的属性.
　　　结论: 将子类对象赋值给父类对象,法子和属性和我们正统的继承关系很不一样.
　　　问题:
　　　　　 此时对象终究是子类对象,还是父类对象?
　　
　　　起头推测:　
　　　　　我在推测之前有几点须声明:
　　　　　1.当我们new一个子类对象时,父类对象的结构函数同时也被履行 ,即父类的一些必要信息和子类对象共占一个内存空间,
　　　　　　当我们法子重写时,于是我们就能应用 super这个指代父类的对象.
　　
　　　　　2.java中对象并不是完整的面向对象思想做的,即不是把一个对象的属性和法子同时封装到对象中.
　　　　　　而是对象有自己的属性,法子却是引用类中的法子,可以说它是把属性和类中法子的引用封装到对象中.
　　　　　　于是对象调用的法子不是自己的法子,而是类中法子.至于java为什么要这样做,我就不知道了.
　　
　　　　　3.当对象被加载到内存时,类先被加载到内存中,此后类应是一只留在内存中.至于类什么时候从内存中消散 ,我也不知道.
　　　　　　 我想java必然有自己的回收机制,就像回收对象一样.
　　
　　　　　4.编译和与运行是完整不同的事.编译时首要做的是声明对象的类型,分配属性,反省语法差错等
　　　　　　运行时做的是,将对象加载内存(一般用new,反射也常用), 运行代码履行功效等.
　　　　　
　　　　　5.若是读者您和我在这几点没有产生 共鸣 的话,或者说我们在这几点没用雷同的认识的话,你会感觉我在胡说.
　　　　　　也许你会感觉我的专家分太低,就感觉我的可信程度 就低.但我想说的是学不分先后,达者为先.
　　　　　　呵呵,我已筹办好将我的专家分变为负值了,不胡扯了,我们持续 .
　　
　　　　 推测:
　　　　　 1.当我们编译Supclass sup=new Subclass()时,sup对象被声明为Supclass类,于是sup对象的属性便是父类对象的属性的值,
　　　　　　 它是编译时被断定好的.(声明4,可以对这段进行解释 ).这段话可以对测试三进行解释 ,即为什么此时对象的属性是父类对象的属性.
　　
　　　　　 2.当我们运行Supclass sup=new Subclass()时,此时sup对象的内存空间是子类对象的内存空间(声明4,可以对这段进行解释 ),
　　　　　　 注意此时sup对象的内存空间由两部分组成父类的一些必要信息和子类对象信息(声明1,可以对这段进行解释 ).
　　　　　　 当我们不重写父类的法子时,由于此时内存空间已有父类的一些必要信息,所以继承父类的法子public void print()当然能被调用。
　　　　　　 这段话可以对测试一进行解释 .
　　
　　　　　 3.接着2持续 ,若我们重写父类的法子时,由于sup对象的内存空间是子类对象的内存空间,子类的法子public void print()已被加载到内存中.
　　　　　　 所以我们调用的是子类的法子public void print();如果你需要调用父类的被重写法子,需要用super.
　　　　　　 这段话可以对测试二进行解释 .
　　　　 总结:
　　　　　　 以下纯是个人观点:
　　　　　　 将子类对象赋值给父类对象,所得到对象是这样的一个对象:
　　　　　　 它是一个编译是为父类对象,但运行却是一个子类对象,具体特点如下.
　　　　　　 1.被声明为父类对象
　　　　　　 2.拥有父类属性
　　　　　　 3.占用子类的内存空间
　　　　　　 4.子类法子笼罩父类的法子时,此时对象调用的是子类的法子;否则,主动调用继承父类的法子.
　　　　　　 5.我人觉得这个对象既不是父类对象,也不是子类对象.当我们用到它的法子时,
　　　　　　　 我便把它看成子类对象;若用到它的属性时,我把它看成父类对象.
　　　　　　　它是一个占用父类属性,而应用子类法子的对象.至于到底是什么对象,我觉得还是得根据声明来,它应算是父类对象,但拥有子类法子.
　　　　　
　　　　 想一想：
　　　　　　　在测试三的根基上，我们如何取出子类的属性

 

 

 

从对象的内存角度来理解试试.
假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,它里面的变量需要占用0.5M内存.
现在通过代码来看看内存的分配情况:
Father f = new Father();//系统将分配1M内存.
Son s = new Son();//系统将分配1.5M内存!因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用父类的方法.
Son s1 = s;//s1指向那1.5M的内存.
Father f1 = (Father)s;//这时f1会指向那1.5M内存中的1M内存,即是说,f1只是指向了s中实例的父类实例对象,所以f1只能调用父类的方法(存储在1M内存中),而不能调用子类的方法(存储在0.5M内存中).
Son s2 = (Son)f;//这句代码运行时会报ClassCastException.因为f中只有1M内存,而子类的引用都必须要有1.5M的内存,所以无法转换.
Son s3 = (Son)f1;//这句可以通过运行,这时s3指向那1.5M的内存.由于f1是由s转换过来的,所以它是有1.5M的内存的,只是它指向的只有1M内存.

 

 

子类对象赋值给父类对象时，如果子类对象没重写父类的方法，调用赋值后的对象的成员，属性是父类的，方法是父类的；如果重写了父类的方法，则属性是父类的，方法是子类的。

父类不可以直接赋值给子类，必须是子类赋值给父类，然后再将这个父类的对象赋值给子类才行，属性是子类的，没重写方法，则方法是父类的，重写了就是子类的。

参考网址：http://blog.sina.com.cn/s/blog_65fda22f0100mos8.html