美文网首页让前端飞程序员
01.JavaScript面向对象编程

01.JavaScript面向对象编程

作者: 胖先森 | 来源:发表于2017-03-29 21:57 被阅读0次

    JavaScript作为一门动态类型语言,它在编译(解释)时没有类型检查的过程,既没有检查创建创建的对象类型,有没有检查传递的参数类型。


    我的读书笔记,我想来记录一下自己认识的JavaScript的多态,多态是面向对象编程语言中最最重要的技术,个人理解多态就是把“做什么”和“谁去做”分离出来,归根结底就是消除类型之间的耦合关系。

    毕竟大部分人都不关心鸡是怎么叫,也不想知道鸭是怎么叫。

    多态的最根本的好处在于,你不必再向对象询问“你是什么类型”,而后根据得到的答案调用某个对象的行为--你只管调用该行为就是了,其他的一切多态机制都会为你安排妥当!

    将行为分布在各个对象中,并让这些对象各自负责自己的行为,这正是面向对象设计的特点

    1.多态

            /*
            * 编写一个地图的应用,我们可能需要调用百度地图,搜狗地图,谷歌地图等应用
            * 那么我们现在就来完成对多态的体现的代码应用
            * */
            var googleMap = {
                show:function () {
                    console.log("开始渲染谷歌地图");
                }
            }
            var baidudMap={
                show:function () {
                    console.log("开始选择百度地图");
                }
            }
    
            //建立渲染的方法
            var renderMap = function(map/*传递地图对象*/){
                //判断你调用的show的类型是否为函数?
                if(map.show instanceof Function){
                    map.show();
                }
            }
    
            //测试
            renderMap(googleMap);
            renderMap(baidudMap);
    

    翻译如下: 当我们想谷歌地图对象和百度地图对象分别发出“展示地图”的消息时候,分别调用他们的show方法,就会产生不同的执行结果。对象的多态性提示我们,“做什么”和“怎么做”是可以分开的,以后增加搜狗地图,renderMap函数仍然不需要做任何变化!

    2.封装

    在多数的对象语言中,封装数据是由语法解析实现的。例如我们学习的Java语言提供了private、public、protected等关键字来提供不同的访问权限

    但是,JavaScript中并没提供这些访问权限的关键字,我们只能依赖 变量的作用域来实现封装特性,而且只能模拟出public和private这两种封装性

            var hpObject = (function () {
                var __name="胖先森";//私有(private)变量
                return {
                    getName:function () {// 公开(public)方法
                        return __name;
                    }
                }
            })();
    
            console.log(hpObject.getName()); // 输出:胖先森
            console.log(hpObject.__name); // 输出:undefined
    
    
    

    目前通过函数创建作用域比较常见,如果你使用的ECMAScript 6 抱歉我没有研究,但是知道其提供了 let 关键字,定义私有变量

    上面仅仅是一个封装数据的示例,但是不要说封装等同于封装数据,这样就是井底之蛙!

    封装实现的目的:将信息隐藏,封装应该被视为“任何形式的封装”,也就是说,封装不仅仅是隐藏数据,还包括隐藏实现细节,设计细节以及隐藏对象的类型等。

    什么时候使用封装呢? 个人的理解为:找到变化并封装之,这里就涉及到设计模式(面试题:一共有多少设计模式呢?),还有如果工作一些年了,你应该知道重构代码的重要性!

    通过封装,我们要达到什么目的呢?就是把系统中 稳定不变的部分容易变化的部分 隔离

    3.继承

    主要说一下JavaScript的原型继承,这里自己也是刚刚入门,如果不太好的地方见谅!

    需要大家记住,原型编程的基本准则:

    • 所有数据都是对象 “万物皆对象”
    • 要得到一个对象,不是通过 实例化,而是找到一个对象作为原型并 克隆它
    • 对象会记住它的原型(你的父亲你不记得?)
    • 如果对象无法响应某个请求,它会把这个请求委托给它自己的原型。(例如,自己克隆自己)

    (1)所有数据都是对象

    JavaScript的数据类型机制: 基本类型和对象类型

    基本类型包括:

    • 特殊数据类型
      • undefined
      • null
    • 基本数据类型
      • string
      • boolean
      • number
    • 复杂数据类型
      • object
      • function (这个好像不算)

    ECMAScript 6 里面增加了一个数据类型 symbol

    JavaScript作者本意是除了undefined以外,一切都是对象!为了实现这个目标number、boolean、string这几种基本数据类型也是通过“包装类(学Java的时候有类似的概念)”的方式变成对象类型数据来处理。

    我们不能说JavaScript的多有数据都是对象,但是绝大部分都是对象。那么JavaScript中一定会有一个 根对象 存在

    事实上,JavaScript中的跟对象是 Object.prototype 对象。Object.prototype 对象是一个 空的对象,实际上都是从 Object.prototype 对象克隆而来的。

            var hp01 = new Object();//声明一个对象
            var hp02 = {};// 创建一个对象,推荐方式
    
            //利用 Object.getPrototypeOf方法检测原型
            console.log(Object.getPrototypeOf(hp01) === Object.prototype);// 输出:true
    
            console.log(Object.getPrototypeOf(hp02) === Object.prototype);// 输出:true
    

    (2)要得到一个对象,不是通过实例化类,而是找到一个对象作为原型并克隆它

    在JavaScript语言中,我们不需要关心克隆的细节,而是由引擎内部负责实现的。

    那么,我就有一个疑问:new 运算符不是实例化吗? 我们看一下下面的经典代码:

    
           function Person( name ){
               this.name = name;
           }
           Person.prototype.getName = function () {
               return this.name;
           }
    
           var a = new Person("胖先森");
           console.log(a.name);  // 输出:胖先森
           console.log(a.getName()); //输出:胖先森
    
           //检查对象
            console.log(Object.getPrototypeOf(a) === Person.prototype);// 输出:true
    

    在JavaScript中没有类的概念,这句话必须要时刻保持警惕!

    但是,刚才明明不是已经调用了 new Person() 吗?如果按照Java的理解,这不就是实例化对象吗?

    在这里Person不是类,而是 函数构造器,JavaScript的函数既可以作为 普通函数 被调用 ,也可以作为 构造函数 被调用。用 new 运算符来创建对象的过程,实际上是

    先克隆了 Object.prototype 对象 ,再进行一些其他额外的操作过程:

    JavaScript是通过克隆 Object.prototype 来得到新的对象,但是实际上不是每次都真正克隆一个新对象。

    从内存方面考虑出发,JavaScript还是做了一些额外的处理。

    (3)对象会记住它的原型

    记住:JavaScript给对象提供了隐藏属性 __proto__ ,某个对象的 __proto__ 属性会默认指向它的构造器的 原型对象 ,即 {Constructor}.prototype 。

          var hp = new Object();
          console.log(hp.__proto__ === Object.prototype);
    

    __proto__就是对象跟“对象构造器的原型” 联系起来的纽带。

    这个地方我理解的还是不够透彻,在后面的学习中,继续努力!

    (4)如果对象无法响应某个请求,它会把这个请求委托给它自己的原型

    JavaScript中每个对象都是从 Object.prototype 对象克隆而来。如果这样的话,就特别像我们之前学习的Java一样就成为了单一继承,即每个对象都继承了 Object.prototype , 显示这样的设计是受到了一定的限制。

    实际上,虽然JavaScript的对象最初都是由Object.prototype对象克隆而来,但是对象 构造器的言行并不是限于Object.prototype 上,而是可以 动态 指向其他对象。

    一段比较经典的继承写法:

         var root = {name:"胖先森"};
    
          var A = function () {
    
          }
          A.prototype = root;
    
          var a = new A();
          console.log(a.name);
    

    比较常用的方式

    说在后面的话:

    花了一天时间,整理出来一点笔记! 如果感觉好,请记得打赏一下!

    相关文章

      网友评论

        本文标题:01.JavaScript面向对象编程

        本文链接:https://www.haomeiwen.com/subject/cbiyottx.html