向上转型
现实中我们常常这样说：这个人会唱歌。在这里，我们并不关心这个人是黑人还是白人，是成人还是小孩，也就是说我们更倾向于使用抽象概念“人”。再例如，麻雀是一种鸟（鸟类的子类），而鸟是一种动物（动物类的子类），现实中我们也经常这样说：麻雀是鸟。这两种说法实际上就是所谓的向上转型，通俗地说就是子类转型成父类，这也符合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了。
