父类和子类转换(子类对象赋值给父类对象)（转载）

下面是几个小例子,请大家看一看：

测试一
　　 父类：
　　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.我人认为这个对象既不是父类对象,也不是子类对象.当我们用到它的方法时,
　　　　　　　 我便把它看成子类对象;若用到它的属性时,我把它看成父类对象.
　　　　　　　 它是一个占用父类属性,而使用子类方法的对象.至于到底是什么对象,我认为还是得根据声明来,它应算是父类对象,但拥有子类方法.
　　　　　
　　　　 想一想：
　　　　　　　在测试三的基础上，我们如何取出子类的属性

转载于:https://www.cnblogs.com/maowh/p/3547623.html