精华内容
下载资源
问答
  • javascript面向对象

    2012-05-11 01:26:32
    javascript面向对象
  • JavaScript面向对象

    2020-06-07 16:55:10
    JavaScript面向对象(oop) – Object Oritented Programming OOP即面向对象程序设计,全称为Object Oriented Programming,是一种计算机编程架构。 面向对象 对代码的一种抽象,对外提供统一调用接口的编程思想。 ...

    JavaScript面向对象(oop)

    – Object Oritented Programming
    OOP即面向对象程序设计,全称为Object Oriented Programming,是一种计算机编程架构。

    面向对象

    对代码的一种抽象,对外提供统一调用接口的编程思想。

    基于原型的面向对象

    基于原型的面相对象中,对象(object)则是依靠构造器(constructor)利用原型(prototype)构造出来的。

    JavaScript面向对象的名词解释

    属性:事物的特性
    方法:事物的功能
    对象:事物的一个实例
    原型:JavaScript函数中由prototype属性引用了一个对象,即原型对象
    所有的函数都有一个prototype属性。
    人和汽车:
    属性: 人 – 名字、身高、年龄 汽车 – 长、宽、高、颜色

    方法: 人 – 学习、玩耍、唱歌 汽车 – 拉人、载货

    对象:事物的一个实例 — 众多人中一个人
    var obj = new Function(“a”,“b”,“return a+b”);
    var s = obj(2,5);
    alert(s);

    注意如下:

    1. 只要通过new Function() 的对象,都是函数对象
    2. 其余的都是普通对象

    JavaScript 闭包

    JavaScript 变量属于本地或全局作用域。
    全局变量能够通过闭包实现局部(私有)。
    function a(){
    var i= 0;
    function b(){
    alert(++i);
    }
    return b;
    }
    var c = a();
    c();//1 特点:函数b实在a内嵌套的,函数a需要返回函数b
    //用途:1、读取函数内部变量 2、让i变量得值保存在内存中

    function f1(){
    var n = 99;
    nAdd = function (){
    n=n+1;
    }
    function f2(){
    alert(n);
    }
    return f2;
    }
    var rs = f1();
    rs();//99
    nAdd();
    rs();//100 – rs就是f2函数的闭包函数

    闭包优缺点:

    优点:有利于封装,可以访问局部变量的
    缺点:内存占用浪费严重,内存泄漏 – 黑客攻击内存

    对象声明方式:

    js字面式对象声明
    var obj = {
    属性名:属性值
    方法名:funcrtion(){}
    };

    new操作符后跟Object构造函数

    var obj = new Object();
    obj.属性 = 属性值;
    obj.方法 = function(){}
    Object是所有对象的基类,根所有的JavaScript对象都是由object延伸的。

    JavaScript构造方法声明对象

    function test([参数列表]){
    this.属性 = 属性值;
    this.方法 = function(){
    方法的代码;
    }
    }
    var obj = new test(参数列表);

    JavaScript的工厂方式声明对象

    拓展 – 工厂模式
    function createObj(name,age){
    var obj = new Object();
    obj.属性 = 属性值;
    obj.方法 = function(){}
    return obj;
    }
    var box1 = createObj(“liski”,100);
    var box2 = createObj(“wanger”,200);

    JavaScript中原型模式声明对象

    function test(){}
    test.prototype.属性 = 属性值;
    test.prototype.方法 = function(){代码}
    var obj = new test();
    好处:让所有的实例化的对象都拥有它包含的属性及方法

    **JavaScript混合模式声明对象

    混合模式:构造模式+原型模式**
    function test(v1,v2,v3){
    this.v1 = v1;
    this.v2 = v2
    this.v3 = v3
    }
    test.prototypt.方法 = function(){代码}
    var obj = new test();

    遍历对象及存储

    //新建对象 – ren
    for(var i in ren){
    //对象有的是可以当做数组处理的
    alert(i);//弹出的是属性和方法名字
    alert(ren[i]);//弹出的是属性和方法的内容
    }

    对象在内存中的分布(存储)

    在这里插入图片描述

    封装

    封装:把对象内部的数据和操作细节进行隐藏; private – 接口一般为调用方法
    1、JavaScript中没有专门封装的关键词 可以使用闭包创建这种模式 – 函数内部声明的变量外部是无法访问的
    2、能否被访问 取决于:公有和私有内容区别 – 能否在对象外部被访问
    1、这种模式有点消耗内存,一直return 创建对象;
    2、其实封装的本意就是局部的属性隐藏起来;

    继承

    **继承:
    1、原型:是利用prototype添加属性和方法
    2、原型链:proto(对象的内置属性) – 用于指向创建他的函数对象的原型对象prototype
    在这里插入图片描述
    在这里插入图片描述

    构造继承

    1、在子类的内部构造父类的对象实现继承
    在这里插入图片描述

    call和apply的用法

    对象内置方法中的apply和call都会用于继承,区别在于传参方式不同;
    1、call:调用一个对象的一个方法,以另一个对象替换当前对象
    2、Apply:应用某一个对象的一个方法,以另一个对象替换当前对象
    在这里插入图片描述
    在这里插入图片描述

    JavaScript多继承方式如下,拓展了解:

    在这里插入图片描述
    JavaScript面向对象的关键词
    关键词:
    Instanceof delete call apply arguments callee this

    对象冒充

    将父类的属性和方法一起传给子类作为特权属性和特权方法

    在这里插入图片描述

    展开全文
  • javascript 面向对象

    2017-06-27 20:30:33
    javascript 面向对象理解对象 万物皆对象,对象就是包含一组变量和函数的集合。 在软件系统中,对象具有唯一的标识符,对象包括属性和方法,属性就是需要记忆的信息,方法就是对象能够提供的服务。在面向对象中,...

    javascript 面向对象

    理解对象

    • 万物皆对象,对象就是包含一组变量和函数的集合。
    • 在软件系统中,对象具有唯一的标识符,对象包括属性和方法,属性就是需要记忆的信息,方法就是对象能够提供的服务。在面向对象中,对象是某一个类的实例。

    基于object对象:

    var person = new Object();
    person.name = 'My Name';
    person.age = 18;
    person.getName = function(){
        return this.name;
    }

    JS 面向对象

    • 会使用对象的方法,不用关注内部细节
    • JavaScript是基于原型(prototype)的面向对象,对象则是依靠 构造器利用 原型(prototype)构造出来的。例如工厂造一辆车,一方面,工人必须参照一张工程图纸,设计规定这辆车应该如何制造。这里的工程图纸就好比是语言中的 类 (class),而车就是按照这个 类(class)制造出来的;另一方面,工人和机器 ( 相当于 构造器) 利用各种零部件如发动机,轮胎,方向盘 ( 相当于 prototype 的各个属性 ) 将汽车构造出来。

    在JavaScript中使用对象很简单,使用new操作符执行Obejct函数就可以构建一个最基本的对象

    var obj = new Object();
    • 我们称new 调用的函数为构造函数,构造函数和普通函数区别仅仅在于是否使用了new来调用,它们的返回值也会不同。
    • 所谓“构造函数”,就是专门用来生成“对象”的函数。它提供模板,作为对象的基本结构。一个构造函数,可以生成多个对象,这些对象都有相同的结构
    obj.name = 'Byron';
    obj.printName = function(){
        console.log(obj.name);
    };

    构造函数:

    function People(name){
        this.name = name;
    
        this.printName = function(){
            alert(name);
        };
    }
    • 这是一个函数,也是对象,我们称之为类
    var p1 = new People('张三');
    • p1是People类new出来的对象,我们称之为实例
    • 类就是搬砖的模具,实例就是根据模具印出来的砖块,一个模具可以印出(实例化)多个实例,每个实例都符合类的特征

    JS面向对象的特点

    • 抽象
      抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节。比如,我们要设计一个学生成绩管理系统,考察学生这个对象时,我们只关心他的班级、学号、成绩等,而不用去关心他的身高、体重这些信息。抽象包括两个方面,一是过程抽象,二是数据抽象。

    • 封装
      所谓封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

    • 继承
      所谓继承是指可以让某个类型的对象获得另一个类型的对象的属性的方法。继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。

    • 多态
      所谓多态就是指一个类实例的相同方法在不同情形有不同表现形式。

    构造函数

    使用Object构造函数或对象字面量都可以创建对象,但缺点是创建多个对象时,会产生大量的重复代码,因此下面介绍可解决这个问题的创建对象的方法。

    工厂模式

    function createPerson(name, sex) {
        //原料
        var obj = new Object();
        //加工
        obj.name = name;
        obj.sex = sex;
        obj.getName = function () {
            alert(this.name);
        }
        //出厂
        return obj;//使用return返回生成的对象实例
    }
    var person = createPerson('Jack', '男');

    创建对象交给一个工厂方法来实现,可以传递参数,但主要缺点是无法识别对象类型,因为创建对象都是使用Object的原生构造函数来完成的。

    • 构造函数模式
    function Person(name,age){
        this.name = name;
        this.age = age;
        this.getName = function () {
            alert(this.name);
        }
    }
    var person1 = new Person('Jack', 19);
    
    var person2 = new Person('Liye', 23);

    使用自定义的构造函数(与普通函数一样,只是用它来创建对象),定义对象类型(如:Person)的属性和方法。它与工厂方法区别在于:

    • 没有显式地创建对象;
    • 直接将属性和方法赋值给this对象;
    • 没有return语句;

    此外,要创建Person的实例,必须使用new关键字,以Person函数为构造函数,传递参数完成对象创建;实际创建经过以下4个过程:

    1. 创建一个对象
    2. 将函数的作用域赋给新对象(因此this指向这个新对象,如:person1)
    3. 执行构造函数的代码
    4. 返回该对象

    虽然构造函数方式比较不错,但也存在缺点,那就是在创建对象时,特别针对对象的属性指向函数时,会重复的创建函数实例,以上述代码为基础,可以改写为:

    function Person(name,age){
        this.name = name;
        this.age = age;
        this.getName = new Function () {//改写后效果与原代码相同,不过是为了方便理解
            alert(this.name);
        }
    }

    上述代码,创建多个实例时,会重复调用new Function();创建多个函数实例,这些函数实例还不是一个作用域中,当然这一般不会有错,但这会造成内存浪费。

    • 原型模式

    JS每个函数都有一个prototype(原型)属性,这个属性是一个指针,指向一个对象,它是所有通过new操作符使用函数创建的实例的原型对象。原型对象最大特点是,所有对象实例共享它所包含的属性和方法,也就是说,所有在原型对象中创建的属性或方法都直接被所有对象实例共享。

    function Person(){
    }
    Person.prototype.name = 'Jack';//使用原型来添加属性
    Person.prototype.age = 29;
    Person.prototype.getName = function(){
        return this.name;
    }
    var person1 = new Person();
    alert(person1.getName());//Jack
    var person2 = new Person();
    alert(person1.getName === person2.getName);//true;共享一个原型对象的方法

    原型模式的缺点,它省略了为构造函数传递初始化参数,这在一定程序带来不便;另外,最主要是当对象的属性是引用类型时,它的值是不变的,总是引用同一个外部对象,所有实例对该对象的操作都会其它实例:

    • 组合构造函数及原型模式

    目前最为常用的定义类型方式,是组合构造函数模式与原型模式。构造函数模式用于定义实例的属性,而原型模式用于定义方法和共享的属性。结果,每个实例都会有自己的一份实例属性的副本,但同时又共享着对方方法的引用,最大限度的节约内存。此外,组合模式还支持向构造函数传递参数,可谓是集两家之所长。

    function CreatePerson(name, qq){//构造函数
        this.name=name;
        this.qq=qq;
    }
    CreatePerson.prototype.showName=function (){ //原型
        alert('我的名字叫:'+this.name);
    };
    CreatePerson.prototype.showQQ=function (){
        alert('我的QQ号:'+this.qq);
    };
    var obj1=new CreatePerson('blue', '258248832');
    var obj2=new CreatePerson('张三', '45648979879');
    alert(obj1.showName==obj2.showName);
    展开全文
  • JAVASCRIPT面向对象

    2016-12-31 15:03:20
    由于内容较多,就不得不分几个章节来讲述一下JAVASCRIPT面向对象 第一章:基础篇 第二章:创建对象 第三章:继承

    由于内容较多,就不得不分几个章节来讲述一下JAVASCRIPT面向对象
    第一章:基础篇
    第二章:创建对象
    第三章:继承

    展开全文
  • Javascript面向对象

    千次阅读 2016-09-14 10:32:11
    在简书上看到了关于Javascript面向对象的一些文章,突然也想写一点自己的见解。 按人们认识客观世界的系统思维方式,采用基于对象(实体)的概念建立模型,模拟客观世界分析、设计、实现软件的办法为什么要面相对象...

    简书上看到了关于Javascript面向对象的一些文章,突然也想写一点自己的见解。

    按人们认识客观世界的系统思维方式,采用基于对象(实体)的概念建立模型,模拟客观世界分析、设计、实现软件的办法

    • 为什么要面相对象?

    • 首先要了解什么是面向对象,面向对象有哪些特性。我在网上查到关于面相对象现在还没有统一的概念,如果没有统一的概念,我就先随便找个差不多的概念吧。如上,简单的说就是一切都是对象,什么是对象,对象就是对现实世界的抽象。

    • 面相对象有什么特性,我在百度百科上找到几个,然后展开来说。

      • 对象唯一性:对象是对现实世界的抽象,现实世界每样东西都是唯一的,所以对象也是唯一的。
      • 抽象性:对象是对现实世界的抽象,比如说我们抽象人的概念,每个人都有姓名,性别,年龄等等,但是每个人又有不通的性格,然后我们把他抽象了出来,这就是抽象性
      • 继承性:还是人的概念,我们抽象的东西为了实现能够多次的复用,我们一类具有相同属性的东西抽离出来,用于继承这样就能实现代码最大程度上的精简,并且富有逻辑,人类社会不就是这样的么,小明和小红的孩子身上会有小红和小明身上的一些特质,当然,他们的孩子身上也会有,一些小红和小明身上没有的特质。正式因为有这个特性,社会才会进步。
      • 多态性:还是用人来举例子,每个人都有不同的名字,我叫每个人,每个人都会回答给我不一样的名字,但是我用了同样的方法去提问,这就是多态性,相同的方法,在不通的对象上体现出来的结果也是不同的。
    • Javascript如何实现面向对象,要讲Javascript面向对象之前首先要讲一下下面这些神奇的东西。

      • this:对于Javascript来说,一切都是function,那么this的作用域就只是在function里面。这个其实很好理解,但是如果不实际操作那就不一定了,用代码说话。
      var name = "ben";//ben  
                  作用域是this.Window
                  function persion() {
                  alert(this.name);
                  //benalert(name);
                  //benthis.name = "jill";//ben 
                      function showAge() {
                          var age = 25; 
                          alert(this.name);//jill
                          alert(this.age);//undifine 作用域是 //
                          **this.window,age 的作用域在showAge这个方法中**
                      }
                      showAge();                      
                  }
                  alert(name);//ben 
                  alert(this.name);//ben
                  persion();
    • prototype:这个东西太他妈重要了,要是不知道的话,别逼我骂人。

      //首先说明原型
                  //这里先借用一个例子
                  //来自
                  //http://www.ruanyifeng.com/blog/2011/06/designing_ideas_of_inheritance_mechanism_in_javascript.html
      
                  function DOG(name){
                      this.name = name;
                      this.species = '犬科';
                  }
      
                  var dogA = new DOG('大毛');
                  var dogB = new DOG('二毛');
                   
                  dogA.species = '猫科';
                  alert(dogB.species); //示犬科",不受dogA的影响
      
                  //下面是原型     
      
      
                  function DOG(name){
                      this.name = name;
                  }
                  DOG.prototype = { species : '犬科' };
                  var dogB = new DOG('二毛');
                  alert(dogA.species); // 犬科
                  alert(dogpecies); // 犬科
      
                  //下面是借用原型的实现
      
                  function Persion(name,age){
                      this.myName = name;
                      this.myAge = age;
                  }
      
                  persion.prototype = {
                      showName:function(){
                          alert(this.myName);
                      },
                      showAge:function(){
                          alert(this.myAge);
                      }
      
                  }
      
                  //这样一个人就抽象好了
      
                  var jack = new Persion("jack",25);
                  var shell = new Persion("shell",25);
      
                  jack.showName(); //jack
                  shell.showName();//shell
    • constructor

                  //其实就是一只构造函数
                  function Persion(name,age){
                      this.myName = name;
                      this.myAge = age;
                  }
                   Persion.prototype.showName = function(){
                      alert(this.myName);
                   };
                  alert(Persion.constructor);
                  var jack = new Persion("jack",25);
                  alert(jack.constructor);
      
                  //但是constructor是会被覆盖的
                  function Persion2(name,age){
                      this.myName = name;
                      this.myAge = age;
                  }
                   Persion2.prototype ={
                      showName:function(){
                          alert(this.myName)
                      }
                   } 
                  alert(Persion2.constructor);
                  var rose = new Persion("rose",25);
                  alert(rose.constructor);
                  //所以如果要用,并不安全,但是我们也要把他给考虑进去
                  //毕竟面向对象的都有构造函数
                  //咱不能掉队
    • call/apply

                  //这个玩意儿相当的重要,重要到无法代替。
                  //例子还是要举起来
                  function Persion(name,age){
                      this.name = name;
                      this.age = age;
                  }
      
                  function Student(name,age,school){
                      Persion.call(this,name,age,school)
                      this.school = school;
                  }
      
                  Student.prototype = {
                      showName:function(){
                          alert(this.name);
                      },
                      showSchool:function(){
                          alert(this.school);
      
                      }
                  }
      
                  var jack = new Student("Jack","24","Jialidun");
                  jack.showName(); // Jack
                  jack.showSchool();//Jialidun
      
      
    • arguments

                  //这个玩意给我们提供了太多的方便,难以言喻。
                  function Persion(name,age){
                      this.name = name;
                      this.age = age;
                  }
                  Persion.prototype = {
                      setSkills:function(){
                          for(var item in arguments){
                               alert(arguments[item]);
                          }
                      }               
                  }
      
                  var jack = new Persion("Jack","24");
                  jack.setSkills("java","javascript","css","Node.js");
                  //这个例子充分表明了这个家伙是干什么用的。
    • 基本概念讲完了,下面讲几个我见到过在项目里面做继承的几个示范:

      • 第一个示范

                /**
                * 实现继承类
                * @private _object
                * */
                function _object (o) {
                     function F() {
                     };
                    F.prototype = o;
                    return new F();
                }
        
        
                /**
                *
                * 实现继承
                * @method inherit
                * @private
                * @param {Object} subType 子类
                * @param {Object} superType 超类
                * */
                function inherit (subType, superType) {
                    var p = _object(superType.prototype);
                    p.constructor = subType;
                    subType.prototype = p;
                }
        
                function Persion(name,age){
                    this.name = name;
                    this.age = age;
                }
        
                Persion.prototype = {
                    showName:function(){
                        alert(this.name);
                    },
                    showAge:function(){
                        alert(this.age);
                    }
                }
        
                function Student(name,age,school){
                    Persion.call(this,name,age);
                    this.school = school;
                } 
        
                inherit(Student,Persion);
        
                Student.prototype.showSchool =  function(){
                        alert(this.school);
                }
        
                var jack = new Student("Jack",25,"jialidun");           
                jack.showName();
                jack.showSchool();
      • 第二个示范

                function Persion(name,age){
                    this.name = name;
                    this.age = age;
                }
        
                Persion.prototype = {
                    showName:function(){
                        alert(this.name);
                    },
                    showAge:function(){
                        alert(this.age);
                    }
                }
        
                function Student(name,age,school){
                    Persion.call(this,name,age);
                    this.school = school;
                } 
        
                Student.prototype = new Persion(); //这块累赘了
                //你知道如果这块不这样,像下面那样
                //Student.prototype 和 Persion.prototype 就将是绑定死的
                //意思就是如果你改变Student.prototype中的东西
                //Persion.prototype也会变,很危险
                //孩子怎么能影响父亲呢,大逆不道不是
                //Student.prototype = Persion.prototype
        
                Student.prototype.showSchool =  function(){
                        alert(this.school);
                }
        
                var jack = new Student("Jack",25,"jialidun");
                jack.showName();
                jack.showSchool();
      • 第三个示范这个例子来自 Leaflet

              /*
               * L.Class powers the OOP facilities of the library.
               * Thanks to John Resig and Dean Edwards for inspiration!
               */
               L = {};
               L.Util ={
      
               extend: function (dest) {
                  var i, j, len, src;
      
                  for (j = 1, len = arguments.length; j < len; j++) {
                    src = arguments[j];
                    for (i in src) {
                      dest[i] = src[i];
                    }
                  }
                  return dest;
                },
                // create an object from a given prototype
                create: Object.create || (function () {
                  function F() {}
                    return function (proto) {
                      F.prototype = proto;
                      return new F();
                  };
                })()}
      
              L.Class = function () {};
      
              L.Class.extend = function (props) {
      
                // extended class with the new prototype
                var NewClass = function () {
      
                  // call the constructor
                  if (this.initialize) {
                    this.initialize.apply(this, arguments);
                  }
      
                  // call all constructor hooks
                  this.callInitHooks();
                };
      
                var parentProto = NewClass.__super__ = this.prototype;
      
                var proto = L.Util.create(parentProto);
                proto.constructor = NewClass;
      
                NewClass.prototype = proto;
      
                // inherit parent's statics
                for (var i in this) {
                  if (this.hasOwnProperty(i) && i !== 'prototype') {
                    NewClass[i] = this[i];
                  }
                }
      
                // mix static properties into the class
                if (props.statics) {
                  L.Util.extend(NewClass, props.statics);
                  delete props.statics;
                }
      
                // mix includes into the prototype
                if (props.includes) {
                  L.Util.extend.apply(null, [proto].concat(props.includes));
                  delete props.includes;
                }
      
                // merge options
                if (proto.options) {
                  props.options = L.Util.extend(L.Util.create(proto.options), props.options);
                }
      
                // mix given properties into the prototype
                L.Util.extend(proto, props);
      
                proto._initHooks = [];
      
                // add method for calling all hooks
                proto.callInitHooks = function () {
      
                  if (this._initHooksCalled) { return; }
      
                  if (parentProto.callInitHooks) {
                    parentProto.callInitHooks.call(this);
                  }
      
                  this._initHooksCalled = true;
      
                  for (var i = 0, len = proto._initHooks.length; i < len; i++) {
                    proto._initHooks[i].call(this);
                  }
                };
      
                return NewClass;
              };
      
      
              // method for adding properties to prototype
              L.Class.include = function (props) {
                L.Util.extend(this.prototype, props);
              };
      
              // merge new default options to the Class
              L.Class.mergeOptions = function (options) {
                L.Util.extend(this.prototype.options, options);
              };
      
              // add a constructor hook
              L.Class.addInitHook = function (fn) { // (Function) || (String, args...)
                var args = Array.prototype.slice.call(arguments, 1);
      
                var init = typeof fn === 'function' ? fn : function () {
                  this[fn].apply(this, args);
                };
      
                this.prototype._initHooks = this.prototype._initHooks || [];
                this.prototype._initHooks.push(init);
              };
      
              //现在开始使用了
              Persion = L.Class.extend({
                options:{
                  name:"",
                  sex:"",
                  age:""
                },
                initialize:function(options){
                  this.name = options.name;
                  this.sex = options.sex;
                  this.age = options.age;
                },
                showName:function(){
                  alert(this.name);
                }
              });
      
              Student = Persion.extend({
                 options:{
                  name:"",
                  sex:"",
                  age:"",
                  school:"",
                  score:""
                },
                initialize:function(options){
                  Persion.prototype.initialize.call(this, options);
                  this.school = options.school;
                  this.score = options.score;
                },
                showSchool:function(){
                  alert(this.school);
                }
              })
      
              var jack = new Student({
                  name:"jack",
                  sex:"man",
                  age:"25",
                  school:"Beijing University",
                  score:"A++"
              });
      
              jack.showSchool();
      
       这个继承有点长,但是很用,很有启发。简单写了一下用法,但是不全。
      

    name:Jack

    QQ:84201088

    wechart:music0627

    blog:http://gdyblog.com

    展开全文
  • JavaScript 面向对象

    2020-10-31 12:05:05
    1. 面向过程与面向对象 1.1 面向过程 面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候再一个一个依次调用就可以了。 1.2 面向对象 面向对象是把事务分解成为一个个对象,...
  • Javascript 面向对象

    2018-09-18 20:07:33
    面向对象介绍 什么是对象 Everything is object (万物皆对象) 对象到底是什么,我们可以从两次层次来理解。 (1) 对象是单个事物的抽象。 一本书、一辆汽车、一个人都可以是对象,一个数据库、一张网页、一个与...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,844
精华内容 9,937
关键字:

javascript面向对象

java 订阅