Java中的多态的简单总结

       时间在流逝，春节也快要到了。别的同学都已经在家好多天，自己还在学校继续忙着。要想人前显贵，就得人后受罪，依然记得高中的时候物理老师送给我们的话，虽然有时候感觉很寂寞，但是想想现在的付出是为了以后的美好生活，还是会很有动力。

今天总结面向对象设计中的多态(polymorphism)了，刚开始接触多态这个概念的时候觉得很混乱，随着学习的不断深入，渐渐开始理解这种机制。

1. 多态的概念
2. 多态的实现机制
3. final关键字

一、多态的概念

       从字面上理解，多态可以理解为多种形态，多种类型。我们知道，通过继承可以使用父类型(supertype)来引用子类型变量(subtype)，也就是说，每个子类对象也可以看做是超类的对象，在程序中可以将多种类型（从同一基类导出的类型）视为同一类型来处理。而同一段代码也就可以毫无差别的运行在不同类型之上了。这些，就是实现多态机制的基础。一个对象变量可以引用多种实际类型的现象被称之为多态。

来看一段代码：

import java.util.*;/** * This program demonstrates inheritance. * @version 1.21 2013/01/25 * @author LiMing */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());   }}class Employee{   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;   }   private String name;   private double salary;   private Date hireDay;}class Manager extends Employee{   /**    * @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;   }   private double bonus;}

        我们可以想象，一个经理Manager必然是一个雇员Employee，经理是子类型，而雇员是父类型。在代码中我们通过

staff[0]=boss; 这条语句将Manager型的引用赋给了Employee类型，在Employee类中拥有一个方法getSalary(),而在Manager中有同样的一个方法getSalary()，程序运行的最后结果我们惊奇的发现，Employee型的对象引用竟然正确的调用了我们希望的Manager的getSalary方法。这个例子作为多态的简单演示，下面我们来讨论多态的实现机制。

二、多态的实现机制

       首先我们先了解几个术语：绑定(binding),《Java编程思想》中说“将一个方法调用同一个方法主体关联起来被称作绑定”

。

这句话个人理解是这样的：假设集合A是一个由所有类中的所有的方法组成的方法集合，集合B是由全部的对象以及每个对象所拥有

的动作（方法）组成的集合，当我们程序在出现方法调用的时候，必然是由集合B和集合A中的两个元素进行交互。B中的一个元素调

用A中的方法时，通过一个过程来找到确定的该调用的方法，这个过程被称之为绑定。
在程序执行之前进行的绑定被称之为前期绑定(静态绑定)这是由编译器以及连接程序确定的（至于前期绑定的具体过程还请高手不

吝赐教），在程序运行过程中实现的绑定被称之为后期绑定(动态绑定、运行时绑定)。在Java中所有的方法都是通过动态绑定来实

现多态的
     我们主要来研究动态绑定这个概念，首先我们需要区分变量的实际类型（actual type）与声明类型（declared type），我们

知道一个变量必须要被声明为某种类型。请看下面这两句代码：

Employee obj = new Manager();obj.getSalary();

这里obj的声明类型是Employee，一个引用变量可以是一个null值或者是一个对声明类型实例的引用。实例可以是该类型本身或者它

的子类型。变量的实际类型是被变量引用的对象的实际类。在这里obj引用的是Manager类型的变量，所以obj的声明类型是Employee

，实际类型是Manager。当调用getSalary方法时是由obj的实际类型所决定的，因为在程序运行之前我们并不能够确定某个变量将引

用何种类型，所以需要在运行时加以确定，从而调用相应的方法，这就是动态绑定。

 

我们来看看动态绑定的工作机制：
   1>编译器查看对象的声明类型以及方法名。假设调用obj.function(param),且隐式参数obj被声明为C类的对象(C类作为子类来看

待)。需要注意的是：有可能存在多个名字为funciton的，但参数类型不一样的方法。例如可能存在function(int),function

（String）等。编译器会列举C类中的所有名为function的方法和其超类中访问属性为public的且名为function的方法。至此编译器

已经获得了所有可能被调用的候选方法。
   2>接下来编译器将查看调用方法时提供的类型参数。如果所有名为function的方法中存在一个与提供的类型参数完全匹配，就选

择这个方法。这个过程被称之为重载解析(overloading resolution)
总之，当程序运行时并且采用动态绑定调用方法时，虚拟机一定调用与obj所引用的对象的实际类型最适合的那个类的方法。假设

obj的实际类型是A，需要调用function（int）型的方法，它是B类的子类，如果A类定义了function（int）方法，就直接调用它；

否则在A类的超类中寻找function(int),以此类推。
我们来看一段代码：

public class DynamicBinding {/** * 演示动态绑定 * @author LiMing * @since 2013/01/25 * @param args */public static void main(String[] args) {// TODO Auto-generated method stubPerson[] p =new Person[3];p[0]=new Person();p[1]=new Student();p[2]=new GraduateStudent();for(Person obj:p)printObject(obj);}public static void printObject(Object o){System.out.println(o.toString());}}class Person{public Person(){}public String toString(){return "This is class Person!";}}class Student extends Person{public Student(){}public String toString(){return "This is class Student!";}}class GraduateStudent extends Student{public GraduateStudent(){}public String toString(){return "This is calss GraduateStudent！";}}

匹配方法的签名和绑定的方法的实现是两个独立的事情。引用变量的声明类型决定了编译时匹配哪个方法。编译器在编译时，会根据类型参数、参数个数和参数顺序找到匹配的方法。一个方法可能在几个子类中都被实现。Java虚拟机在运行是动态绑定的方法的实现，这是由变量的实际类型决定的。