父类名  obj = new 子类；
obj.方法（子类覆写了的父类方法）-------最终调用的是谁的方法


父类名  obj = （父类名）new 子类；
obj.方法（子类覆写了的父类方法）-------最终调用的又是是谁的方法



原理是什么

都是多态，都是调用子类的成员方法

父类名  obj = new 子类；
这本来就是对子类的提升，没有必要在再像这个
父类名  obj = （父类名）new 子类；
这样前面加个（父类名）。

1. class Father{
   
2.         void show() {
   
3.         System.out.println("Father");
   
4. }
   
5. }
   
6. 
   
7. class Son extends Father {
   
8.         void show() {
   
9.         System.out.println("Son");
   
10. }
    
11. }
    
12. 
    
13. public class Test{
    
14.         public static void main(String[] args) {
    
15.         Father f = new Son();
    
16.         f.show();
    
17. 
    
18.         Father f1 = (Father) new Son();
    
19.         f1.show();
    
20.        
    
21. }
    
22. }

复制代码

运行结果：
Son
Son
说明两个都是调用的子类的方法。
原理： 这个是父类引用指向子类对象。
编译和运行是两个独立的过程，编译时根据等号左边的类里是否有这个方法来判断对错。
比如这个程序里等号左边是Father类，有这个方法，编译通过。
但是运行时，是看等号右边的类。如果有该方法，就运行它，如果没有就查找父类的。
比如这个程序里等号右边是new Son()，所以运行时首先去Son里找方法，如果son里没有就去它的父类里找。

上面的是调用子类的方法，下面的是调用父类的方法

感觉没什么区别~~

这不就是对象的多态，子类覆盖了父类的成员，调用时就是调用子类的成员

后者有个类型转换，输出的是子类

你这么多的技术分是怎么攥的啊，搞点技术分好难啊
只能水几个帖子赚黑马币

1. class AA
   
2. {
   
3.         public void show()
   
4.         {
   
5.                 System.out.println("AA");
   
6.         }
   
7. }
   
8. class AB extends AA
   
9. {
   
10.         public void show()
    
11.         {
    
12.                 System.out.println("AB");
    
13.         }
    
14. }
    
15. public class Demo03 {
    
16. 
    
17.         public static void main(String[] args) {
    
18.                 // TODO Auto-generated method stub
    
19.                 AA aa=new AB();
    
20.                 aa.show();//运行结果"AB"
    
21.                 AA ab=(AA)new AB();
    
22.                 ab.show();// 运行结果"AB"
    
23.         /* AA ab=(AA)new AB();
    
24.            虽然将子类对象进行向上转型，转为父类类型，其实质上还是多态的表现形式。
    
25.          和第一种将父类的引用指向子类对象的形式是一样的
    
26.           */
    
27.         }
    
28. 
    
29. }

复制代码