java之旅 （五）多态性

多态性是继数据抽象和继承后，面向对象语言的第三个特征。

 

绑定（binding）（看起来到像一个音译词）：将方法的调用连到方法本身被称为绑定，当绑定发生在程序运行之前，被称做前绑定（earlybinding）,而在程序运行的时候根据对象的类型来决定该绑定方法的成为后绑定，也叫运行时绑定（run-time binding）或动态绑定（dynamic binding）；java的所有方法都采用后绑定，也就是说通常情况下，

你不用考虑是不是该采用后绑定，这一切都是自动的。

 

有一个经典的关于“形状”的例子，可以生动的说明什么是后绑定。

 

在这个例子中，基类是shape类，它有几个派生类：circle, Square, Triangle,

Shape s = new Circle();

这里先创建了一个Circle对象，接着把它给了一个Shape，看上去这样做有点不妥，不过确是不错的，因为Circle确实也是个Shape，接着假设你调用了一个基类的方法

     s.draw();

可能你会认为这次调用的应该是shape的draw方法吧，然而不是，它调用的却是circle的draw(),这就是因为实现的后绑定的原因。具体的实现方法就是基类定义了一个共用的接口――也就是说所有的shape都有draw()方法和erase（）方法，派生类会覆写这两个方法从而提供不同的行为。到这里我想为什么不直接写成：

Circle s = new Circle();

s.draw();

后来看到作者将这个例子改动成随机的创建一个Circle, Square, Triangle对象，因为这时还不知道创建的对象具体是什么，所以只有像前面的那样的写法利用动态绑定才能实现。

      

       由此我们看到了多态性的最大优势：可扩展性。我们可以根据需要添加任意个新的类型，而不用担心修改基类里的方法，因此在一个设计良好的OOP程序里，绝大多数方法都会和draw()方法一样，只跟基类接口打交道。这种程序是可扩展的，因为你可以通过“让新的数据类型继承通用的基类“的方法来添加新的功能。而那些与基类接口打交道的方法，根本不需要做修改就能适应新的类。

 

       对程序员来说，多态性是一项非常重要的技术，它能让你将“会变的和不会变的分隔开来“。

 

抽象类和抽象方法：要创建像shape类这样的类对象是没有实际意义的，更何况你可能还要阻止用户这么做，这样我们可以使用抽象方法来解决这个问题。形如：

        abstract void f();

而包含一个或多个抽象方法的类就是抽象类（含有抽象方法是必须被定义位抽象类的），抽象类的作用是通过一个公共的接口来操控一组类。它的方法就像上面例子里基类的方法一样，只是样子货。而且如果创建一个抽象类的对象，编译器就会报错。

 

       如果你继承了抽象类，并打算创建该类的对象，那就必须实现基类所定义的全部方法，否则有一个抽象方法存在的话，那么该类还是个抽象类。

 

       创建一个不包含抽象方法的抽象类是可以的，这种技巧可以用于“不必创建抽象方法，但又想禁止别人创建这个类的对象的场合”。

 

       构造函数总是与众不同，牵涉到多态性也不例外。首先研究一个例子，复习一下构造函数的调用顺序先。

///////////////////////////////////////////////////////////////////////////////////

class Meal {

  Meal() { System.out.println("Meal()"); }

}

class Bread {

  Bread() { System.out.println("Bread()"); }

}

class Cheese {

  Cheese() { System.out.println("Cheese()"); }

}

class Lettuce {

  Lettuce() { System.out.println("Lettuce()"); }

}

class Lunch extends Meal {

  Lunch() { System.out.println("Lunch()"); }

}

class PortableLunch extends Lunch {

  PortableLunch() { System.out.println("PortableLunch()");}

}

public class Sandwich extends PortableLunch {

  private Bread b = new Bread();

  private Cheese c = new Cheese();

  private Lettuce l = new Lettuce();

  public Sandwich() {

    System.out.println("Sandwich()");

  }

  public static void main(String[] args) {

new Sandwich();

System.out.println("正确输出：");

    System.out.println(

      "Meal()/n"+

      "Lunch()/n"+

      "PortableLunch()/n"+

      "Bread()/n"+

      "Cheese()/n"+

      "Lettuce()/n"+

      "Sandwich()"

   );

  }

} 

///////////////////////////////////////////////////////////////////////////

也就是说复杂对象的构造函数的调用顺序是这样的：

1，  调用基类的构造函数。这是一个递归的过程，因此会先创建继承体系的根，然后是下一级派生类，以次类推直到最后一个继承类的构造函数。

2，  成员对象按照其声明的对象顺序进行初始化。

3，  执行继承类的构造函数的正文。

 

关于清理工作，虽不常用，但是个非常需要小心的工作。

 

一个好的构造函数应该，“用最少的工作量把对象的状态设置好，而且要尽可能的避免去调用方法”构造函数唯一能安全调用的方法就是基类的final方法。（这一条也同样适用private,因为它自动就是final）他们不会覆写，因此也不会产生这种意外的行为。

1>     在了解了多态性的一些概念后，我们再来看看类的设计

在类的继承方式里有种方式叫“纯继承”就像下图

由于有着相同的接口，基类可以接受任何发送给派生类的消息。你所要做的，只是将派生类的对象上传，然后就不再需要知道这个对象是什么类型的了。所有的对象都交由多态性来处理。看起来这是一个很好的办法，但事实是很多时候你的派生类都会有比基类更多的接口或者方法比如下面这个图。

看起来这才是实际中常常用到的情形，但同时它也带来了一个缺点，不能通过基类访问派生类的扩展方法，如果在程序中出现了这样的错误，系统会抛出一个ClassCastException 的异常，这种运行时的类型检查被称为“运行时的类型鉴别run-time type identification (RTTI)” 关于RTTI在后面的学习中还有更详细的介绍。

 

最后有个重要的概念再重申一下：人们常常会将多态性同java的那些非面向对象的特性相混淆，比如方法的重载，它常常会被当作面向对象的特点介绍给大家。千万记住“不是后绑定的，就不是多态性”。（我也以为重载是多态性的一种体现 。汗～）