多态（2）：转机

怼烎@ 2023-07-03 04:45 37阅读 0赞

运行这个程序后，我们便会发现Music.java的难点所在。Wind.play()方法将产生输出结果。这无疑是我们所期望的输出结果，但它看起来似乎又没有什么意义。请观察一个tune()方法：

public static void tune(Instrument i) {
    		i.play(Note.MIDDLE_C);
    	}

它接受一个Instrument引用。那么在这种情况下，编译器怎样才能知道这个Instrument引用指向的是Wind对象，而不是Brass对象或Stringed对象呢？实际上，编译器无法得知。为了深入理解这个问题，有必要研究一下绑定这个话题。

### 一、方法调用绑定 ###

将一个方法调用同一个方法主体关联起来被称作绑定。若在程序执行前进行绑定（如果有的话，由编译器和连接程序实现），叫做前期绑定。你可能以前从来没有听过这个术语，因为它是面向过程的语言中不需要选择就默认的绑定方式。例如，C只有一种方法调用，那就是前期绑定。

上述程序之所以令人迷惑，主要是因为前期绑定。因为，当编译器只有一个Instrument引用时，它无法知道究竟调用哪个方法才对。

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

java中除了static方法和final方法（private方法属于final方法）之外，其他所有的方法都是后期绑定。这意味着通常情况下，我们不必判定是否应该进行后期绑定--它会自动发生。

为什么要将某个方法声明为final呢？它可以防止其他人覆盖该方法。但更重要的一点或许是：这样做可以有效地“关闭”动态绑定，或者说，告诉编译器不需要对其进行动态绑定。这样，编译器就可以为final方法调用生成更有效的代码。然而，大多数情况下，这样做对程序的整体性能不会有什么改观。所以，最好根据设计来决定是否使用final，而不是出于试图提高性能的目的来使用final。

### 二、产生正确的行为 ###

一旦知道java中所有方法都是通过动态绑定实现多态这个事实之后，我们就可以编写只与基类打交道的程序代码了，并且这些代码对所有的导出类都可以正确运行。或者换一种说法，发送消息给某个对象，让该对象去断定应该做什么事。

面向对象程序设计中，有一个经典的例子就是“几何形状”（shape）。因为它很直观，所以经常用到；但不幸的是，他可能使初学者认为面向对象程序设计仅适用于图形化程序设计，实际当然不是这样。

在“几何形状”这个例子中，有一个基类Shape，以及多个导出类--如Circle、Square、Triangle等。这个例子之所以好用，是因为我们可以说“圆是一种几何形状”，这种说法也很容易被理解。下面继承图展示它们之间的关系：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70][]

向上转型可以向下面这条语句这么简单：

Shape s = new Circle();

这里，创建了一个Circle对象，并把得到的引用立即赋值给Shape，这样做看似错误（将一种类型赋值给另一种类型）；但实际上是没问题的，因为通过继承，Circle就是一种Shape。因此，编译器认可这条语句，也就不会产生错误信息。

假设你调用一个基类方法（它已在导出类中被覆盖）：s.draw()；你可能再次认为调用的是Shape的draw()，因为这毕竟是一个Shape引用，那么编译器是怎样知道去做其他的事情呢？由于后期绑定（多态），还是正确调用了Circle的draw()方法。

下面的例子稍微有所不同：

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 Triangle extends Shape {
    	public void draw() {
    		System.out.println("Triangle的draw()");
    	}
    
    	public void erase() {
    		System.out.println("Triangle的erase()");
    	}
    }

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

public class Shapes {
    	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 shape : s) {
    			shape.draw();
    		}
    	}
    }

Shape基类为自它那里继承而来的所有导出类建立了一个公用接口--也就是说，所有形状都可以描绘和檫除。导出类通过覆盖这些定义，来为每种特殊类型的几何形状提供单独的行为。

RandomShapeGenerator是一种“工厂”（factory），在我们每次调用next()方法时，它可以为随机选择的Shape对象产生一个引用。请注意向上转型是在return语句里发生的。每个return语句取得一个指向某个Circle、Square或者Triangle的引用，并将其以Shape类型从next()方法中发送出去。所以无论我们在什么时候调用next()方法时，是绝对不可能知道具体类型到底是什么的，因为我们总是只能获得一个通用的Shape引用。

main()包含了一个Shape引用组成的数组，通过调用RandomShapeGenerator的next()来填入数据。此时，我们只知道自己拥有一些Shape，除此之外不会知道更具体的情况（编译器也不知道）。然而，当我们遍历这个数组，并为每个数组元素调用draw()方法时，与类型有关的特定行为会神奇般地正确发生，我们可以从运行该程序时所产生的输出结果中发现这一点。

随机选择几何形状是为了让大家理解：在编译时，编译器不需要获得任何特殊信息就能进行正确的调用。对draw()方法的所有调用都是通过动态绑定进行的。

### 三、可扩展性 ###

现在，让我们返回到“乐器”（Instrument）示例。由于有多态机制，我们可根据自己的需求对系统添加任意多的新类型，而不需更改tune()方法。在一个设计良好的OOP程序中，大多数或者所有方法都会遵循tune()的模型，而且只与基类接口通信。这样的程序是可扩展的，因为可以从通用的基类继承出新的数据类型，从而新添加一些功能。那些操作基类接口的方法不需要任何改动就可以应用于新类。

考虑一下：对于“乐器”的例子，如果我们向基类中添加更多的方法，并加入一些新类，将会出现什么情况呢？请看下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70 1][]

事实上，不需要改动tune()方法，所有的新类能与原有类一起正确运行。即使tune()方法是单独存放在某个文件中，并且Instrument接口中添加了其他的新方法，tune()也不需要在编译就能正确运行。下面是上图的具体实现：

/**
     * 乐器
     */
    class Instrument {
    	void play(Note n) {
    		System.out.println("Instrument的play()" + n);
    	}
    
    	String what() {
    		return "Instrument";
    	}
    
    	// 调整
    	void adjust() {
    		System.out.println("Adjusting Instrument");
    	}
    }
    
    class Wind extends Instrument {
    	void play(Note n) {
    		System.out.println("Wind的play()" + n);
    	}
    
    	String what() {
    		return "Wind";
    	}
    
    	void adjust() {
    		System.out.println("Adjusting Wind");
    	}
    }
    
    /**
     * 敲打乐器
     */
    class Percussion extends Instrument {
    	void play(Note n) {
    		System.out.println("Percussion的play()" + n);
    	}
    
    	String what() {
    		return "Percussion";
    	}
    
    	void adjust() {
    		System.out.println("Adjusting Percussion");
    	}
    }
    
    /**
     * 弦乐器
     */
    class Stringed extends Instrument {
    	void play(Note n) {
    		System.out.println("Stringed的play()" + n);
    	}
    
    	String what() {
    		return "Stringed";
    	}
    
    	void adjust() {
    		System.out.println("Adjusting Stringed");
    	}
    }
    
    /**
     * 管乐
     */
    class Brass extends Wind {
    	void play(Note n) {
    		System.out.println("Brass的play()" + n);
    	}
    
    	void adjust() {
    		System.out.println("Adjusting Brass");
    	}
    }
    
    /**
     * 木管乐器
     */
    class Woodwind extends Wind {
    	void play(Note n) {
    		System.out.println("Woodwind的play()" + n);
    	}
    
    	String what() {
    		return "Woodwind";
    	}
    }
    
    public class Music3 {
    	public static void tune(Instrument i) {
    		i.play(Note.MIDDLE_C);
    	}
    
    	public static void tuneAll(Instrument[] e) {
    		for (Instrument instrument : e)
    			tune(instrument);
    	}
    
    	public static void main(String[] args) {
    		Instrument[] orchestra = { new Wind(), new Percussion(), new Stringed(), new Brass(), new Woodwind() };
    		tuneAll(orchestra);
    	}
    }

新添加的方法what()返回一个带有类描述的String引用；另一个新添加的方法adjust()则是提供每种乐器的调音方法。

在main()中，当我们将某种引用置入orchestra数组中，就会自动向上转型到Instrument。

可以看到，tune()方法完全可以忽略它周围代码所发生的全部变化，依旧正常运行。这正是我们期望多态所具有的特性。我们所做的代码修改，不会对程序中其他不应受到影响的部分产生破坏。换句话说，多态是一项让程序员“将改变的事物与未变的事物分离开来”的重要技术。

### 四、缺陷：“覆盖”私有方法 ###

我们试图像下面这样做也是无可厚非的：

public class PrivateOverride {
    	private void f() {
    		System.out.println("private f()");
    	}
    
    	public static void main(String[] args) {
    		PrivateOverride po = new Derived();
    		po.f();
    	}
    }
    
    class Derived extends PrivateOverride {
    	public void f() {
    		System.out.println("public f()");
    	}
    }

我们所期望的输出是public f()，但是由于private方法被自动认为是final方法，而且对导出的类是屏蔽的。因此，在这种情况下，Derived类中的f()方法就是一个全新的方法；既然基类中的f()方法在子类Derived中不可见，因此甚至也不能被重载。

结论就是：只有非private方法才可以被覆盖；但是还需要密切注意覆盖private方法的现象，这时虽然编译器不会报错，但是也不会按照我们所期望的来执行。确切地说，在导出类中，对于基类中的private方法，最好采用不同的名字。

### 五、缺陷：域与静态方法 ###

一旦你了解了多态机制，可能就会开始认为所有事物都可以多态地发生。然而，只有普通的方法调用可以是多态的。例如，如果你直接访问某个域，这个访问就将在编译期进行解析，就像下面的示例所演示的：

class Super {
    	public int field = 0;
    
    	public int getField() {
    		return field;
    	}
    }
    
    class Sub extends Super {
    	public int field = 1;
    
    	public int getField() {
    		return field;
    	}
    
    	public int getSuperField() {
    		return super.field;
    	}
    }
    
    public class FieldAccess {
    	public static void main(String[] args) {
    		Super sup = new Sub();
    		System.out.println("sup.field = " + sup.field + ", sup.getField() = " + sup.getField());
    		Sub sub = new Sub();
    		System.out.println("sub.field = " + sub.field + ", sub.getField() = " + sub.getField()
    				+ ", sub.getSuperField() = " + sub.getSuperField());
    	}
    }

当Sub对象转型为Super引用时，任何域访问操作都将由编译器解析，因此不是多态的。在本例中，为Super.field和Sub.field分配了不同的存储空间。这样，Sub实际上包含两个称为field的域：它自己和它从Super处得到的。然而，在引用Sub中的field时所产生的默认域并非Super版本的field域。因此，为了得到Super.field，必须显式地指明super.field。

尽管这看起来好像会成为一个容易令人混淆的问题，但是在实践中，它实际上从来不会发生。首先，你通常会将所有的域都设置成private，因此不能直接访问它们，其副作用是只能调用方法来访问。另外，你可能不会对基类中的域和导出类中的域赋予相同的名字，因为这种做法容易令人混淆。

如果某个方法是静态的，它的行为就不具有多态性：

class StaticSuper {
    	public static String staticGet() {
    		return "Base staticGet()";
    	}
    
    	public String dynamicGet() {
    		return "Base dynamicGet()";
    	}
    }
    
    class StaticSub extends StaticSuper {
    	public static String staticGet() {
    		return "Derived staticGet()";
    	}
    
    	public String dynamicGet() {
    		return "Derived dynamicGet()";
    	}
    }
    
    public class StaticPolymorphism {
    	public static void main(String[] args) {
    		StaticSuper sup = new StaticSub();
    		System.out.println(sup.staticGet());
    		System.out.println(sup.dynamicGet());
    	}
    }

静态方法是与类，而并非与单个对象相关联的。

**如果本文对您有很大的帮助，还请点赞关注一下。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200202123148875.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200203104041465.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx,size_16,color_FFFFFF,t_70