多态

一、多态简要介绍
面向对象的程序设计的三大支柱：封装、继承和多态。接下来将给大家介绍其中的多态。
首先，定义两个有用的术语：子类型和父类型。一个类实际上定义了一种类型。子类定义的类型称为子类型（subtype)，而父类定义的类型称为父类型（supertype)。因此，可以说Circle式GeometriObject的子类型，而GeometriObject是Circle的父类型。
继承关系使一个子类继承父类的特征，并且反过来附加一些新的特征。子类使它的父类的特殊化，每个子类的实例都是其父类的实例，但是反过来就不成立。例如：每个圆都是一个几何对象，但并非每个几何对象都是圆。因此，总可以将子类的实例传给需要父类型的参数。
如下程序：

public class PolymorphismDemo { 
 /** Main method */ 
 public static void main(String口 args){ 
   // Display circle and rectangle properties
 displayObject(new CircleFromSimpleCeometricObject(1, "red”，false));
 displayObject(new RectangleFromSimpleCeometricObject (1, 1,"black", true)); 
  }
 /** Display geometric object properties V
 public static void displayObject(Simp!eCeometricObject object){
 System out.println("Created on + object.getDateCreatedO +
 Color is " + object.getColorO);
 }
 }

方法displayObject具有GeometricObject类型的参数。可以通过传递任何一个GeometricObject的实例（例如：new new CircleFromSimpleCeometricObject(1，“red”.false)和 new RectangleFromSimpleGeometricObject(l,l,“black”,false))来调用displayObject。使用父类对象的地方都可以使用子类的对象。这就是通常所说的多态（polymorphism)。简单来说，多态意味着父类型的变量可以引用子类型的对象，即父类型可以指向子类对象。
二、多态的实现
前面我们提到了面向对象的三大支柱，其中有一个是继承，继承就是在为多态的实现做了准备。子类继承父类，我们可以编写一个指向子类的父类类型引用，该引用既可以处理父类对象，也可以处理子类对象，当相同的消息发送给子类或者父类对象时，该对象就会根据自己所属的引用而执行不同的行为，这就是多态，即多态性就是相同的消息使得不同的类做出不同的响应。实现多态有三个必要条件：继承、重写、向上转型
继承：在多态中必须存在有继承关系的子类和父类
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样引用才能够具备技能调用父类方法和子类方法
只有满足了上述三个条件，我们才能够在同一继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为
对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法
多态的实现形式：继承和接口
继承关系是一个子类继承父类的特征，并且附加一些新特征，子类是它的父类的特殊化，每个子类的实例都是其父类的实例，但是反过来就不成立。例如：每个圆都有一个几何对象，但并非每个几何对象都是圆。例如下面这个例子：

public class PolymorphismDemo {
  /** Main method */
  public static void main(String[] args) {
    // Display circle and rectangle properties
    displayObject(new CircleFromSimpleGeometricObject
        (1, "red", false));
    displayObject(new RectangleFromSimpleGeometricObject
        (1, 1, "black", true));
  }

  /** Display geometric object properties */
  public static void displayObject(SimpleGeometricObject object) {
    System.out.println("Created on " + object.getDateCreated() +
      ". Color is " + object.getColor());
  }
}

动态绑定：
方法可以在沿着继承链的多个类中实现，JVM决定运行时间时调用哪个方法。
方法可以在父类中定义而在子类中重写。例如：toString()方法是在Object类中定义的，而在GeometricObject类中重写。
动态绑定的工作机制：
假设对象o是类C1、 C2、 …、Cn-1 、Cn的实例，其中C1 是C2的子类， C2 是C3的子类， …, Cn-1 是Cn的子类。也就是说，Cn是最通用的类，C1是最特殊的类。在Java中，Cn是Object类。如果对象o调用一个方法p，那么Java虚拟机会依次在类C1、 C2、 …、Cn-1 、 Cn中查找方法p的实现，直到找到为止。一旦找到一个实现，就停止查找并调用这个第一次找到的实现。
如图所示：

例子：

public class PolymorphismDemo {
  public static void main(String[] args) {
    m(new GraduateStudent());
    m(new Student());
    m(new Person());
    m(new Object());
  }
 
  public static void m(Object x) {
    System.out.println(x.toString());
  }
}
 
class GraduateStudent extends Student {
}
 
class Student extends Person {
  public String toString() {
    return "Student";
  }
}
 
class Person extends Object {
  public String toString() {
    return "Person";
  }
}

方法匹配和绑定
匹配方法的签名和绑定方法的实现是两个独立的事情。引用变量的声明类型决定了编译时匹配哪个方法。编译器会在编译时，根据参数类型、参数个数和参数顺序找到匹配的方法。一个方法可能在几个子类中都被实现。Java虚拟机在运行时动态绑定方法的实现，这是由变量的实际类型决定的。
对象转换
我们已经使用过转换运算符把一种基本类型变量转换为另一种基本类型。也可以使用转换把一种类类型的对象转换为继承体系结构中的另一种类类型的对象。
例如：

m(new Student());

将对象new Student（）赋值给一个Object类型的参数，这条语句等价于：

Object o=new Student();
m(o);

在这里语句Object o = new Student()被称为隐式转换(implicit casting)，是合法的，因为Student的实例自动地就是Object的实例。
将一个父类转换为子类：
当把一个父类的实例转换为它的子类变量时，必须使用转换记号“（子类名）”进行显式转换。下面的转换不可能总会成功。

Apple x = (Apple)fruit;
Orange x = (Orange)fruit;

其实为了更好地理解类型转换，可以认为它们类似于水果、苹果、橘子之间的关系，其中水果类Fruit是苹果类Apple和橘子类Orange的父类。苹果是水果，所以，总是可以将Apple的实例安全地赋值给Fruit变量。但是，水果不一定是苹果，所以，必须进行显式转换才能将Fruit 的实例赋值给Apple的变量。