java向上转型

向上转型：将子类对象的引用转换为父类对象的引用，这就是向上转型。

”为新的类提供方法“这并不是继承中最重要的方面，其最重要的是用来表现新类和基类之间的关系。这种关系是”新类是现有类的一种类型“ 也就是is-a。例如：假设有一个称为Animal的代表动物的类和一个称为dog的导出类。继承可以保证基类中的所有的可继承方法（除了私有方法，不同包情况下的包访问权限方法）在导出类中也同样有效，所以能向基类发送的信息同样也可以向导出类发送。如：Animal有一个public的eat()方法，那么dog类也将具有此方法。这也就意味着dog对象也是一种类型的Animal。看一个例子：

class Animal {
    public void eat(){}
    static void tune(Animal a){
        //....
        a.eat();
    }
}

public class Dog extends Animal{
    public static void main(String[] args){
        Dog hashiqi = new Dog();
        Animal.tune(hashiqi);  //向上转型
    }
}

在此例中，tune()方法可以接受Animal的引用，但在Dog.main()方法中，传递给tune方法的是一个Dog引用。刚开始我也不懂这到底是怎么回事，以为代码写错了呢。在tune()中，程序代码可以对Animal和它所有的导出类起作用，这将Dog引用转换为Aniaml引用的动作，就是向上转型。

2  为什么称为向上转型

传统的类继承图：基类置于页面的顶端，然后导出类逐渐向下。由导出类转型成基类，在继承图上是向上移动的，因此一般称为向上转型。

导出类是基类的一个超集。它可能比基类含有更多的方法，但它必须至少具备基类中的所有方法。在向上转型的过程中，类接口唯一可能发生的事情就是丢失方法，而不是获取它们。

3  再论向上转型

向上转型可以这么写： Shape s  =  new  Circle();创建了一个Circle对象，并把他的引用赋值给Shape，看起来是错误的但是由于继承，Circle也是一种Shape，因此没有问题。

示例：

public class Shape {
    public void draw(){System.out.println("Shape.draw()"}
    public void earse(){System.out.println("Shape.earse()"}
}

public class Square extends Shape{
    public void draw(){System.out.println("Square.draw()"}
    public void earse(){System.out.println("Square.earse()"}
}

public class Circle extends Shape{
    public void draw(){System.out.println("Circle.draw()"}
    public void earse(){System.out.println("Circle.earse()"}
}

public class Triangle extends Shape{
    public void draw(){System.out.println("Triangle.draw()"}
    public void earse(){System.out.println("Triangle.earse()"}
}

public class Test{
    public static void main(String[] args){
        Shape s = new Circle();
        s.draw();
        s.erase();
    }
}

输出：

Circle.draw()

Circle.earse()

以前，我认为输出的答案应该是Shape.draw() Shape.earse().但是结果并不是那样。Shape s = new Circle();中的s是父类的引用，指向的确是子类的对象，编译器在执行的时候会先找子类对象中的方法，如果子类中由这个方法就会调用子类中的方法，如果没有才会查看父类中是否有这个方法。之所以能正确将引用指向Circle而不是Square或Triangle，是因为后期绑定。

4  域与静态方法

向上转型时调用域，会有什么样的结果呢，请往下看：

示例：

class Super{
    public int field = 0;
    public int getField(){ return field;}
}

public class Sub extends Super{
    public int field = 1;
    public int getField(){ return field;}
    public int getSuperField{return super.field;}  //显示调用父类的域
    public static void main(String[] args){
        Super sup = new Sub();      //向上转型
        System.out.println("sup.field="+sup.field+", sup.getField()="+sup.getField());
        Sub sub = new Sub();     //没有向上转型
        System.out.println("sub.field="+sub.field+", sub.getField()="+sub.getField()+", sub.getSuperField()="+sub.getSuperField());
    }
}
输出：
sup.field=0, sup.getField()=1;
sub.field=1, sub.getField()=1, sub.getSuperField()=0;

当Sub对象转型为Super引用时，任何域访问操作都将由编译器解析，因此不是多态的，所以sup.field调用的是父类的field。当引用Sub要访问父类的域时，需要显示的指明super.field。

再看一个例子：

class Super{
    public static String staticGet(){
        return "base class staticGet()";
    }
    public String dynamicGet(){
        return "base class dynamicGet()";
    }
}

public class Sub extends Super{
    public static String staticGet(){
        return "export class staticGet()";
    }
    public String dynamicGet(){
        return "export class dynamicGet()";
    }
    public static void main(String[] args){
        Super sup = new Sub(); //向上转型
        System.out.println(sup.staticGet());
        System.out.println(sup.dynamicGet());
    }
}
输出：
base class staticGet()
export class dynamicGet()

有输出结果可以看出，静态方法不具有多态性，静态方法是与类，而非单个对象相关联的。