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方法。