Java中多态变量的讨论和总结一、多态的表现形式
多态的表现形式有方法重载,方法改写,多态变量和泛型。重载是一种静态的多态性,在程序编译时确定被调用的方法,称为早绑定。而多态变量和改写相结合之后,方法的调用在运行时才能确定,是动态的多态性,称为晚绑定。
二、里氏替换原则(The Liskov Principle of Substitution)
在静态类型语言中,在父类和子类之间的关系存在下面的现象:
子类的实例必须拥有父类的所有数据成员;
子类的实例必须至少通过继承(如果不是显示地改写)实现父类所定义的所有功能;
这样,在某种条件下,如果用子类实例来替换父类实例,那么将会发现子类实例可以完全模拟父类的行为,二者毫无差别;
替换原则是指如果有A和B两个类,类B是类A的子类,那么在任何情况下都可以用类B来替换类A,而外界则毫无察觉。
不是所有继承产生的子类都符合替换原则,符合替换原则的子类称为子类型。
三、静态类型和动态类型
在静态类型面向对象语言中,一个变量所存储的值的类型并不等同于这个变量所声明的类型。声明为父类类型的变量可以包含子类的实例值。
静态类型是指变量在声明时所确定的类型,并且一经声明就不会改变;动态类型是指这个变量实际存储的值的类型。在静态类型的面向对象程序设计语言中,在编译时消息传递表达式的合法性不是基于接收器的动态类型,而是基于接收器的静态类型。而对象对消息的响应取决于对象的动态类型。(就是说:写代码的时候“点”不出该对象动态类型包含而静态类型不包含的变量、方法;动态类型就是程序运行过程中被重新赋值为对其他对象的引用,这时候他就可以含有动态类型对象的方法了。)
这样的变量在多态中称为多态变量。
考虑下面的类图:
对应的程序如下:
class SuperClass { public int x; public void f1() { } public void f2() { }}class SubClass extends SuperClass{ public int y; public void f1() { } public void f3() { }}public class Test{ public static void main(String[] args){ SuperClass ob=new SuperClass(); //(1) ob=new SubClass(); //(2) ob.x=1; //(3) ob.y=2; //(4) ob.f1(); //(5) ob.f2(); //(6) ob.f3(); //(7) }}
程序中,子类改写了父类中的f1()方法,添加了自己的属性y和方法f3()。语句(1)中变量ob的静态类型是SuperClass,动态类型是SuperClass;语句(2)中变量ob的静态类型不变,动态类型是SubClass(子类类型),子类对象的地址可以存放在父类类型的引用变量中,即父类引用变量引用子类对象;(3)、(5)、(6)是正确的,(4)、(7)是错误的,因为对于引用的合法性依赖于变量的静态类型,属性y和方法f3()在SuperClass中不存在,故有错,还应该注意参数的匹配;(5)调用的f1()是子类的f1(),(6)调用的f2()是父类的f2(),这是因为对于消息的响应取决于变量的动态类型,因此f1()是SubClass中的f1()。
如果在父类和子类中存在属性的覆盖,则通过ob(父类对象名)访问的x是父类中被覆盖的属性。
class SuperClass { public int x=1; public void f1() { } public void f2() { }}class SubClass extends SuperClass{ public int x=2; public int y; public void f1() { } public void f3() { }}class Test{ public static void main(String[] args){ SuperClass ob=new SuperClass(); //(1) ob=new SubClass(); //(2) System.out.println(ob.x); ob.f1(); //(5) ob.f2(); //(6) }}显示结果为:1
四、父类对象和子类对象
子类从父类继承了所有的属性和方法,因此作用在父类上的方法应用在子类对象上也是合法的。由于继承表达的是一种is a关系,即子类对象可以被视为父类的一个对象,因此可以把子类对象的引用赋给父类对象;反之,父类对象不一定是其某个特定子类的对象,因此不一定满足is a关系,因此不能把父类对象的引用直接赋给子类对象。
class Employee { private String name; private int salary; Employee(String name,int salary){ this.name=name; this.salary=salary; } public String getDetails() { return Name: " + name + "\nSalary: " + salary; }} class Manager extends Employee { String department; Manager(String name,int salary,String department){ super(name,salary); this.department=department; } public String getDetails() { return super.getDetails() + "\nDepartment: " + department; }} public class Test{ public static void main(String args[]){ Employee a=new Employee("Mike",800); Manager b=new Manager("Tom",1200,"Research"); Manager c=a; //Error Employee d=b; //True System.out.println(A.getDetails()); System.out.println(D.getDetails()); }}
根据消息传递的概念,对消息的响应取决于接收器。而这又依赖于接收器的动态类型。因此,当父类对象中存放了子类对象的引用,并且父类和子类中有方法覆盖时,通过父类对象将会调用子类中的方法。
同时,在编译时消息传递表达式的合法性不是基于接收器的动态类型,而是基于接收器的静态类型。因此,当父类对象中存放了子类对象的引用时,不能通过父类对象名引用子类中新定义的成员(包括属性和方法)。例如,下面的语句是错误的:
System.out.println(d.department);
可以通过强制类型转换把父类对象转换成子类对象,然后再进行访问:
Manager e=(Manager) d;
System.out.println(e.department);
五、运行时类型识别和向下造型
替换原则将数据的类型从子类提升到了父类。有时也需要做相反的事情,例如判断父类对象所存放的值是否是某个子类的对象。
类型的强制类型转换只能用于子类唯一这种确定的情况下,如果子类不止一个,则可能发生错误,可以通过instanceof运算符来识别子类对象所属的类。
public class Manager extends Employee
public class Contractor extends Employee
假设有一个子类对象,可以通过下面的语句来判断它所述的类并执行相应的操作:
if(a instanceof Manager){
Manager b=(Manager) a;
......
}
else if(a instance of Contractor){
Contractor b=(Contractor) a;
......
}
例如在上面的操作中,可以把a这个父类对象转换成相应的子类对象,从而去访问子类中新增的属性或方法,这称为向下造型(down casting)。造型(cast)也就是通常所说的类型转换。类型的提升称为向上造型(up casting)。
六、多态和抽象类、抽象方法
抽象类不能实例化,但是可以声明抽象类的变量用以存放其子类对象的引用。另外,抽象方法为其子类规定了一个必须实现的接口,这样在多个子类中就拥有一个相同的接口方法。
在程序中可以定义一个父类的数组用于保存所有子类的对象,从而保持程序的简洁和灵活性。下面的程序说明了这个问题。
abstract class Shape{ public abstract void draw();}class Circle extends Shape{ private int x; private int y; private int radius; public Circle(int x,int y,int radius){ this.x=x; this.y=y; this.radius=radius; } public void draw() { System.out.println("draw circle: ("+x+","+y+"),radius="+radius); }}class Line extends Shape{ private int x1,y1,x2,y2; public Line(int x1,int y1,int x2,int y2){ this.x1=x1; this.x2=x2; this.y1=y1; this.y2=y2; } public void draw(){ System.out.println("draw line,("+x1+","+y1+")-("+x2+","+y2+")"); }}public class TestShape{ public static void main(String[] args){ Shape[] s=new Shape[4]; s[0]=new Circle(1,1,10); s[1]=new Line(3,4,20,12); s[2]=new Circle(3,10,20); for(int i=0;i
如果没有多态这个特性或者不利用多态这个特性,则程序将复杂得多。
Java中所有的类的最终根类是java.lang.Object,因此可以Object类型的引用变量可以存放所有Java对象的引用,也使用一个Object数组保存Java中所有的对象。