关闭

Java中的多态和动态绑定

标签: java多态继承动态绑定
284人阅读 评论(0) 收藏 举报
分类:

 1. 定义

根据Core Java:

  1. 多态:一个对象变量可以指示多种实例类型的现象。
  2. 动态绑定:在运行时刻能够自动选择调用哪个方法的现象。
  3. 签名:方法名和参数列表构成一个签名

多态和动态绑定大多与继承有关,因为有了继承的出现,才有了父类与子类,然后就是随之而来的方法重写(override),即子类重写父类的方法。另一个出现的就是子类对象的引用转换为父类对象的引用(此处不需要进行强制转换)。比如:

    public class Son extends Father {
        ...

        public static void main(String []args) {
            // 第一种写法
            Son son1 = new Son();
            Father father1 = son1;

            // 第二种写法,两种写法类似
            Father father2 = new Son(); // 直接把创建的子类对象的引用赋值给父类变量
        }
    }

上述代码中的父类变量father1引用的是子类的对象。也就是说,father1余son1引用的都是同一个对象,这个对象就是Son类的对象。但对于变量father1来说,编译器会把其当做Father类的变量,但是JVM当中,把确认其真实的实例类型(Son类)。

子类转为父类可以,但是反过来不行,比如:

    Father father3 = new Father();
    Son son3 = father3;

此处是把父类创建的一个对象(father3)的引用赋给子类变量(son3),在继承当中,这是不被允许的。试想:若此赋值语句成功,那么son3引用的对象其实是father3,但是son3其本身又被声明为Son类,此时在Son类中若有一个额外的新方法(eg: MethodOfSon(){…}),那么son3就可以调用该方法,但是其引用的对象是没有这个方法的,会造成混乱,所以此赋值方式不合适。

在类的继承之外,还有同一个类内部的方法重载(overloading),同一个方法名,因参数类型和参数个数不同,构成不同的签名。另外,签名不包含返回类型。

2. Example

Employee.java

    public class Employee
    {
       private String name;
       private double salary;
       private Date hireDay;

       public Employee(String n, double s, int year, int month, int day)
       {
          name = n;
          salary = s;
          GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);
          hireDay = calendar.getTime();
       }

       public String getName()
       {
          return name;
       }

       public double getSalary()
       {
          return salary;
       }

       public Date getHireDay()
       {
          return hireDay;
       }

       public void raiseSalary(double byPercent)
       {
          double raise = salary * byPercent / 100;
          salary += raise;
       }
    }

Manager.java

    public class Manager extends Employee
    {
       private double bonus;

       /**
        * @param n the employee's name
        * @param s the salary
        * @param year the hire year
        * @param month the hire month
        * @param day the hire day
        */
       public Manager(String n, double s, int year, int month, int day)
       {
          super(n, s, year, month, day);
          bonus = 0;
       }

       public double getSalary()
       {
          double baseSalary = super.getSalary();
          return baseSalary + bonus;
       }

       public void setBonus(double b)
       {
          bonus = b;
       }
    }

ManagerTest.java

    public class ManagerTest
    {
       public static void main(String[] args)
       {
          // construct a Manager object
          Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
          boss.setBonus(5000);

          Employee[] staff = new Employee[3];

          // fill the staff array with Manager and Employee objects

          staff[0] = boss;
          staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
          staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);


          // print out information about all Employee objects
          for (Employee e : staff)
             System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
       }
    }
其结果如下:

name=Carl Cracker,salary=85000.0
name=Harry Hacker,salary=50000.0
name=Tommy Tester,salary=40000.0

说明类Manager继承类Employee,在Manager内部重写了getSalary()方法,并新添加了setBonus()方法。

在main()函数中,Employee类型的数组staff包含了3个元素,第一个元素staff[0]包含的Manager类对象的引用,其与boss引用同一个Manager对象。staff[1]和staff[2]包含的是Employee类变量,分别指向不同的Employee类对象。

从结果看出,staff[0]的getSalary()方法,调用的Manager里面的方法,而staff[1]和staff[2]都是调用的Employee类中的getSalary()方法。staff[0]虽然声明的是一个Employee变量,但是其引用的对象却是Manager类对象,所以会首先在Manager类中查找是否有完全匹配的getSalary()方法(有可能存在重载的情况),然后再在父类中查找是否有完整的getSalary()方法。

还一个需要注意的地方:编译器会认为staff[0]是一个Employee对象,所以对于以下的调用方式,程序会出错:

    staff[0].setBonus(100);

同样,如果有如下的赋值,也是错误的:

    Manager manager1 = staff[0];

因为从编译器的角度来看,这两个是不同的类型,所以需要进行强制类型转换:

    Manager manager1 = (Manager) staff[0];

这种方式,看似这样很合理,因为staff[0]引用的是Manager对象,让manager1变量也应用这个对象,这样赋值好像也没什么不对,但是同样编译器报错。因为编译器认为staff[0]是属于Employee类型的,而Manager类是Employee类的子类,两者是不同的类型,不能直接赋值,必须要强制类型转换。

按照这个逻辑,以下的赋值语句,编译器也是通过的:

    Manager manager2 = (Manager) staff[1];

虽然编译器是通过的,但是在程序运行时,也会报错“ClassCastException”。原因在于staff[1]引用的对象是Employee类型的,也就是说,该Employee对象也能调用子类Manager当中的新方法setBonus(x),这是错误的。所以,Java当中,把父类对象强制转换为子类对象是不被允许的,反过来可以。

其实,上面的一段话,是从底层的角度对多个对象的逻辑关系进行的分析,实际上,Java虚拟机已经帮我们做了安全检查。只需要使用instanceof运算符,就可以确保赋值安全。

    Manager manager2;
    if(staff[1] instanceof Manager) {
        manager2 = staff[1];
    }

所以,在将超类对象转为子类对象时,一定要进行instanceof检查

在上面的例子中,staff[0]就是一个多态的例子,有继承,就有多态。和多态分不开的一个就是动态绑定。动态绑定和是静态绑定相对应的,一个是在编译的时候就知道用什么方法,还一个就是在运行时刻才知道调用哪个方法。

有private,static,final修饰的方法,或者构造函数,都是静态绑定。

3. 动态绑定的内部机制

首先理解方法表的概念:

方法表:除了private、static、final修饰的方法外,其他的能够参与动态绑定的实例方法。

对于动态绑定来说,每次在类中找对应的方法总是低效的,时间开销大,所以需要为每个类生成一个方法表,这样可以直接在类的方法表中寻找。

过程如下:

  1. 首先编译器确定对象的声明类型和方法名。然后找当前类中方法名字匹配的所有方法(由于重载,可能存在多个),然后在其父类中也找类似的属性为public的方法;
  2. 编译器查看调用方法的参数类型,先在本类中找,然后在超类中找,这一过程称为重载解析(overloading resolution)。若没找到,或在同一个类中找到多个,均报错。
  3. 若为private、static或者final修饰的方法,为静态绑定,可直接知道调用的是哪个方法,此情况下就省去了剩下的步骤;
  4. 在程序运行时,JVM会根据对象的实际类型从方法表中调用最合适的方法。

note:

  • 动态绑定只针对类的方法,对数据域无效,因为根据类的封装特性,数据域都是私有的,即使是子类,也无法访问。
  • 方法表存储在JVM中的方法区。

参考:


—— 2016.5.31

0
0
猜你在找
【套餐】Hadoop生态系统零基础入门
【套餐】嵌入式Linux C编程基础
【套餐】2017软考系统集成项目——任铄
【套餐】Android 5.x顶级视频课程——李宁
【套餐】深度学习入门视频课程——唐宇迪
【直播】广义线性模型及其应用——李科
【直播】从0到1 区块链的概念到实践
【直播】计算机视觉原理及实战——屈教授
【直播】机器学习之凸优化——马博士
【直播】机器学习&数据挖掘7周实训--韦玮
查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:36256次
    • 积分:1113
    • 等级:
    • 排名:千里之外
    • 原创:79篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类