[技术学习]js接口继承

js是面向对象语言，但是js又缺乏了面向对象的诸多特性，比如继承，没有接口继承也没有父类继承，因此有时候需要人工来实现继承。

一、首先看下java中面向对象的继承：

//定义类鸟类的飞行动作
interface BirdFlyable {
    public void fly();
}
//鸟类
class Bird implements BirdFlyable{
    public void fly(){
        System.out.println("bird is flying");
    }
}
//蝙蝠同样可以飞行，不过没有继承鸟类的动作
class Bianfu{
    public void fly(){
        System.out.println("Bianfu is flying");
    }
}

public class Test{
    //定义fly方法，要求传入鸟类飞行方法
    public void fly(BirdFlyable flyable){
        flyable.fly()
    }
    public static void main(String[] args) {
        Bird bird=new Bird();
        fly(bird);//bird is flying
        //Bianfu bianfu=new Bianfu();
        //fly(bianfu) //执行蝙蝠方法，报错
    }
}

 

此处可以看到fly(bird)执行结果为bird is flying，如果Bird继承了BirdFlyable却没有实现fly方法，会在编译时候报错，相反，如果使用fly(bianfu),因为蝙蝠没有继承接口，同样也会报错，因此java中的接口继承为严格的继承。

二、python继承

#定义鸟类飞行方法
class BirdFlyable():
    def fly(self):
        pass
#定义鸟类
class Bird(BirdFlyable):
    def fly(self):
        print('bird is flying')

#定义蝙蝠
class Bianfu():
    def fly(self):
        print('Bianfu is flying')

#增加方法，希望传入鸟类飞行方法
def fly1(birdFlyable):
    birdFlyable.fly();

#事实证明，传入蝙蝠也是可以的
fly1(Bird())#bird is flying
fly1(Bianfu())#bird is flying
        

在python中因为方法中的参数没有明确规定类型，因此只要执行时候含有此方法，即可完成功能。

这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。

三、js中实现接口

目前js中实现接口有三种方法：

1、文档注释，即预先在文档注释中写好接口，规定接口中的方法，开发人员根据注释编写接口，此方法其实用处不大，无法强制开发人员继承接口。

2、属性检测法：在定义类的时候，规定类继承了哪几个接口，此方法只能检测接口名称，不能检测具体实现方法。

3、鸭式辩型法：与python中一样，来源与“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子的理论，重点关注类实现了哪些方法，而忽略继承了那个接口，从而判断类的继承，实现方法如下：

    //鸭式辩型法  实现javascript接口最完美的方法
    //核心方法是检测是否实现了接口的每一个方法
    //面向对象，代码实现统一，也解耦了

    //1、接口类
    /**
    *接口需要两个参数，1、名字，2、抽象方法名称数组
    */
    var Interface=function(name,methods){
        //如果参数大于一个，且第二个参数为数组，否则抛出异常
        if(arguments.length>=2&&(arguments[1] instanceof Array)){           
            this.name=name;
            this.methods=[];
            for(var index in methods){
                if(typeof methods[index]=='string'){
                    this.methods.push(methods[index]);
                }else{
                    throw new Error('方法名应该是字符串')
                }
            }
        }else{
            throw new Error("接口需要两个参数，1、名字，2、抽象方法名称数组");
        }
    }

    //定义两个接口，分别为增删改查
    var interface1=new Interface('interface1',['add','delete']);
    var interface2=new Interface('interface2',['modify','query']);

    /**
    *定义接口检验类，主要检验是否实现了接口中的所有方法
    *接口中传递参数为：1、需要检测的类，2、其他接口参数
    */
    Interface.checkInterface=function(object){
        if(arguments.length>=2){
            for(var i=1,len=arguments.length;i<len;i++){
                //获取需要检测的接口
                var interface=arguments[i];
                //获取接口中所含的所有方法
                for(var j=0,methods=interface.methods;j<methods.length;j++){
                    var method=methods[j];
                    if(!object[method]||(typeof object[method]!='function')){
                        throw new Error("方法"+method+"没有实现");
                    }

                }
            }
        }else{
            throw new Error('接口检验错误，参数至少两位')
        }
    }

    //定义From类
    //实现接口1和接口2中的方法
    function Form(){
        this.add=function(){
            alert('add');
        };
        this.delete=function(){
            alert('delete')
        };
        this.modify=function(){
            alert('modify')
        };
        this.query=function(){
            alert('query')
        }
    }
    //实例化类
    var form =new Form();
    //做借口检查
    Interface.checkInterface(form,interface1,interface2)
    form.add();