java向上转型神解析
经典案例
public class Animal {
public void eat(){
System.out.println("animal eatting...");
}
}
public class Cat extends Animal{
public void eat(){
System.out.println("我吃鱼");
}
}
public class Dog extends Animal{
public void eat(){
System.out.println("我吃骨头");
}
public void run(){
System.out.println("我会跑");
}
}
public class Main {
public static void main(String[] args) {
Animal animal = new Cat(); //向上转型
animal.eat();
animal = new Dog();
animal.eat();
}
}
//结果:
//我吃鱼
//我吃骨头
当父类对象引用变量引用子类对象时，被引用对象的类型决定了调用谁的成员方法，引用变量类型决定可调用的方法。Animal是引用变量类型，它决定哪些方法可以调用；eat()方法可以调用，而cat是被引用对象的类型，它决定了调用谁的方法：调用cat的方法。
向上转型
- 子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口。
Animal animal = new Cat();将子类对象Cat转化为父类对象Animal。这个时候animal这个引用调用的方法是子类方法。
向上转型应注意的问题
-
向上转型时，子类单独定义的方法会丢失。比如上面Dog类中定义的run方法，当animal引用指向Dog类实例时是访问不到run方法的，
animal.run()会报错。 -
子类引用不能指向父类对象。
Cat c = (Cat)new Animal()这样是不行的。Fu f=new Zi();
1、将子类对象赋值给父类对象，父类对象就成了子类的上转型对象，但是这只能访问从父类继承的方法和变量或者重写的方法。
2、只能让上转型对象调用（访问）子类中与父类有关的成员，子类中自己后定义的成员不能被调用（变量或方法）
向上转型的好处
- 减少重复代码，使代码变得简洁。
- 提高系统扩展性。
举个例子：比如我现在有很多种类的动物，要喂它们吃东西。如果不用向上转型，那我需要这样写：
public void eat(Cat c){
c.eat();
}
public void eat(Dog d){
d.eat();
}
//......
eat(new Cat());
eat(new Cat());
eat(new Dog());
//......
一种动物写一个方法，如果我有一万种动物，我就要写一万个方法，写完大概猴年马月都过了好几个了吧。好吧，你很厉害，你耐着性子写完了，以为可以放松一会了，突然又来了一种新的动物，你是不是又要单独为它写一个eat方法？开心了么？
那如果我使用向上转型呢？我只需要这样写：
public void eat(Animal a){
a.eat();
}
eat(new Cat());
eat(new Cat());
eat(new Dog());
//.....
恩，搞定了。代码是不是简洁了许多？而且这个时候，如果我又有一种新的动物加进来，我只需要实现它自己的类，让他继承Animal就可以了，而不需要为它单独写一个eat方法。是不是提高了扩展性？
class Fuc{
public int num=100;
public void show(){
System.out.println("show Fuc");
}
}
class Zic extends Fuc{
public int num=1000;
public int num2=200;
@Override
public void show() {
System.out.println("show Zic");
}
}
public class DuoTai {
public static void main(String[] args) {
Fuc f=new Zic();
System.out.println(f.num);
//System.out.println(f.num2); 编译错误
f.show();
}
}
编译器在编译阶段会先看父类，编译器通过声明对象的类型（即引用本身的类型）在方法区中该类型的方法表中查找匹配的方法。所以起初父类中没有num2变量，你用父类的引用去访问子类的变量编译不会通过，子类可以访问父类，但是父类不能访问子类，因为子类继承了父类。通俗点说就是儿子可以访问父亲，但是你父亲不能访问儿子。
静态方法的调用
class A {
public static void show(){
System.out.println("hhhh");
}
}
class B extends A {
public static void show(){
System.out.println("你哈");
}
}
public class C{
public static void main(String[] args) {
A b=new B();
b.show();
}
}
静态方法不具有多态性，因为
静态和类相关，和对象实例无关，静态方法可以继承和重写，但重写只是形式上的（算不上重写），父类方法并没有被覆盖掉。同名将隐藏。静态方法是被隐藏而不是被覆盖，所以上转型变量调用这个静态方法时，调用的是子类中继承的并且被隐藏的static方法，深层次去理解就是静态方法属于静态绑定，在编译过程中，方法与引用变量类型绑定，编译器看的是父类，所以运行时以声明类型为准，上转型变量调用的是继承且被隐藏的static方法。
