5、面向对象

/*① 字面量方式创建对象
         var obj = {};   //空对象
         var obj = {name:‘kitty‘,swim:function(){console.log(‘在游泳‘)}};
         给对象丰富成员:
         对象.成员名称 = 值;
         对象[成员名称] = 值;
         对象访问本身成员：
         对象.成员名称
         对象[成员名称]();
         */
        var ldh = {}
        var Imcong = {name: ‘cong‘, age: 40}

        Imcong.hoby = function () {
            console.log(‘breakbasst‘)
        }
        Imcong[‘addr‘] = "niang_ning";
        Imcong.hoby();
        console.log(Imcong[‘addr‘]);
        /*② 构造函数方式创建对象
         var obj = new 函数();
         在javascript里边，new后边的元素是“函数”(与php的类相似)
         在实例化对象的同时会自动使得“函数”发生执行，因此成为“构造函数”方式创建对象
         */
        function peple(){
            //this在方法里边代表调用该方法的当前对象
            this.name="show";
            this.age="year";
        }
        var hzd=new peple();
        hzd.zhiye="monkey";
        console.log(hzd);
        console.log(peple);

        /*③ Object方式创建对象

         //通过“字面量”方式创建的对象，对象构造器是"Object"
         构造器：用那个“函数/类”把对象给创建出来
         */
        var colths = {color:‘yellow‘};
        console.log(colths);//Object { color="yellow"}

        var bulia = new Object();//Object { eat="fish"}
        bulia.eat = "fish";
        console.log(bulia);


        /*③
        对象在内存中的分配
         */
        function Animal(){
            this.name = "kitty";
            this.age = 6;
            this.run = function(){
                console.log(‘在跑步‘);
            }
        }
        var cat = new Animal();
        var tiger = cat; //对象赋值-引用传递-给new Animal创建一个对象名称
        //cat和tiger共同指引同一个对象
        tiger.name = "东北虎";
        console.log(cat.name);//东北虎

        var wolf = new Animal();
        console.log(wolf.name)//kitty

        /*对象调用其他函数或方法
         解决：把其他函数增加一个别名赋予给调用对象即可
         */
        var dorg = {name:‘tom‘,climb:function(){console.log(this.name+"frighting")}};
        dorg.climb();//tom在爬树

        var birth = {name:‘鸟儿‘,hobby:‘skying‘};
        //使得dog对象调用cat的climb方法

        birth.pa = dorg.climb;//为climb的function增加一个别名为pa
        //这样climb和pa均可以调用同一个function执行
        birth.pa();//旺财在爬树

        /*call方式使得函数或方法执行
         call的好处：
         “无需声明新的成员”出来，就可以使得对象调用其他函数或方法
         这样会对变量污染的风险进行控制
         */
        var xiaoxuesheng={name:"xiao_hong",go:function(whatdo,who){console.log(this.name+"go to school"+whatdo+" "+who)}}
        var colege={name:‘shuai_guo‘}
          /*colege调用xiaoxuesheng的go方法*/
        xiaoxuesheng.go.call(colege);
        xiaoxuesheng.go.call(colege,‘看看书‘,‘和朋友‘);//方法名称.call(方法内部this的指引,参数1，参数2，.....参数n);
                                                      //..      .apply(方法内部this的指引,[参数1，参数2，.....参数n])
        /*call方式使得函数或方法执行
         */
        var think=‘mony‘;
        function thinking(){
            console.log(this.name+"想法是"+this.think)
        }
        var boy={name:‘xiaoming‘,think:‘love‘}
        thinking.call(boy)//函数.call(this指引，参数，参数。。。);
        /*获取构造器
         */
        console.log(boy.constructor);

        /*return的影响
         仍然实例化一个对象，不过return后边的代码不给执行
         */
        function Animal(){
            this.name = "kitty";
            this.age = 6;

            return 100;

            this.run = function(){
                console.log(‘在跑步‘);
            }
        }
        //Animal内部有return，cat接收的是对象还是返回信息100。
        var miulk = new Animal();
        console.log(miulk);//Animal { name="kitty", age=6}
        //miulk.run();报错