java 多态[编程思想之8.2.1]

标签：

将一个方法调用同一方法主体关联进来就叫做绑定。如果在程序执行前进行绑定由编译器和连接程序实现，叫做前期绑定。这个是在面向过程的语言中不需要选择就默认的绑定方式。现在我对面各过程语言已经很模糊了，高中是只知道面向过程依稀记得那时用的好像是什么Fox或Fox什么的。

在运行时根据对象的类型进行绑定，叫做后期绑定也称动态绑定或运行时绑定。如果一种语言想实现后期绑定，，就必须具有某种机制，以便在运行时能判断对象的类型，从面调用恰当的方法。也就是说编译器一直不知道对象的类型，但是方法调用机制能找到正确的方法体，产加以调用。后期绑定机制随语言的不同而有所不同，介是只要想一下就会得知，不管怎样都必须在对象中安置某种“类型信息”。

Java中除了static和final方法（private方法属于final方法）之外，其他所有方法都是后期绑定。所以java中所有方法都是通过动态绑定实现多态的，所以就可以编写只与基类打交道的程序代码了，并且这些代码对所有的导出类都可以正确运行。或者说是发送消息给某个对象，让该对象去断定应该做什么事。

上例子说话：

package com.ebao.java.dynamic.binding;

public class Shape {
 public void draw(){}
 public void erase(){}
}

public class Circle extends Shape {
 public void draw(){
  System.out.println("========Circle.draw()==");
 }
 public void erase(){
  System.out.println("========Circle.erase()==");
 }
}

public class Square extends Shape {
 public void draw(){
  System.out.println("========Square.draw()==");
 }
 public void erase(){
  System.out.println("========Square.erase()==");
 }
}

public class Trangle extends Shape {
 public void draw(){
  System.out.println("========Trangle.draw()==");
 }
 public void erase(){
  System.out.println("========Trangle.erase()==");
 }
}

import java.util.Random;

public class RandomShapeGenerator {
 private Random ran = new Random(47);
 public Shape next(){
  switch(ran.nextInt(3)){
   default:
   case 0:return new Circle();
   case 1:return new Square();
   case 2:return new Trangle();
  }
 }
}

public class TestShape {
 private static RandomShapeGenerator gen = new RandomShapeGenerator();
 public static void main(String[] args){
  Shape[] s = new Shape[9];
  for(int i=0;i<s.length;i++){
   s[i] = gen.next();
  }
  for(Shape shp:s)
   shp.draw();
 }
}

运行结果：

========Trangle.draw()==
========Trangle.draw()==
========Square.draw()==
========Trangle.draw()==
========Square.draw()==
========Trangle.draw()==
========Square.draw()==
========Trangle.draw()==
========Circle.draw()==

RandomShapeGenerator是一种“工厂”（factory)，在每次调用next()方法时，它可以为随机选择的Shape对象产生一引用。请注意向上转型是在return语句里发生的。每个return语句取得一个指向某个Circle、Square、Triangle的引用，并将其以Shape类型从next()方法中发送出去。所以无论什么调用next()方法时，是绝对不可能知道具体类型到底是什么的。因为我们总是只能获得一通用的Shape引用。所以随机选择很好的说明了，在编译时，编译器不需要获得任何特殊信息就能进行正确的调用。对draw()方法的所有调用都是通过动态绑定进行的。

示例二: 创建一个包含两个方法的基类。在第一个方法中可以调用第二个方法。然后产生一个继承自该类的导出类，且覆盖基类中的第二个方法。为该导出类创建一个对象，将其向上转型到基类开并调用第一个方法。

package com.ebao.java.dynamic.binding;

public class Shape1 {
 public void draw(){
  System.out.println("-------------------Shape1.draw()");
  this.erase();
 }
 public void erase(){
  System.out.println("-------------------Shape1.erase()");
 }
}

public class TestShape1 extends Shape1 {
 public void erase(){
  System.out.println("-------------------TestShape1.erase()");
 }
 public static void main(String[] args){
  Shape1 s1 = new TestShape1();
  s1.draw();
 }
}

运行结果：

-------------------Shape1.draw()
-------------------TestShape1.erase()

由此可看出向上转型后的引用不管调用的方法有没有被导出类覆盖，整个过程中只要涉及到的方法被导出类覆盖了，动态绑定的就是导出类的方法。

java 多态[编程思想之8.2.1]

标签：

原文地址：http://www.cnblogs.com/yefy/p/4772660.html