第1页：OOP: 继承以及多态第2页:OOP: 继承以及多态

深入多态性
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的变量作用域/可见域规则来控制方法和属性的暴露问题.