面向对象的继承语法

1 Es6的继承语法(用的最多的)

基本构造语法:

    class father{

    constructor(变量1,变量2,变量3){

     this.变量名称1=变量1

     this.变量名称2=变量2

     this.变量名称3=变量

}

 函数1(){}

函数2(){}

}

class son extends father{

constructor(变量名称){

   super(变量1,变量2,变量3);

//可以设置自己的属性和属性值

}

//定义自己的函数

}

创建实例化对象并进行传参

class Father{
            constructor(name,age){
                this.name=name;
                this.age=age;
            }

            fun1(){console.log(this.name)}
        }
        class Son extends Father{
          
            constructor(name,age,addr,sex){
                super(name,age)
                this.addr=addr;
                this.sex=sex;
            }
            fun2(){console.log(this.sex)}
        }
       const sonObj=new Son('莹',18,'北京','女');
       console.log(sonObj);

 表示自己可以继承来自于父级的参数 避免代码的冗余

二 Es5的继承语法

      1 继承属性和属性值

         本质

             new关键词定义一个对象 并且return 返回这个对象 构造函数this指向 就是这个对象 也就是实例化对象 构造函数中 通过this指向 实例化对象   设定的属性和属性值 就设定给实例化对象

// 父类构造函数
        function Father( name , age ){
            // this 指向 new 关键词创建的实例化对象
            // 也就是通过 new 关键词 调用父类构造函数 创建的父类实例化对象
            this.name = name ; 
            this.age = age ;
        }
        Father.prototype.f1 = function(){};
        Father.prototype.f2 = function(){};


        // 子类构造函数
        function Son( name , age , sex,addr,phone ){
            // 调用 父类构造函数 通过 函数改变this指向
            // this指向应该修改为 子类实例化对象
            // 子类构造函数 和 new 一起调用 this指向就是子类实例化对象
            Father.call( this , name , age );

            // 定义子类构造函数 自己的属性属性值
            this.sex = sex ;
            this.addr = addr ;
            this.phone =  phone ;
        }

        // 创建子类实例化对象
        // 创建实例化对象时 输入所有需要的实参
        const objSon = new Son( '王五' , 100 , '男' , '北京' , 123456);




        console.log( objSon );

 

    2 继承函数

function Father(){}

        Father.prototype.f1 = function(){}

        Father.prototype.f2 = function(){}

        // 父类实例化对象

        const fatherObj = new Father();

        // 父类实例化对象 可以 访问 父类构造函数的prototype

        console.log( fatherObj );

        // 子类构造函数

        function Son(){}

        // 给 子类构造哈数 的 prototype 赋值 父类实例化对象 的 内存地址

        // prototype 本质是一个对象 有 内存地址

        // 现在 赋值修改 子类构造函数 prototype 的 内存地址

        // 修改为 父类实例化对象

        // 子类构造函数 prototype 访问调用的 就是 父类实例化对象

        // prototype 本身又是一个对象 也有 __proto__

        // 子类构造函数 prototype 就是 父类实例化对象

        // 子类构造函数 prototype 的 __proto__ 就是 父类实例化对象的 __proto__

        // 也就是 子类构造函数 prototype 指向 父类实例化对象的 prototype

        Son.prototype = fatherObj;

       

        // 子类构造函数的prototype

        Son.prototype.ff1 = function(){}

        Son.prototype.ff2 = function(){}

 

        // 子类实例化对象

        // 子类实例化对象 只能 访问 子类构造函数的 prototype

        const objSon = new Son();

        console.log( objSon );