向上转型和向下转型

向上转型

现实中我们常常这样说：这个人会唱歌。在这里，我们并不关心这个人是黑人还是白人，是成人还是小孩，也就是说我们更倾向于使用抽象概念“人”。再例如，麻雀是一种鸟（鸟类的子类），而鸟是一种动物（动物类的子类），现实中我们也经常这样说：麻雀是鸟。这两种说法实际上就是所谓的向上转型，通俗地说就是子类转型成父类，这也符合Java提倡的面向抽象编程思想。来看下面的代码：

package leif;

public class Test {
    public static void main(String []args){
        Father father = new Son();
        father.print();
        father.father();
    }
}

class Father {
    public void father() {}

    public void print() {
        System.out.println("Father");
    }
}

class Son extends Father {
    public void son() {}

    @Override
    public void print() {
        System.out.println("Son");
    }
}

image.png

如果运行Test，输出的是“Son”而不是“Father”。这是因为father对象实际上指向的是Son子类的对象。由于向上转型，father对象会遗失和父类不同的方法，例如son()。这就是面向抽象的编程特色，体现了类的多态性，增强了程序的简洁性，还可以减轻编程工作量。例如有如下类：

package leif;

public class Monitor {
    public void displayText() {}

    public void displayGraphics() {}
}

class LCDMonitor extends Monitor {
    @Override
    public void displayText() {
        System.out.println("LCD display text");
    }

    @Override
    public void displayGraphics() {
        System.out.println("LCD display graphics");
    }
}

class CRTMonitor extends Monitor {
    @Override
    public void displayText() {
        System.out.println("CRT display text");
    }

    @Override
    public void displayGraphics() {
        System.out.println("CRT display graphics");
    }
}

class PlasmaMonitor extends Monitor {
    @Override
    public void displayText() {
        System.out.println("Plasma display text");
    }

    @Override
    public void displayGraphics() {
        System.out.println("Plasma display graphics");
    }
}

如果没有向上转型，Test类代码如下：

package leif;

public class Test {
    public static void main(String[] args) {
        run(new LCDMonitor());
        run(new CRTMonitor());
        run(new PlasmaMonitor());
    }

    public static void run(LCDMonitor monitor) {
        monitor.displayText();
        monitor.displayGraphics();
    }

    public static void run(CRTMonitor monitor) {
        monitor.displayText();
        monitor.displayGraphics();
    }

    public static void run(PlasmaMonitor monitor) {
        monitor.displayText();
        monitor.displayGraphics();
    }
}

可能你已经意识到上述代码有很多重复代码，而且也不易维护。有了向上转型，代码可以更为简洁：

package leif;

public class Test {
    public static void main(String[] args) {
        run(new LCDMonitor());
        run(new CRTMonitor());
        run(new PlasmaMonitor());
    }

    public static void run(Monitor monitor) {
        monitor.displayText();
        monitor.displayGraphics();
    }
}

我们也可以采用接口的方式，例如：

package leif;

public interface Monitor {
    public void displayText();

    public void displayGraphics();
}

class LCDMonitor implements Monitor {
    @Override
    public void displayText() {
        System.out.println("LCD display text");
    }

    @Override
    public void displayGraphics() {
        System.out.println("LCD display graphics");
    }
}

class CRTMonitor implements Monitor {
    @Override
    public void displayText() {
        System.out.println("CRT display text");
    }

    @Override
    public void displayGraphics() {
        System.out.println("CRT display graphics");
    }
}

class PlasmaMonitor implements Monitor {
    @Override
    public void displayText() {
        System.out.println("Plasma display text");
    }

    @Override
    public void displayGraphics() {
        System.out.println("Plasma display graphics");
    }
}

向下转型

子类转型成父类是向上转型，反过来说，父类转型成子类就是向下转型。但是，向下转型可能会带来一些问题：我们可以说麻雀是鸟，但不能说鸟就是麻雀。来看下面的例子：

package leif;

public class Test {
    public static void main(String []args){
        Father fatherSon = new Son();
        fatherSon.print();
        fatherSon.father();
        Son sonFather = (Son) fatherSon;
        sonFather.print();
        sonFather.father();
        sonFather.son();
        Father father = new Father();
        father.print();
        father.father();
        Son son = (Son) father;// 运行时异常
        son.print();
        son.father();
        son.son();
    }
}

class Father {
    public void father() {}

    public void print() {
        System.out.println("Father");
    }
}

class Son extends Father {
    public void son() {}

    @Override
    public void print() {
        System.out.println("Son");
    }
}

从上面的代码我们可以得出这样一个结论：向上转型总是安全的，向下转型需要使用强制转换，有时会出现运行时异常。这是因为父类对象fatherSon指向的是子类Son的对象，所以子类对象sonFather当然也可以指向fatherSon。而父类对象father指向是父类Father的对象，所以子类对象son不能指向father。
那么如何避免在执行向下转型时发生ClassCastException？使用instanceof关键字就可以了。修改一下代码：

package leif;

public class Test {
    public static void main(String []args){
        Father fatherSon = new Son();
        fatherSon.print();
        fatherSon.father();

        if (fatherSon instanceof Son) {
            Son sonFather = (Son) fatherSon;
            sonFather.print();
            sonFather.father();
            sonFather.son();
        }

        Father father = new Father();
        father.print();
        father.father();

        if (father instanceof Son) {
            Son son = (Son) father;
            son.print();
            son.father();
            son.son();
        }
    }
}

class Father {
    public void father() {}

    public void print() {
        System.out.println("Father");
    }
}

class Son extends Father {
    public void son() {}

    @Override
    public void print() {
        System.out.println("Son");
    }
}

这样处理后就不用担心类型转换时发生ClassCastException了。