Java接口规范的理解

接口

接口是什么？看到查阅了网上大多数的文章，都说“接口是一种行为规范”，这句话初学者理解起来不容易，我也是仔细查阅了一些资料后，略微了解。

百度上规范的定义：约定或规定的标准。

以下是我个人理解，如有错误，请指教，大牛勿喷，谢谢！

要想理解“接口是一种行为规范”这句话，还是得先从代码入手。

假如这里有一个飞机类Plane，飞机类有起飞up，降落down，飞行fly的功能，客机类Aircraft、喷气战斗机类Fighter、直升机类Helicopter继承了飞机类，都具有它的功能属性；还有一个飞行员类Pilot负责控制飞机的操作。

飞机类及其子类：

//飞机类-----------------------
class Plane {
    String name;

    public Plane(String name) {
        this.name = name;
    }

    //起飞
    void up(){
        System.out.println(this.name+"正在起飞.....");
    }

    //落地
    void down(){
        System.out.println(this.name+"正在落地......");

    }

    //飞行
    void fly(){
        System.out.println(this.name+"正在飞行");
    }
}

//客机-----------------------
class Aircraft extends Plane{

    public Aircraft(String name) {
        super(name);
    }
}

//喷气战斗机---------------------
class Fighter extends Plane{

    public Fighter(String name) {
        super(name);
    }
}

//直升飞机
class Helicopter extends Plane{

    public Helicopter(String name) {
        super(name);
    }
}

飞行员类：

class Pilot{
    void controlUp(Plane plane){
        plane.up();
    }

    void controlDown(Plane plane){
        plane.down();
    }

    void controlFly(Plane plane){
        plane.fly();
    }


}

测试类：

public class Demo01 {
    public static void main(String[] args) {

        Pilot pilot = new Pilot();//飞行员对象
        Aircraft aircraft = new Aircraft("客机10001");//客机对象
        Fighter fighter = new Fighter("战斗机70001");//喷气战斗对象
        Helicopter helico = new Helicopter("直升机90001");//直升机对象

        //飞行员操控客机
        pilot.controlUp(aircraft);
        pilot.controlFly(aircraft);
        pilot.controlDown(aircraft);


        System.out.println();

        //飞行员操控喷气战斗机
        pilot.controlUp(fighter);
        pilot.controlFly(fighter);
        pilot.controlDown(fighter);

        System.out.println();

        //飞行员操控直升机
        pilot.controlUp(helico);
        pilot.controlFly(helico);
        pilot.controlDown(helico);


    }
}

输出为：

显然，他们都继承了Plane类，所以在飞行员调用操作飞机的方法时，方法的参数为Plane类，因为多态特性，父引用指向不同子对象，就出现如上结果。

这时我们给飞机员Plilot类加上一个操控 飞机战斗 的功能：

class Pilot{
    void controlUp(Plane plane){
        plane.up();
    }

    void controlDown(Plane plane){
        plane.down();
    }

    void controlFly(Plane plane){
        plane.fly();
    }

    //操作飞机攻击
    void controlFight(Plane plane){

    }

}

然后我们发现要想飞机能够战斗必须给飞机类Plane添加一个发射导弹 fire()
方法才能让飞行员操控，但是仔细一想如果给Plane 类 fire()方法，喷气战斗机类Fighter 和 直升机类Helicopter 确实能够发射导弹，那么 客机类Aircraft 也能发射导弹（一般来说客机是没有战斗系统的）,这不符合逻辑，并且这个方法还占用了客机类的资源。

那么如果只给 喷气战斗机类 和 直升机类 增加 fire() 方法呢？，那么 飞行员操作攻击的方法 就得改为如下：

    //操作喷气战斗机攻击
    void controlFight(Aircraft aircraft){

    }
    //操作直升机攻击
    void controlFight(Helicopter helico){

    }

此时，就有了飞行员就有了两个操作飞机战斗的方法，有人会说：挺好实现了方法的重载。如果我后面又加了一个轰炸机类，这类飞机也可以 发起攻击，那我又要对飞行员类增加一个操作轰炸机战斗的方法，增加了代码量。

这里我们创建一个接口：

//战斗接口（战斗组件）
interface  Battle{
    void fire();
}

然后让 喷气战斗机类 和 直升机类 实现这个 战斗接口：

//喷气战斗机
class Fighter extends Plane implements Battle{

    public Fighter(String name) {
        super(name);
    }

    @Override
    public void fire() {
            System.out.println(this.name+"发射多枚导弹.....");
    }
}

//直升飞机
class Helicopter extends Plane implements Battle {

    public Helicopter(String name) {
        super(name);
    }

    @Override
    public void fire() {
             System.out.println(this.name+"机关枪连续射击......");
    }
}

最后改变飞行员操作飞机攻击的方法：

    //操作飞机攻击
    void controlFight(Battle battle){
        battle.fire();
    }

输出:

从结果可以看到，喷气战斗机 和 直升机都可以发起攻击了，而且飞行员操作飞机攻击的方法也简化了，形参是接口 Battle, 也符合多态的概念，减少了代码量，逻辑也清晰。

总结：
只有实现了战斗接口Battle的飞机才能使用战斗方法，如果强行将客机丢给飞行员的操作攻击的方法，则会出现编译报错。

这就是接口的规范，一种行为标准，某些方法以接口作为形参时，就是表明实参必须符合（实现）这个标准,否则编译报错,起到了规范代码的作用。

并且接口可以扩展类的功能而不出现代码的冗余，假如以后客机也能战斗，也可以实现这个战斗接口。

可以看到接口与多态息息相关，倒不如说接口就是为多态服务。