Java中的多态和动态绑定

原创 2016年05月31日 18:26:57

 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

版权声明:本文为博主原创文章,未经博主允许不得转载。

Java中的多态与动态绑定

关于Java的多态在慕课网上的教程中已经学到了,但是当时似乎没有看到有动态绑定这么个主题。虽说,动态绑定的相关功能再教程中确实是提到了。        而Java中的多态一般是跟动态绑定放到一块儿说...

Java中的多态和动态绑定

先来一张图表明类Employee,Manager,Secretary,Programmer, Executive的继承关系 在java中有一个用来判断是否应该设计为继承关系的简...

java 多态 动态绑定

package com.bjpowernode.mybatis.test; public class TestMethod { public static void main(String[] ...

【Java】多态和动态绑定中的坑

大一学C++的时候就感觉多态这部分略烦,小坑不断。一年过后学习Java再次遇到多态的问题,写一篇笔记来记下发现的各种小坑,以供以后复习。来看下面一段代码:enum Note { MIDDLE_...

Java面向对象 多态动态绑定(非静态成员函数、成员变量、静态成员函数)

package test; class Father { int num = 1; void method1() { System.out.println("father method1")...

Java多态与动态绑定

public class Polymorphism { public static void main(String[] args) { // TODO Auto-generated metho...

Java中的多态(polymorphism)和动态绑定(dynamic binding)

以下面代码为例,存在超类Employee和子类Manager,两个类中都有getSalary方法,但实现不同。一个对象变量可以引用多种实际类型的现象被称为多态(polymorphism),运行时能够自...

【Java Learning】重载、多态和动态绑定——Overloading、Ploymorphism&Dynamic binding

Title:重载、多态和动态绑定——Overloading、Ploymorphism&Dynamic binding 【Section one】     对于面向对象编程语言,重载...

Java - 多态、动态绑定、抽象类和访问修饰符

一个对象变量可以指示多种实际类型的现象叫做多态。 在运行时能够自动地选择调用哪个方法的现象叫做动态绑定。 在Java中,不需要将方法声明为虚拟方法。动态绑定是默认的处理方式。如果不希望让...

深入理解java——多态与动态绑定

此文章为我阅读《java核心技术I》的读书笔记。 穿插个人理解和书上所述。 以及引用了网上的文章。侵权删。1.多态首先,什么是多态?根据定义上来讲,一个对象变量可以指示多种实际类型的现象被称为多态...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java中的多态和动态绑定
举报原因:
原因补充:

(最多只允许输入30个字)