关于父类引用指向子类对象（A a = New B();）的使用，理解向上转型

本文已参与「新人创作礼」活动，一起开启掘金创作之路。

首先什么是向上转型？

向上转型是JAVA中的一种调用方式，是多态的一种表现。向上转型并非是将B自动向上转型为A的对象，相反它是从另一种角度去理解向上两字的：它是对A的对象的方法的扩充，即A的对象可访问B从A中继承来的和B复写A的方法，其它的方法都不能访问，包括A中的私有成员方法。

我们举个例子，看下面的代码：

1. class Animal{  
2. public void sleep(){  
3.         System.out.println("Animal sleep");  
4.     }  
5. public void eat() {  
6.         System.out.println("Animal eat");  
7.     }  
8. }  
9. class Dog extends Animal {  
10. public void eat() {  
11.         System.out.println("dog eat meat");//重写父类方法
12.     }  
13. //子类定义了自己的新方法
14. public void methods() {  
15.         System.out.println("dog method");  
16.     }  
17. }  
18. public class Demo {  
19. public static void main(String[] args) {  
20.         Animal a = new Dog();  
21.         a.sleep();  
22.         a.eat();  
23. //a.methods();  /报错:The method methods() is undefined for the type Animal/
24.     }  
25. }  

1、a实际上指向的是一个子类对象，所以可以访问Dog类从Animal类继承的方法sleep()和重写的方法eat()

2、由于向上转型，a对象会遗失和父类不同的方法，如methods();

所以答案就很明显了：

Animal sleep

dog eat meat

现在你再想想如果是B a = new B();的话是怎么样的情况？（这个问题不难，我就不再啰嗦了）

这样理解下来相信你已经大致知道他们的区别了。

现在我们来研究一下多态中的成员访问特点，看下面的代码

1. class Fu {  
2. public int num = 100;  
3. public void show() {  
4.         System.out.println("show Fu");  
5.     }  
6. public static void function() {  
7.         System.out.println("function Fu");  
8.     }  
9. }  
10. class Zi extends Fu {  
11. public int num = 1000;  
12. public int num2 = 200;  
13. public void show() {  
14.         System.out.println("show Zi");  
15.     }  
16. public void method() {  
17.         System.out.println("method zi");  
18.     }  
19. public static void function() {  
20.         System.out.println("function Zi");  
21.     }  
22. }  
23. public class DuoTaiDemo {  
24. public static void main(String[] args) {  
25. // 要有父类引用指向子类对象。
26. // 父 f = new 子();
27.         Fu f = new Zi();  
28.         System.out.println(f.num);  
29. // 找不到符号
30. // System.out.println(f.num2);
31.         f.show();  
32. // 找不到符号
33. // f.method();
34.         f.function();  
35.     }  
36. }  

答案是：

100

show Zi

function Fu

我们可以看到多态中的成员访问特点：

• 成员变量

• • 编译看左边，运行看左边

• 构造方法

• • 子类的构造都会默认访问父类构造

• 成员方法

• • 编译看左边，运行看右边

• 静态方法

• • 编译看左边，运行看左边
  • 所以静态方法不能算方法的重写

最后为什么我们要用到向上转型？

目的是规范和扩展，提高了代码的维护性和扩展性

在继承时：非静态属性、静态属性、静态方法都不可以重写