System.out.println(a.name); //输出什么？
}
}
向下转型
public class Demo{
public static void main(String args[]){
//B b = (B)new A( ); //强制转型，运行后抛出异常
A a = new B();
B b = (B)a; //向下转型
b.fun1(); //输出什么？ A->fun1
b.fun2(); //输出什么？ A->fun2
b.fun3(); //输出什么？ B->fun3
}
}
要想产生对象的向下转型，则必须先产生一个向上的转型关系， A a = new B(); 表示建立关系。
多态的目的
所有的对象都可被转型为相同的类型，响应相同的消息
使代码变得简单且容易理解
使程序具有很好的“扩展性”
应用实例
技术基础
向上转型：一个父类的引用变量可以指向不同的子类对象。
动态绑定：运行时根据父类引用变量所指对象的实际类型执行相应的子类方法，从而实现多态性。
例子1：司机开车
public abstract class Driver{
public Driver( ) { }
public abstract void drives( );
}
public class FemaleDriver extends Driver {
public FemaleDriver( ) { }
public void drives( ) {
System.out.println("A Female driver drives a vehicle.");
}
}
public class MaleDriver extends Driver {
public MaleDriver( ) { }
public void drives( ) {
System.out.println("A Male driver drives a vehicle.");
}
}
public class Test{
public static void main(String [ ] args){
Driver a = new FemaleDriver( );
Driver b = new MaleDriver( );
a.drives( );
b.drives( );
}
}
输出结果：A Female driver drives a vehicle.
A Male driver drives a vehicle.
例子2——司机开什么车
不利用对象多态性的做法
public class MaleDriver extends Driver {
public MaleDriver( ) { }
public void drivesBus( ) {
System.out.println("A Male driver drives a bus.");
}
public void drivesCar( ){
System.out.println("A Male driver drives a car.");
}
public void drivesTruck( ){
System.out.println("A Male driver drives a truck.");
}
……
}
利用对象多态性的做法
public abstract class Vehicle{
public void drivedByFemale( );
public void drivedByMale();
}
public class Bus extends Vehicle{
public void drivedByFemale( ){
System.out.println("A Female driver drives a bus.");
}
public void drivedByMale(){
System.out.println("A Male driver drives a bus.");
}
}
public class MaleDriver extends Driver {
public void drives(Vehicle v){
v. drivedByMale();
}
}
public class Test{
public static void main(){
Vehicle bus = new Bus();
Driver male = new MaleDriver();
male.drives(bus);
}
}
输出结果： A Male driver drives a bus