多态性,是面向对象的最后一个特征,也是最重要的特征,掌握多态性可以设计更好的程序结构。
<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />
实际上方法的重载就是一种多态性的体现:
方法名称相同,根据传入参数的类型或个数的不同完成的功能也不同。
另外一种多态性就是指的对象的多态性:
· 子类对象向父类对象转型(向上转型)
· 父类对象向子类对象转型(向下转型)
· 对象间的互相转型问题
<?xml:namespace prefix = v ns = "urn:schemas-microsoft-com:vml" />
强调:
一个类绝对不能继承一个已经实现好了的类。此处讲解的时候只是为了阐述概念,才使用了类与类的直接继承,但是开发中此种类型的代码肯定不存在。
观察以下程序,初步认识对象的转型:
class A{
public void fun1(){
System.out.println("A --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B --> public void fun3(){}") ;
}
};
|
以上代码可以发现,子类B,继承了父类A,同时在子类中覆写了类A中的fun1方法,也增加了自己新的fun3方法。
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
public class Demo10{
public static void main(String args[]){
A a = new B() ;
a.fun1() ;
a.fun2() ;
}
};
|
以上代码,无论是直接使用子类,还是子类向父类转型,发现最终结果调用的都是被子类覆写过的方法。
向上转型的关系:只要发生了向上转型,则一切的操作方法以子类为标准。
如果向上转型完成之后,那么一定可以把父类对象变为子类对象。但是此时就需要强制了。
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
public class Demo10{
public static void main(String args[]){
A a = new B() ;
B b = (B)a ;
b.fun1() ;
b.fun2() ;
}
};
|
现在观察以下代码:
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
public class Demo11{
public static void main(String args[]){
A a = new A() ;
B b = (B)a ;
b.fun2() ;
}
};
|
java.lang.ClassCastException:
为类型转换异常。两个没有任何关系的对象直接进行转型了,就出现此错误。
注意:
如果要进行向下转型之前,首先必须建立关系,即:必须先发生向上转型之后,才可以进行向下转型。为了建立关系。
对象多态性所带来的好处?
对象多态性在传递参数上可以体现出其优点,下面看两组代码,第一组是没有使用对象多态性的时候:
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
class C extends A{
public void fun1(){
System.out.println("C1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("C2 --> public void fun3(){}") ;
}
};
public class Demo12{
public static void main(String args[]){
fun(new B()) ;
fun(new C()) ;
}
//
定义一个方法,此方法可以接收
A
的子类对象
public static void fun(B b){
b.fun2() ;
}
public static void fun(C c){
c.fun2() ;
}
};
|
如果代码按以上格式编写会有那些问题?
· 每增加一个子类,就要增加一个方法,所以可以发现代码重复修改。
如果此时使用了对象多态性的概念,则代码可以修改为以下结构(所有的操作方法以被子类覆写过的方法为标准操作):
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
class C extends A{
public void fun1(){
System.out.println("C1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("C2 --> public void fun3(){}") ;
}
};
public class Demo13{
public static void main(String args[]){
fun(new B()) ;
fun(new C()) ;
}
//
不管有多少个子类,都用父类对象接收,因为可以自动发生向上转型关系
public static void fun(A a){
a.fun2() ;
}
};
|
感觉到一点:在继承关系中,父类的设计是最重要的,只要父类把功能定义好了,则所有代码都好写。
新的要求:
现在希望可以对程序的功能稍微有一些扩充,判断,如果传入的是B类对象,则可以调用fun3方法,如果传入的是C类对象,也可以调用C类的fun3方法。
要完成此功能,肯定要使用向上转型。
要完成此功能,必须对传入对象的类型进行判断,判断此对象到底是属于那个类的实例。
instanceof关键字完成:
· 功能:判断一个对象是否是某个类的实例,返回boolean
· 语法:对象 instanceof 类
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
class C extends A{
public void fun1(){
System.out.println("C1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("C2 --> public void fun3(){}") ;
}
};
public class Demo14{
public static void main(String args[]){
fun(new B()) ;
fun(new C()) ;
}
//
不管有多少个子类,都用父类对象接收,因为可以自动发生向上转型关系
public static void fun(A a){
a.fun2() ;
if(a instanceof B){
B b = (B)a ;
b.fun3() ;
}
if(a instanceof C){
C c = (C)a ;
c.fun3() ;
}
}
};
|
转型原则:
在转型之前最好先判断一下一个对象是否是某个类的实例,判断通过之后在进行向下转型操作。
转型概念清楚之后就可以利用此概念完善抽象类与接口。
转载于:https://blog.51cto.com/lixinghua/91245