js基于对象

js基于对象

1. 为什么是基于对象，不是面向对象，因为面向对象有：封装，继承，多态。js只有封装
2. js函数没有重载。多个方法名相同，只执行最后一个函数，最后一个会覆盖前面的函数

• 什么是重载：函数名相同，参数不同（参数个数不同，参数 顺序不同 ，参数类型不同）

function test () {
            alert('test');
        }
        
        function test (x) {
            alert("x=" + x);
        }
        
        //JS中的函数没有重载的概念,如果定义多个同名函数,最后一个起作用,相当于最后一个把前面的都给覆盖掉了
        function test (x,y) {
            alert("x=" + x + ",y=" + y);
        }
        
        test(10);//结果x=10,y=undefined

3. js函数的形参是占位符，没有实际意义，如果不用形参，也可以用arguments[i]取出

function test() {
        alert(arguments[0]);
        alert(arguments[1]);
      }

      test(10,20);

5. js创建对象的三种方式：

• 自定义一个类（实质是函数），再创建对象（js的静态方法需要在类外面创建）
  //定义类(定义了一个类叫做Student、并且为这个类同时定义了一个构造函数Study)

 function Student(sno,name,age) {
        this.sno = sno;
        this.name = name;
        this.age = age;
        this.study = function() {
            alert('我是' + this.name + ",我在学习JS");
        }
    }

    //创建对象
    let stu = new Student(1,'LX',22);
    //调用方法
    stu.study();

• 使用Object创建即时对象

let student = new Object();
        student.sno = 1;
        student.name = 'LX';
        student.age = 22;
        student.study = function() {
            alert('我是' + this.name + ",我在学习JS");
        }

        student.study();//我是LX,我在学习JS
        
        delete student.name;

        student.study();//我是undefined,我在学习JS

• 使用json创建对象（json数组）

        //1.JSON定义对象
        let student = {
            sno: 1,
            name: 'LX',
            age: 22,
            study: function() {
                alert('我是' + this.name + ',我在学习JSON');
            },
        };
		let stu = new student();
		stu.study();
		
        //2.JSON数组
        let objArr = [{
            sno: 1,
            name: 'LX',
            age: 22,
            study: function() {
                alert('我是' + this.name + ',我在学习JSON');
            },
        },{
            sno: 2,
            name: 'LXX',
            age: 21,
            study: function() {
                alert('我是' + this.name + ',我在学习JSON');
            },
        },{
            sno: 3,
            name: 'LXXXX',
            age: 23,
            study: function() {
                alert('我是' + this.name + ',我在学习JSON');
            },
        }]
        
        for(let i=0;i<objArr.length;i++) {
            objArr[i].study();
        }

6. 减少全局变量的污染，两种方法

• 在不同的js文件中创建一个相同的变量，定义成唯一的属性，并导入

var myWeiXin = {};//
myWeiXin.table = "桌子A";

B.js
var myQQ = {};
myAppQQ.table = "表格B";

• 使用闭包（推荐使用）

//1.定义一个外部的函数,在外部函数中定义一个局部变量
        function outer() {
            let a = 10;

            //2.在外部函数中定义一个内部函数,内部函数中访问外部函数中的局部变量
            function inner() {
                alert("a=" + a++);
            }

            return inner;//3.返回内部函数的引用
        }

        let obj = outer();
        obj();//a=10
        obj();//a=11

        function outer2() {
            let a = 30;

            //2.在外部函数中定义一个内部函数,内部函数中访问外部函数中的局部变量
            function inner2() {
                alert("a=" + a++);
            }

            return inner2;//3.返回内部函数的引用
        }

        let obj2 = outer2();
        obj2();//a=30
        obj2();//a=31

• 闭包作用的概括：函数外可以访问函数内的局部变量
• 闭包的好处：
  (1)希望—个变量长期驻扎在内存当中(不被垃圾回收机制回收)
  (2)避免全局变量的污染
  (3私有成员的存在
  (4)安全性提高

7. 模拟继承，三种方式

• 使用call()

// 父类
        function Person(name,age) {
            this.name = name;
            this.age = age;
            this.eat = function() {
                alert('我是' + this.name + ",我在吃饭");
            }
        }

        function Student(sno,name,age) {
            //super(name,age)
            Person.call(this,name,age);
            this.sno = sno;
            this.study = function() {
                alert('我的学号是:' + this.sno + ',我在学习模拟继承');
            }
        }

        let stu = new Student(1,'LX',22);
        stu.eat();

• 使用apply(）

// 父类
        function Person(name,age) {
            this.name = name;
            this.age = age;
            this.eat = function() {
                alert('我是' + this.name + ",我在吃饭");
            }
        }

        function Student(sno,name,age) {
            //super(name,age)
            Person.apply(this,[name,age]);
            this.sno = sno;
            this.study = function() {
                alert('我的学号是:' + this.sno + ',我在学习模拟继承');
            }
        }

        let stu = new Student(1,'LX',22);
        stu.eat();

• 使用原生链继承 prototype

// 父类(函数对象)
        function Person(name,age) {
            this.name = name;
            this.age = age;
            this.eat = function() {
                alert('我是' + this.name + ",我在吃饭");
            }
        }

        function Student(sno,name,age) {
            Person.call(this,name,age);
            this.sno = sno;
            this.study = function() {
                alert('我的学号是:' + this.sno + ',我在学习模拟继承');
            }
        }

        //1. 创建一个父类的对象
        let person = new Person();
        //2. 修改 子类.prototype  获取类所对应的原型对象
        Student.prototype = person;

        //测试
        //为什么子类对象可以调用父类的eat();
        //当我们调用对象的方法或访问对象的属性时
        //1.第一步先从当前对象上有没有这个属性和方法 如果有就调用
        //2. 如果当前对象上没有该属性或方法 从对象的原型对象去寻找 因为我们把学生类的原型对象(protype)设置成了person
        // person中有eat() 所以就可以调用eat()方法了
        let stu = new Student(1,'LX',22);
        //console.log(stu.__proto__ == Student.prototype);
        //stu.eat();
       

       //大学生
       function UnivercityStudent() {

       }

       //大学生继承学生
       //1.创建父类对象
       let stu2 = new Student();
       //2.设置子类.prototype = 父类对象
       UnivercityStudent.prototype = stu2;

       //测试
       let uniStudent = new UnivercityStudent();
       //uniStudent.eat();

       //console.log(uniStudent);
       console.log(Person.prototype);