面向对象编程

OOP：Object - Oriented - Programming
无序的属性继承——对象
把数据及数据的操作方法放在一起，作为一个相互依存的整体——对象
创建具有相同属性名的对象的函数——类
对同类对象，抽出其共性，形成类
类中的大多数数据只能用本类方法进行处理

特性

封装：
第一层含义：把对象的属性和行为看成一个比不可分的整体
第二层含义：信息隐藏，把不需要让外界知道的信息隐藏起来

继承：
子类继承父类的特征和行为，使得子类对象具有父类的实例域和方法

继承的好处：
a.提高代码复用
b.提高代码维护性
c.使得类和类之间产生联系

继承的方法
a.原生链继承
优点：继承所有
缺点：不能给父级传参
原生链继承写法：
1.创建父类
2.创建子类
3.子类.prototype=new 父类（）
4.实例化子类，得到对象

//创建父类
         function Fu(name,age){
            this.name=name
            this.age=age
        }
        Fu.prototype.say=function(){
            console.log("旺旺仙贝，洽洽瓜子，亲亲果冻");
        }
//创建子类        
        function Zi(){

        }
//子类.prototype=new 父类（）
        Zi.prototype=new Fu("liu",20)
        var s1=new Zi();
        console.log("s1",s1);
        console.log(s1.name,s1.age);
        s1.say()
//子类实例化
        var s2=new Zi()
        console.log("s2",s2);

b.类式继承 借用构造函数继承，改变this指向继承
优点：可以给父类传参
缺点：不能继承父类的原型对象
类式继承写法：
1.创建父类
2.创建子类
3.子类内部调用父类——改变父类的this指向
4.实例化子类，得到对象

//创建父类
       function Fu1(name,age){
            this.name=name
            this.age=age
        }
        Fu1.prototype.say=function(){}
//创建子类
        function Zi1(name,age){
            Fu1.call(this,name,age)//改变父类this指向
        }
        //子类实例化
        var obj1=new Zi1("liu",20)
        console.log(obj1);

c.组合继承
原型链继承+类式继承

//创建父类
        function Fu3(name,age){
           this.name=name
           this.age=age
        }
        Fu3.prototype.say=function(){

        }
//创建子类
        function Zi3(name,age){
            this.sex="nv"
            Fu3.call(this,name,age)//改变this指向
        }
        Zi3.prototype=new Fu3()//子类.prototype=new 父类（）
        Zi3.prototype.run=function(){

        }
        var obj3=new Zi3("zhao",20)//子类实例化
        console.log(obj3);

完美的继承方式，可以给父类传参，又可以全部继承