JS-面向对象

<script type="text/javascript">
    //什么是面向对象：对象是一个整体，对外提供一些操作
    //使用对象时，只关注对象提供的功能，但是不关注它的内部细节
    //比如一个收音机，只知道如何使用，不需要知道他是如何实现功能的
    //面向对象的特点：封装、继承、抽象
    //抽象：抓住核心的问题
    //封装：不考虑内部实现，只需要会使用
    //继承：继承已有对象的属性和方法
    //多态：父类和子类有一些相同的操作，但是操作又不完全相同
    //变量和属性的差别：变量是自由自在的，而属性属于一个对象
    var a = 12;//变量
    var arr = [12,23]
    arr.a = 5//属性

    var arr1 = [1,2,3]
    //this指的是执行时的对象，而不是创建时的对象
    arr1.show = {console.log(this)}

    var obj = {}
    obj.name = 'lana'
    obj.showName = function(){
        console.log(this.name)
    }

    // 工厂方式 | 构造函数：构造一个对象
    // 缺点:不能使用new的方法创建实例；每一个实例都有自己一套对象，很浪费资源
    // 1.原料；2.加工；3.出厂销售；
    function Person(name1,sex1){
        // 创建一个对象
        var obj = new Object()
        // 对象添加方法和属性
        obj.name1 = name
        obj.sex1 = sex
        obj.showName1 = function(){
            console.log(this.name1)
        }
        // 返回对象
        return obj
    }
    var p1 = Person('blue','女')

    //当添加了new之后，那么内部就会创建一个对象，this指的就反复是这个对线
    //解决每次创建实例后，都会有一套自己的对象，浪费资源的问题，可以用原型，不会出现副本
    var arr1 = [1,2,3,4]
    //在数组实例上添加一个方法只能在当前实例上使用，类比于css就相当于行内样式
    arr1.sum = function(){
        var result = 0
        var i = 0 
        for(var i = 0;i<this.length){
            result += this[i]
        }
        return result;
    }

    //为了让每个对象实例都可以访问到方法，就出现了prototype(原型)，类比于css中的class
    //给一类元素添方法
    //原型的重要应用：扩展系统对象
    Array.prototype.sum = function(){

    }
    //类:模型，不能在其基础上添加实际功能，在js中，类就是构造函数
    //对象（实例）：成品，具有实际的功能，被类构造出来的；
    String.prototype.trim = function(){
        return this.replace(/^\s+|\s+$/,'')
    }

    function Person(name,sex){
        // 属性，每个对象都各不相同
        this.name = name
        this.sex = sex
    }
    //添加原型属性
    //方法是每个对象都一样的
    Person.prototype.showName = function(){
            console.log(this.name)
        }
    var p2 = new Person('lilana','女')

    //如果将面向过程改写为面向对象:
    //1.onload方法中写创建对象实例
    //2.将变量改写为为属性
    //3.将函数改写为方法
    //注意this:定时器调用this：凡是被定时器调用的函数，this指向的是window；事件；
    
</script>

继承

<script type="text/javascript">
    window.onload = function(){
        // JSON通常用在命名空间里的
        var p1 = {
            name:'lina',
            sex:'male',
            showName:function(){
                alert(this.name)
            },
            showSex:function(){
                alert(this.sex)
            }
        }
        // 命名空间
        var obj = {}
        obj.common = {
            getByClass:function(){

            }
        }
        obj.fx = {
            drag:function(){

            }
        }

        //继承：可以使用父类的属性和方法
        function Person(name,sex){
            this.name = name
            this.sex = sex
        }
        Person.prototype.showName = function(){}
        Person.prototype.showSex = function(){}

        function Worker(name,sex,job){
            //调用了父级构造函数
            //call是改变this的指向
            //this-》new出来的构造函数
            Person.call(this,name,sex)
            this.job = job
        }
    
        //通过原型来继承父级的方法
        //原型链
        //将父类的原型的那个引用同时赋值给子类，那么子类指向的就是父类的那个地址，此时会出现引用
        Worker.prototype = Person.prototype
        //如果要解决这个办法，可以重新复制一份
        for(var i in Person.prototype){
            Worker.prototype[i] = Person.prototype[i]
        }
        Worker.prototype.showJob = function(){

        }
    }

</script>