面向对象三大特征(封装,继承,多态)

面向对象的三大特征:
1.封装: 把功能封装到对象中,外部只需要调用,无需关心内部实现
2.继承: 一个对象拥有另一个对象的所有的成员
3.多态: 同一个对象在不同情况下的多种状态

1.封装*
代码封装可以避免代码冗余,避免去哪聚变量污染,本质就是把公共的代码抽离出来在需要的地方随时调用在继承中也有体现

2.多态
同一个对象在不同的情况下的多种状态

         function Animal(name){
             this.name = name;
         };
         var dog = new Animal('金毛');
         dog.eat = function(food){
             console.log('汪汪汪，我是' + this.name + '我吃了' + food);
         };
         var cat = new Animal('汤姆');
         cat.eat = function(food){
            console.log('喵喵喵，我是' + this.name + '我吃了' + food);
         };
         function Person(name){
             this.name = name;
         };
         var p1 = new Person('小明');
         //饲养员的职责是给动物喂食
         p1.work = function(animal,food){
             //animal形参 接收由Animal构造函数实例化的动误对象，然后调用这个对象的eat方法
            animal.eat(food);
         };
         p1.work(dog,'大骨头');
         p1.work(cat,'小干鱼');

3.继承
继承的本质就是一个对象拥有另一个对象的所有的成员

 var wangjianlin = {
            house:{
                address:'北京一环',
                price:100000000000
            },
            car:{
                pinpai:'劳斯莱斯',
                price:5000000
            }
        };


        var wangsicong = {
            girlFrineds:['豆得儿','雪梨','林更新','王建钢']
        };

        //需求：让wangsicong对象拥有wangjianlin所有得成员
        console.log(wangjianlin);
        console.log(wangsicong);

        //第一种方式：混入式
        //解决方案： 遍历wangjianlin(父对象)所有得成员，添加到wangsicong(子对象)中
        //弊端：每继承一次，就要执行一次forin循环

        // for(var key in wangjianlin){
        //     wangsicong[key] = wangjianlin[key];
        // };

        // console.log(wangsicong);


        //第二种方式：替换原型
        //解决方案：将父对象（wangjianlin）作为子对象构造函数（SonWang）得原型对象
        //弊端：丢失之前得原型对象

        // function SonWang(grs){
        //     this.girlFrineds = grs;
        // };

        // SonWang.prototype.flowerMoney = function(){
        //     console.log('我是wangjianlin得儿子，我很会花钱哄女孩子吃六块钱得麻辣烫');
        // };

        // //原型赋值（覆盖之前得原型对象）
        // // SonWang.prototype = wangjianlin;

        // var wangsicong = new SonWang(['豆得儿','雪梨','林更新','王建钢']);
        // console.log(wangsicong);
        // var smallMao = new SonWang(['范冰冰','赵薇','李沁','谭松韵']);
        // console.log(smallMao);

        //第三种方式： 混合式（混入+替换原型）  使用最多
        //解决方案： 将父对象（wangjianlin）对象所有得成员，添加到子对象构造函数（SonWang）得原型中
        //function SonWang(grs){
        //    this.girlFrineds = grs;
        //};

        //SonWang.prototype.flowerMoney = function(){
        //    console.log('我是wangjianlin得儿子，我很会花钱哄女孩子吃六块钱得麻辣烫');
        //};

        ////遍历wangjianlin对象所有得成员，添加到SonWang得原型中（没有覆盖原先的默认原型，只是动态添加属性）
       //function extend(method,father){
       //     for(var key in father){
       //         method.prototype[key] = father[key];
       //     };
       // };
       //  //混合式继承封装
       // extend(SonWang,wangjianlin);

       // var wangsicong = new SonWang(['豆得儿','雪梨','林更新','王建钢']);
       // console.log(wangsicong);
       // var smallMao = new SonWang(['苍老师','吉泽老师','波多老师','白石老师']);
       // console.log(smallMao);
       
       //第四种方式 : 借用构造函数继承：用的不多  修改this的指向
       //原因： 只能继承this.xxx 这种属性
       

        function Person(name,age){
            //this:new创建的空对象
            this.name = name;
            this.age = age;
        };
        var p1 = new Person('张三',18);
        console.log(p1);
        p1.girlFrend = '班花';


        function Student(name,age,score){
            //this:new创建的空对象
            console.log(this);    
            //调用Person的代码，但是将this改成Student函数中的this，借用了Person中的两行赋值代码对Student中的this赋值
            Person.call(this,name,age);
            // this.name = name;
            // this.age = age;
            this.score = score;
        };

        var s1 = new Student('李四',38,100);
        console.log(s1);