用户注册



邮箱：

密码：

用户登录


邮箱：

密码：
记住登录一个月忘记密码？

发表随想


还能输入：200字

海大软件1102班    -  云代码空间

—— 你究竟输入什么了导致它崩溃？

java对象多态性

2013-01-25|1668阅|作者：海大软件1102班|举报

摘要:多态性，是面向对象的最后一个特征，也是最重要的特征，掌握多态性可以设计更好的程序结构。 实际上方法的重载就是一种多态性的体现：        方法名称相同，根据传入参数的类型或个数的不同完成的功能也不同。 另外一种多态性就是指的对象的多态性：

多态性，是面向对象的最后一个特征，也是最重要的特征，掌握多态性可以设计更好的程序结构。
实际上方法的重载就是一种多态性的体现：
       方法名称相同，根据传入参数的类型或个数的不同完成的功能也不同。
另外一种多态性就是指的对象的多态性：
       · 子类对象向父类对象转型（向上转型）
       · 父类对象向子类对象转型（向下转型）
       · 对象间的互相转型问题
强调：
       一个类绝对不能继承一个已经实现好了的类。此处讲解的时候只是为了阐述概念，才使用了类与类的直接继承，但是开发中此种类型的代码肯定不存在。
       观察以下程序，初步认识对象的转型：
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() ;
                   }
         }
};
转型原则：
       在转型之前最好先判断一下一个对象是否是某个类的实例，判断通过之后在进行向下转型操作。
转型概念清楚之后就可以利用此概念完善抽象类与接口。
顶 1踩 0收藏
文章评论
    发表评论

    个人资料

    • 昵称： 海大软件1102班
    • 等级： 初级设计师
    • 积分： 2516
    • 代码： 147 个
    • 文章： 70 篇
    • 随想： 11 条
    • 访问： 242 次
    • 关注

    人气文章

    人气代码

    标签

    设计模式(3)单例模式(1)移动互联网(1)猜想(1)java(14)工厂模式(1)游戏(2)jsp(7)配置(1)Hibernate(1)查询缓存(1)rss(1)web(1)大数据(1)谷歌地图(1)苹果应用(1)传递参数(1)编码(1)乱码(2)解决方法(1)php(2)连接数据库(1)mysql(6)命令(2)数据库(3)安装(1)cmd(1)权限(1)世界末日(1)网络(1)光纤(1)Android(1)诺基亚(1)小米盒子(1)互联网电视(1)电视(1)jquery(1)正则表达式(1)图形操作类(1)图形(1)倒映效果(1)CSS3(1)编程语言排行榜(1)Objective-(1)wifi(1)interface(1)常量(1)堆栈(1)平板(1)面试(1)编码规范(1)笔试(2)辐射(1)bug(1)google(1)Oracle(1)数字电路与逻辑设计(1)广东海洋大学(1)curl(1)毕业游(2)

    最新提问

    站长推荐