在"oop简介:理解类和对象"这篇文章中,我们讨论了继承和多态性的好处.我们还粗略的学习了如何扩展基类定义子类,继承基类中合适的行为和属性而重载那些并不适合的行为和属性.这种方式能够削减代码宏余以及错误的堆积.
　　
　　现在我们将更深入的考察多重继承性以及java是如何处理它的.我们还将通过学习动态绑定来学习多态性.
　　
　　深入继承性
　　一些面向对象的语言提供叫做"多重继承"的特点,当一个对象需要从多于一个的基类继承行为和属性的时候这是有价值的.多重继承在有些情况下是复杂的.例如,假设我们需要定义一个基类,animal,然后是animal的两个子类,landanimal 和 wateranimal.现在我们想要定义一个类来代表青蛙.青蛙是两栖动物,所以我们自然会想到定义frog类从landanimal和wateranimal类继承.这使得frog类能够同时从landanimal 和wateranimal类继承所需的行为和属性.
　　
　　初看起来这是相当简单的;但是,让我们为animal添加一个叫做livingenvironment的属性,并用方法getlivingenvironment来返回它.我们假设landanimal 和 wateranimal类都重载了这个方法来实现特殊的功能.landanimal将返回land作为它的livingenvironment属性的值,而wateranimal将返回water作为它的livingenvironment属性的值.现在,当我们将frog类作为landanimal 和 wateranimal 子类实现的时候,想要得到frog的livingenvironment属性值,这时将遇到一个麻烦:frog类的getlivingenvironment方法是返回land值呢还是water值?答案取决于编译器如何处理多重继承.
　　
　　我在前面的文章里就已经说过,java不支持多重继承.但它确实允许一个对象通过使用叫做"接口"的功能拥有多个特性.下面的例子显示了定义landanimal的接口的可能的定义代码:
　　public interface landanimal
　　{
　　　　public int getnumberoflegs();
　　　　public boolean hasatail();
　　}
　　
　　一个使用接口的类在类定义语句的开始添加implements+接口名.例如,在java中,我们会以下面的方式定义frog类:
　　
　　public class frog extends animal implements landanimal, wateranimal
　　
　　接口并没有什么实际的功能;相反,它的作用是联系使用者和实现了这个接口的对象.接口保证了对象实现接口定义的方法.而且,一个实现接口的对象能够在运行时被强制转换成接口类型.例如,使用上面的frog定义,并且假设landanimal类定义了一个叫做getnumberoflegs的方法而wateranimal定义了一个叫做hasgills的方法,那么一个frog类的实例可以在运行时被强制转换成landanimal或wateranimal对象:
　　
　　frog afrog = new frog();
　　int legcount = ((landanimal)afrog).getnumberoflegs();
　　boolean gillflag = ((wateranimal)afrog).hasgills();
　　
　　注意forg为什么能够被强制转换成一个landanimal对象即使实际的landanimal对象并没有被创建.这使得我们能够在运行时以其带有的任何"身份"调用一个对象,这就是所谓的"动态绑定"或"运行时绑定".
　　
　　深入多态性
　　java使用动态绑定来使多态成为可能,它指的是java用来在运行时选择调用的方法或对象的机制.重载构成了了java中的一种特殊的多态机制,它表现在当一个类的两个或者两个以上的方法拥有相同的名字但是不同的参数列表,或者说"方法签名".一个方法的签名指的是方法的名字以及参数的类型和数目.类的每一个方法都有与之相关的唯一的签名.类可以有多个名字相同的方法只要它们的参数列表是唯一的.例如,我们能够为animal类定义两个名字为gethello的方法,用其中一个方法来获得动物通常的叫声,而用另一个获得当动物被惊吓或是抚摩的时候的叫声.我们将给每一个方法唯一的签名:
　　
　　public string gethello();
　　public string gethello(int mood);
　　
　　现在,让我们修改例子程序来将我们讨论的一些概念付诸实践:
　　　
　　public class helloworld
　　{
　　public static void main(string[] args)
　　{
　　dog animal1 = new dog();
　　cat animal2 = new cat();
　　duck animal3 = new duck();
　　
　　system.out.println("a dog says " +animal1.gethello()
　　+", when scared says: " +animal1.gethello(animal.scared)
　　+", is carnivorous: " +animal1.iscarnivorous()
　　+", is a mammal: " +animal1.isamammal());
　　system.out.println("a cat says " +animal2.gethello()
　　+", when comforted says: " +animal2.gethello(animal.comforted)
　　+", is carnivorous: " +animal2.iscarnivorous()
　　+", is a mammal: " +animal2.isamammal());
　　system.out.println("a duck says " +animal3.gethello()
　　+", when scared says: " +animal3.gethello(animal.scared)
　　+", is carnivorous: " +animal3.iscarnivorous()
　　+", is a mammal: " +animal3.isamammal());
　　}
　　}
　　
　　abstract class animal
　　{
　　public static final int scared = 1;
　　public static final int comforted = 2;
　　
　　public boolean isamammal()
　　{
　　return(true);
　　}
　　
　　public boolean iscarnivorous()
　　{
　　return(true);
　　}
　　
　　abstract public string gethello();
　　abstract public string gethello(int mood);
　　}
　　
　　interface landanimal
　　{
　　public int getnumberoflegs();
　　public boolean hasatail();
　　}
　　
　　interface wateranimal
　　{
　　public boolean hasgills();
　　public boolean layseggs();
　　}
　　
　　class dog extends animal implements landanimal
　　{
　　// 重载父类的方法
　　public string gethello()
　　{
　　return("bark");
　　}
　　
　　public string gethello(int mood)
　　{
　　switch (mood) {
　　case scared:
　　return("growl");
　　case comforted:
　　return("");
　　}
　　
　　return("bark");
　　}
　　
　　// landanimal 接口的实现
　　public int getnumberoflegs()
　　{
　　return(4);
　　}
　　
　　public boolean hasatail()
　　{
　　return(true);
　　}
　　}
　　
　　class cat extends animal implements landanimal
　　{
　　// 重载父类的方法
　　public string gethello()
　　{
　　return("meow");
　　}
　　
　　public string gethello(int mood)
　　{
　　switch (mood) {
　　case scared:
　　return("hiss");
　　case comforted:
　　return("purr");
　　}
　　
　　return("meow");
　　}
　　
　　// landanimal 接口实现
　　public int getnumberoflegs()
　　{
　　return(4);
　　}
　　
　　public boolean hasatail()
　　{
　　return(true);
　　}
　　}
　　
　　class duck extends animal implements landanimal, wateranimal
　　{
　　// 重载父类的方法
　　public string gethello()
　　{
　　return("quack");
　　}
　　
　　public string gethello(int mood)
　　{
　　switch (mood) {
　　case scared:
　　return("quack, quack, quack");
　　case comforted:
　　return("");
　　}
　　
　　return("quack");
　　}
　　
　　public boolean isamammal()
　　{
　　return(false);
　　}
　　
　　public boolean iscarnivorous()
　　{
　　return(false);
　　}
　　
　　// wateranimal 接口实现
　　public boolean hasgills()
　　{
　　return(false);
　　}
　　
　　public boolean layseggs()
　　{
　　return(true);
　　}
　　
　　// landanimal 接口实现
　　public int getnumberoflegs()
　　{
　　return(2);
　　}
　　
　　public boolean hasatail()
　　{
　　return(false);
　　}
　　}
　　
　　程序执行后输出的结果如下:
　　
　　a dog says bark, when scared says: growl, is carnivorous: true, is a mammal: true
　　a cat says meow, when comforted says: purr, is carnivorous: true, is a mammal: true
　　a duck says quack, when scared says: quack, quack, quack, is carnivorous: false, is a mammal: false
　　
　　总结
　　综合继承,多态和接口的概念提供了一组强大的编程工具,允许我们重用代码,隔离错误的发生,并获得动态/运行时绑定带来的好处.在下一篇文章里,我们将讨论如何使用java的变量作用域/可见域规则来控制方法和属性的暴露问题.