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

首先什么是向上转型？

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

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

class Animal{  
public void sleep(){  
        System.out.println("Animal sleep");  
    }  
public void eat() {  
        System.out.println("Animal eat");  
    }  
}  
class Dog extends Animal {  
public void eat() {  
        System.out.println("dog eat meat");//重写父类方法
    }  
//子类定义了自己的新方法
public void methods() {  
        System.out.println("dog method");  
    }  
}  
public class Demo {  
public static void main(String[] args) {  
        Animal a = new Dog();  
        a.sleep();  
        a.eat();  
//a.methods();  /*报错:The method methods() is undefined for the type Animal*/
    }  
}  

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

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

所以答案就很明显了：

Animal sleep

dog eat meat

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

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

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

[java]view plaincopy

class Fu {  
public int num = 100;  
public void show() {  
        System.out.println("show Fu");  
    }  
public static void function() {  
        System.out.println("function Fu");  
    }  
}  
class Zi extends Fu {  
public int num = 1000;  
public int num2 = 200;  
public void show() {  
        System.out.println("show Zi");  
    }  
public void method() {  
        System.out.println("method zi");  
    }  
public static void function() {  
        System.out.println("function Zi");  
    }  
}  
public class DuoTaiDemo {  
public static void main(String[] args) {  
// 要有父类引用指向子类对象。
// 父 f = new 子();
        Fu f = new Zi();  
        System.out.println(f.num);  
// 找不到符号
// System.out.println(f.num2);
        f.show();  
// 找不到符号
// f.method();
        f.function();  
    }  
}  

答案是：

100

show Zi

function Fu

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

• 成员变量

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

• 构造方法

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

• 成员方法

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

• 静态方法

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

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

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

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