第四章 接口与多态
接口在语法上与抽象类类似，它声明了若干抽象方法和常量，其主要作用是帮助实现类的多重继承功能。
多态性是面向对象设计语言的重要特性之一。
4.1 接口
接口允许创建者规定一个类的基本形式：方法名、自变量列表以及返回类型，但不规定方法主题。接口也包含了数据成员，但默认都为static和final。接口只提供一种形式并不提供具体的细节。
4.1.1 接口的作用及语法
1 接口的作用
Java的接口也是面向对象的一个重要机制。它的引进是为了实现多继承，同时免除C++中的多继承那样的复杂性。接口中的所有方法都是抽象的，这些抽象方法由实现这一接口的不同类来具体完成。
Java可以建立类与类之间的“协议”。将类根据其实现的功能分组，用接口代表，而不必顾虑它所在的类继承层次；这样可以最大限度地利用动态绑定，隐藏实现细节。
还可以实现常量的共享。
如图1所示。Java还可以在看起来不相干的对象之间定义共同的行为。
图1
2 接口的语法
声明格式如下：
[接口修饰符] interface 接口名称 [extends 父接口名]{
..//方法的原型声明或者静态变量
}
接口与一般类一样，本身也有数据成员与方法，但数据成员一定要赋予初值，且不可修改（因为是常量），此时final可以省略。方法必须是“抽象方法”，public和abstract也可以省略。
例：声明一个接口Shape2D，包括π和计算面积的方法原型：
| 1 2 3 4 5 6 7 8 9 10 | interface Shape2D{//声明Shape2D接口 final double pi =3.14;//数据成员一定要初始化 public abstract double area();//抽象方法 } /*如前文所讲，在接口声明中，我们可以省略final, public,abstract等关键字。因此可以修改为以下格式：*/ interface Shape2D{ double pi = 3.14; double area(); } |
接口不能实例化，即不可能new一个出来。
4.1.2 实现接口
接口的使用
利用接口设计类的过程，被称为接口的实现，使用implements关键字，语法如下：
| 1 2 3 4 | public class 类名称 implements 接口名称{ //在类体中实现接口的方法 //本来声明的更多变量和方法 } |
注意：
（1）必须实现接口中的所有方法；
（2）来自接口的方法必须是public。
例：实现接口Shape2D
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | //接上面的接口声明 class Circle implements Shape2D{ double radius; public Circle(double r { radius = r; } public double area(){ return(pi*radius*radius; } } class Rectangle implements Shape2D{ int width,height; public Rectangle(int w, int h){ width = w; height = hl } public double area(){ return(width*height); } } |
测试一下：
| 1 2 3 4 5 6 7 8 | public class InterfaceTester{ public static void main(String args[]){ Rectangle rect = new Rectangle(5,6); System.out.println("Area of rect = " + rect.area()); Circle cir = new Circle(2.0); System.out.println("Area of cir = " + cir.area()); } } |
结果为
Area of rect = 30.0
Area of cir =12.56
例：接口类型的引用变量:
| 1 2 3 4 5 6 7 8 9 | public class InterfaceTester{ public static void main(String args[]){ Shape2D var1,var2; var1 = new Rectangle(5,6); System.out.println("Area of rect = " + var1.area()); var2 = new Circle(2.0); System.out.println("Area of cir = " + var2.area()); } } |
4.1.3 多重继承
一个类可以实现多个接口，通过这种机制可以实现对设计的多重继承。
实现多个接口的语法如下：
[类修饰符] class 类名 implements 接口1,接口2,…{……}
4.1.4 接口的扩展
已有的接口称为超接口，父接口，基本接口等，扩展出来的接口为子接口。
接口扩展的语法：
interface 子接口的名称 extends 超口1,超口2,…{……}
说明：
（1）首先声明父接口，然后声明其子接口；
（2）之后声明类实现子接口，因此必须在此类内明确定义子接口中抽象方法的处理方式；
（3）最后在主类中我们声明了类型的变量并创建对象，最后通过对象调用那些方法。
4.2 塑型（类型转换）
4.2.1~4.2.2 类型转换
1.转换方式：隐式的类型转换和显式的类型转换。
2.从方向来看：向上转型和向下转型。
3.类型转换规则：
（1）基本类型转换：将值一种类型转换成另一种类型。
（2）引用变量的转换：将引用转换向另一类型的引用，并不改变对象本身的类型。
它只能被转换为：
任意一个（直接或间接）超类的类型（向上转型）；
对象所属的类（或其超类）实现的一个接口（向上转型）；
被转为引用指向的对象的类型（唯一可以向下转型的情况）。
（3）当一个引用被转为其超类引用后，通过他能够访问的只有在超类中声明过的方法。
如图2所示：
图2
我们看这里定义了一个person类，隐含的继承或者扩展了Object类，然后Employee雇员类继承了person类，customer顾客类也继承了person类，manager继承了雇员类，person实现了insurable接口，另外company，car都继承了insurable接口。所以把这一组可以被保险的对外接口规定在insurable这个接口里面。
下面来看，manager类型的引用可以被转换成什么呢？按照继承的层次，它可以被转型为employee雇员类，子类对象总是可以充当超类对象用的；还可以转换成person类型和object类型。由于person实现了insurable接口，所以manager课转型为insurable接口。由于没有继承关系，也不是实现接口的关系，manager又不能被塑型为customer还有company或者car。
1.隐式转换（自动转换）
基本数据类型：可以转换的类型直接，存储容量低自动向高的类型转换。
引用变量：被转成更一般的类（向上的超类）。例如：
Employee emp;
emp = new Manager();//将manager类型对象直接赋
//给Employee类的饮用对象，系统会自动将manage转换
//为employee类
2.显式类型转换
引用变量
| 1 2 3 4 | Employee emp; Manager man; emp = new Manager(); man = (Manager)emp;//将emp显式转换为它指向的对象的类型 |
类型转换的主要应用场合：
（1）赋值转换：赋值运算符右边的表达式或对象类型转换为左边的类型；
（2）方法调用转换：实参的类型转换为形参的类型；
（3）算术表达式转换：算术混合运算时，不同类型的操作数转换为相同的类型再进行运算；
（4）字符串转换：字符串连接运算时，如果一个操作数为字符串，另一个操作数为其他类型，则会自动将其他类型转换为字符串。
4.2.3 查找方法
如果转换前后两个类都提供了相同方法，那么系统会调用哪个类的方法呢？
1. 实例方法查找
我们通过图3来看一下实例方法的查找。实例方法是非静态方法。对于实例方法，从对象创建时的类开始，沿类层次向上查找。例如，
| 1 2 3 4 5 6 | Manager man = new Manager(); Employee emp1 = new Employee(); Employee emp2 = (Employee)man; emp1.computePay();//调用employee类中的computePay()中的方法 man.computePay();//调用manager类中的computePay()方法； emp2.computePay();//调用manager类中的computePay()方法。 |
图3
2.类方法查找
这里，我们以图4为例来讲解。对于类方法，查找在编译时进行，所以总是在变量声明时所属的类中进行查找。
例如：
| 1 2 3 4 5 6 7 8 9 | Manager man = new Manager(); Employee emp1 = new Employee(); Employee emp2 = (Employee)man; Manager.expenseAllowance();//in manager man. .expenseAllowance();//in manager Employee.expenseAllowance();//in employee emp1.expenseAllowance();//in employee emp2.expenseAllowance();//in employee因为总是在变量声明时 //所属的类中进行查找。emp2声明的是employee类 |
图4
4.3 多态的概念
超类对象和从相同的超类派生出来的多个子类的对象，可被当作同一种类型的对象对待；
实现统一接口的不同类型对象，也可以被当作同一种类型的对象对待；
可向这些不同类型的对象发送同样的消息，由于多态性，这些不同类的对象响应同一消息时的行为可能有所差别。
多态的目的：
（1）使代码变得更简单且容易理解；
（2）使程序具有很好的可扩展性。
接下来结合一个例子来进行介绍。如图5所示。我们来看这个继承关系图，最上面的这个和超类shape类里面，声明了一个绘图方法draw()还有一个擦出方法erase()。子类circle、square、triangle中都覆盖了这两个方法。以后绘图可以如下进行：
| 1 2 | Shape s =new Circle(); s.draw();//实际调用的是circle对象的draw() |
图5
绑定就是将一个方法调用表达式与方法体的代码结合起来。它分为：
早绑定：程序运行之前执行绑定（编译时）
晚绑定：基于对象的类别，在程序运行时执行。又被称为动态绑定或者运行绑定。若一种语言实现了后期绑定，同时必须提供一些机制，课在运行期间判断对象的类型，并分别调用适当的方法。
4.4 多态的应用举例
例子：二次分发
有不同种类的交通工具（vehicle），如公共汽车（bus）及小汽车（car），由此可声明一个抽象类Vehicle和两个子类Bus，Car。
声明一个抽象类Driver和两个子类FemaleDriver及MaleDriver；
在Driver中声明抽象方法drives，在两个子类中对这个方法进行覆盖；
drives接受一个Vehicle类的参数，当不同类型的交通工具被传送到此方法时，可以输出具体的交通工具；
所有的类放在drive包中。
具体代码详见课本。
二次分发即对输出消息的请求被分发两次，首先根据驾驶员的类型发送给一个类，之后根据交通工具的类型发送给另一个类。
4.5 构造方法与多态
构造方法不具有多态性。
构造子类对象时构造方法的调用顺序：
首先是调用超类的构造方法；这个步骤会不断重复下去，首先被执行的是最远超类的构造方法；
执行当前子类对象的构造方法体的其它语句。
注意：子类不能直接存取父类中声明的私有数据成员。所以在该类方法中要调用它超类的toString时用super.toString。
如果构造方法中调用多态方法会发生什么呢？
会造成一些难以发现的程序错误。从概念上讲，构造方法的职责是让对象实际进入存在状态。在任何构造方法内部，整个对象可能只是得到部分初始化，但却不知道哪些类已经继承。然而，一个动态绑定的方法调用却会调用位于派生类里的一个方法。如果在构造方法内部做这件事情，那么对于调用方法，它要操纵的成员可能尚未得到正确的初始化，就会造成一些难以发现的程序错误。
实现构造方法的注意事项：
（1）用尽可能少的动作把对象的状态设置好。构造方法就是用来初始化的，别干别的事情。
（2）如果可以避免不要调用任何方法。
（3）在构造方法内唯一能够安全调用的是在基类中具有final属性的哪些方法（private方法也可以，因为它们自动具有final属性）。这些方法不能被覆盖，所以不会出现问题。
