Java接口和多态

---

接口

利用接口，Java程序也可以实现类似于多重继承的网状层次结构。

接口使抽象的概念更深入一层。可将其想象为一个纯抽象类。它允许创建者规定一个类的基本形式：方法名、自变量列表以及返回类型，但不规定方法主题。接口也包含了数据成员，但它们都默认static和final。接口只提供一种形式，并不提供实施的细节。

接口的语法

使用关键字interface声明接口。Java接口中只声明类中方法的原型，而没有直接定义方法的内容。

声明格式：

[接口修饰符]interface接口名称[<Type {,Type>}][extends 父类名]{
   //方法的原型声明或静态常量
}

接口与一般类一样，本身也具有数据成员与方法，但数据成员一定要赋予初值，且此值将不能再更改，而方法必须是“抽象方法”。
抽象方法；
声明的语法格式；

public abstract <returnType><methodName>(...);

抽象方法体的具体实现是由当前类的不同子类在它们各自的声明类中完成的。也就是说，各子类在继承了父类的抽象方法之后，再分别重写它，形成若干个名字相同，返回值相同，参数列表也相同，但具体功能有一定差别的方法。

interface Shape2D{          //声明Shape2D接口
    final double pi=3.14;   //数据成员一定要初始化
    public abstract double area();//抽象方法，不需要定义处理方法
}

在接口的声明中，Java允许省略声明数据乘员的final关键字、方法的public及abstract关键字。

接口的实现

实现接口的语法：

[类修饰符] class 类名称 implements 接口名称{
   /*bodies for the interface methods*/
   /*own data and methods.*/
}

完成接口的类必须实现接口中的所有抽象方法，注意实现一个接口的时候，来自接口的方法必须声明成public。具体实现一个接口之后，就获得了一个普通的类，可用标准方式对其进行扩展。

class Circle implements Shape2D {
    double radius;

    public Circle(double r) {   //构造方法
        radius = r;
    }

    public double area() {
        return (pi * radius * radius);
    }
}

测试类声明如下；

public class InterfaceTester {
    public static void main(String args[]){
        Circle cir=new Circle(2.0);
        System.out.println("圆的面积： "+cir.area());
    }
}

输出结果：
圆的面积： 12.56

多重继承

一个类可以有多个接口，通过这种机制可以实现多重继承。

interface Shape2D{          //声明Shape2D接口
    final double pi=3.14;   //数据成员一定要初始化
    public abstract double area();//抽象方法，不需要定义处理方法
}
interface Color{
    void setColor(String str);
}
class Circle implements Shape2D,Color {
    double radius;
    String color;
    public Circle(double r) {   //构造方法
        radius = r;
    }
    public double area() {
        return (pi * radius * radius);
    }
    public void setColor(String str){
        color=str;
        System.out.println("color= "+color);
    }
}

public class MultiInterfaceTester {
    public static void main(String args[]){
        Circle cir;
        cir=new Circle(2.0);
        cir.setColor("blue");
        System.out.println("圆的面积： "+cir.area());
    }
}

输出结果：
color= blue
圆的面积： 12.56

多态

多态的概念其实不难理解，它是指针对不同类型的参数进行相同的操作，根据对象（或类）类型的不同而表现出不同的行为。比如在我们刚学的继承中，子类可以拿到父类的数据和方法，也可以重写父类的方法，还可以新增自己特定的方法。有了继承，就能实现多态，便可以为不同的数据类型的实现提供统一的接口。

多态的目的：

• 所有的对象都可被塑型为相同的类型，响应相同的消息；
• 使代码变得简单且容易理解；
• 使程序具有很好的“扩展性”。

二次分发举例

现在我们声明一个抽象类Driver 及两个子类Female Driver、MaleDriver。

public abstract class Driver {
    public Driver(){}
    public abstract void drivers(Vehicle v);
}

public class FemaleDriver extends Driver{
    public FemaleDriver(){}
    public void drivers(Vehicle v){
        v.drivedByFemaleDriver();
    }
}

public class MaleDriver extends Driver{
    public MaleDriver(){}
    public void drivers(Vehicle v){
        v.drivedByMaleDriver();
    }
}

public abstract class Vehicle {
    private String type;
    public Vehicle(){
    }
    public Vehicle(String s){
        type=s;
    }
    public abstract void drivedByFemaleDriver();
    public abstract void drivedByMaleDriver();
}

public class Bus extends Vehicle{
    public Bus(){
    }
    public void drivedByFemaleDriver(){
        System.out.println("a female driver drives a bus.");
    }
    public void drivedByMaleDriver(){
        System.out.println("a male driver drives a bus.");
    }
}

public class Car extends Vehicle{
    public Car(){
    }
    public void drivedByFemaleDriver(){
        System.out.println("a female driver drives a car.");
    }
    public void drivedByMaleDriver(){
        System.out.println("a male driver drives a car.");
    }
}

public class DriverTester {
    static public void main(String [] args){
        Driver a=new FemaleDriver();
        Driver b=new MaleDriver();
        Vehicle x=new Car();
        Vehicle y=new Bus();
        a.drivers(x);
        b.drivers(y);
    }
}

输出结果：
a female driver drives a car.
a male driver drives a bus.