1. OOP基础


1.1面向对象编程OOP

1、语言的分类:
     ① 面向机器:汇编语言
     ② 面向过程:C语言
     ③ 面向对象:C++ Java PHP 等
 
2、面向过程与面向对象
     ① 面向过程:专注于如何去解决一个问题的过程步骤。编程特点是由一个个的函数去实
                            现每一步的过程步骤,没有类和对象的概念。
     ② 面向对象:专注于由哪一个对象来解决这个问题。编程特点是出现了一个个的类,从
                           类中拿到对象,由这个对象去解决具体问题。
 
对于调用者来说,面向过程需要调用者自己去实现各种函数;而面向对象,只需要告诉调用者对象中具体方法的功能,而不需要调用者了解方法中的实现细节。
 
[面向对象的三大特征]
继承、封装、多态
JS可以模拟实现继承和封装,但是无法模拟实现多态,所以说JS是一门基于对象的语言,而并非是面向对象的语言!
 

1.2类和对象

1、类:一类具有相同特征(属性)和行为(方法)的集合。
  eg:人类-->属性:身高、体重、性别 方法:吃饭、睡觉、说话
 
2、对象:从类中,拿出具有确定属性值和方法的个体。
  eg:张三-->属性:身高180 体重160 方法:说话-->我叫张三
 
3、类和对象的关系:
  类是抽象的,对象是具体的(类是对象的抽象化,对象是类的具体化)
 
类是一个抽象的概念,只能说类有属性和方法,但是不能给属性赋具体的值。
eg:人类有姓名,但是不能说人类的姓名是什么
 
对象是一个具体的个例,是将类中的属性进行具体赋值而来的个体
eg:张三是人类的一个个体,可以说张三的姓名是张三,也就是张三对人类的每一个属性进行了赋值,那么张三就是由人类产生的一个对象。
 
4、使用类和对象的步骤:
    ① 创建一个类(构造函数):类名必须使用大驼峰法则,即每个单词首字母都要大写。
        function Person(name,age){
            this.name=name;
            this.age=age;
            this.say=function(content){
                // 在类中,访问类自身的属性,必须使用this.属性 调用
                alert("我叫"+this.name+",今年"+this.age+"岁。我说了一句话:"+content);
            }
        }        
 
 ② 通过类,实例化(new)出一个对象。
var zhangsan = new Person("张三",18);
    var obj = new 类名(属性1的具体值);
    obj.属性; 调用属性
    obj.方法; 调用方法
 
  ③ 注意事项:
      >>> 通过类名,new出一个对象的过程,叫做"类的实例化"
      >>> 类中的this,会在实例化的时候,指向新new出的对象;
    所以,this.属性 this.方法 实际上是将属性和方法绑定在即将new出的对象上面
    >>> 在类中,要调用自身属性,必须使用this.属性名。如果直接使用变量名,则无法访问对应属性。
      >>> 类名必须使用大驼峰法则,注意与普通函数区分。
 
5、两个重要属性:
    ① constructor:返回当前对象的构造函数。
        >>> lisi.constructor==Person; √
    ② instanceof:检测一个对象,是不是一个类的实例
        >>> lisi instanceof Person √ lisi是通过Person类new出的
        >>> lisi instanceof Object √ 所有对象都是Object的实例
        >>> Person instanceof Object √ 函数本身也是对象
 
6、广义对象与狭义对象:
    ① 狭义对象:只有属性和方法,除此之外没有任何其他内容。
                           var obj = {} var obj = new Object();
    ② 广义对象:除了用字面量声明的基本数据类型之外,JS中万物皆对象。换句话说,只要能够添加属性和方法的变量,都可以成为对象。
var s="123"; // 不是对象
s.name="aaa";
console.log(typeof s); // String
console.log(s.name); // Undefined 字面量声明的字符串不是对象,不能添加属性。

 

2. 成员属性、静态属性和私有属性

 

2.1成员属性与成员方法

在构造函数中,使用this.属性 声明,或者在实例化出对象以后,使用"对象.属性"追加的,都属于成员属性或成员方法,
也叫实例属性和实例方法。
 
成员属性/方法,是属于由类new出的对象的。
需要使用"对象名.属性名"调用
        var zhangsan = new Person("张三");
        zhangsan.age = 14; // 追加成员属性
        console.log(zhangsan.age); // 调用成员属性

 

2.2静态属性与静态方法

1、通过"类名.属性"、"类名.方法"声明的属性和方法,称为静态属性、静态方法,也叫类属性和类方法。
 
   类属性/类方法,是属于类的(属于构造函数的)
   通过"类名.属性名"调用
 
2、成员属性是属于实例化出的对象的,只能使用对象调用。
   静态属性是属于构造函数的,只能使用类名调用。
        Person.count = "60亿"; // 声明静态属性
        console.log(Person.count); // 调用静态属性
        var lisi = new Person("李四");
        console.log(lisi.count); // Undefined 静态属性是属于类的,只能用类名调用

 

2.3私有属性与私有方法

在构造函数中,使用var声明的变量,称为私有属性;
在构造函数中,使用function声明的函数,称为私有方法;
             function Person(){
                  var num = 1; // 私有属性
                  function func(){}; // 私有方法
             }

私有属性和私有方法的作用域,只在构造函数内部有效。即,只能在构造函数内部使用,无论使用对象名还是类名都无法调用。

 

3. JS模拟实现封装
 
1、 什么叫封装?
    ① 方法的封装:将类内部的函数进行私有化处理,不对外提供调用接口,无法在类外部使用的方法称为私有方法,即方法的封装。
 
    ② 属性的封装:将类中的属性进行私有化处理,对外不能直接使用对象名访问(私有属性)。同时,需要提供专门用于设置和读取私有
                              属性的set/get方法,让外部使用我们 提供的方法,对属性进行操作。这就叫属性的封装。
 
2、 注意:封装不是拒绝访问,而是限制访问。要求调用者,必须使用我们提供的set/get方法进行属性的操作,而不是直接拒绝操作。
                  因此,单纯的属性私有化,不能成为封装!必须私有化之后,提供对应的set/get方法
function Person(){
   var age=0;
   this.setAge=function(ages){
      age=ages;
   }
   this.getAge=function(){
      return age;
   }
}

 

4. JS中的this指向详解


4.1谁最终调用函数,this就指向谁

4.1.1  this指向谁,不应该考虑函数在哪声明,而应该考虑函数在哪调用!!!
4.1.2  this指向的,永远只可能是对象,而不可能是函数!!!
4.1.3  this指向的对象,叫做函数的上下文/context,也叫函数的调用者
 

4.2this指向的规律!!!(与函数的调用方式息息相关)

4.2.1  通过函数名()调用的,this永远指向window  
 func();
 
4.2.2  通过对象.方法调用的,this指向这个对象
obj.func(); // 狭义对象
document.getElementById("div1").onclick = func; // 广义对象
 
4.2.3  函数作为数组中的一个元素,用数组下标调用的,this指向这个数组
var arr = [1,2,3,func,4,5,6];
arr[3]();
 
4.2.4  函数作为window内置函数的回调函数使用,this指向window。setInterval setTimeout 等
setTimeout(func,1000);
 
4.2.5  函数作为构造函数,使用new关键字调用,this指向新new出的对象。
var obj1 = new func();

 

5. 原型与原型链

 

5.1__proto__与prototype

5.1.1   prototype:函数的原型对象
     ① 只有函数才有prototype,而且所有函数必有prototype。
     ② prototype本身也是一个对象!
     ③ prototype指向了当前函数所在的引用地址!
 
5.1.2   __proto__:对象的原型!
     ① 只有对象才有__proto__,而且所有对象必有__proto__。
     ② __proto__也是一个对象,所以也有自己的__proto__,顺着这条线向上找的顺序,就是原型链。
     ③ 函数、数组都是对象,都有自己的__proto__
 
5.1.3   实例化一个类,拿到对象的原理?
      实例化一个类,实际上是将新对象的__proto__,指向构造函数所在的prototype。
      也就是说:zhangsan.__proto__==Person.prototype √
 
5.1.4   所有对象的__proto__沿原型链向上查找,都将指向Object的prototype。
      Object的prototype的__proto__,指向null
 

5.2原型链的指向问题

研究原型链的指向,就是要研究各种特殊对象的__proto__指向问题。
5.2.1   通过构造函数,new出的对象,新对象的__proto__指向构造函数的prototype
5.2.2   函数的__proto__,指向Function()的prototype
5.3.3   函数的prototype的__proto__指向Object的prototype
           (直接使用{}字面声明,或使用new Object拿到的对象的__proto__直接指向Object的prototype)
5.2.4   Object的prototype的__proto__指向null
           (Object作为一个函数,它的__proto__指向Function()的prototype)
 

 

 

6. 原型属性与原型方法
6.1   成员属性与成员方法:
   this.name = ""; this.func = function(){}
   >>> 属于实例化出的新对象,使用 对象.属性 调用
 
6.2   静态属性与静态方法:
   Person.name = ""; Person.func = function(){}
   >>> 属于类的,用 类名.属性 调用
 
6.3   私有属性与私有方法:
   构造函数中,使用var声明属性,使用function声明方法;
   >>> 只在类内部能够使用,外部无法使用任何方式调用。
 
6.4   原型属性与原型方法:
   Person.prototype.name = "";
   Person.prototype.func= function(){};
   >>> 将属性或方法写到类的prototype上,在实例化的时候,这些属性和方法就会进入
      到新对象的 __proto__上,就可以使用对象名调用
 
也就是说,1/4适用对象名访问,2使用类名访问,3只能在函数内部使用。
 
6.5   当访问对象的属性或方法时,会优先使用对象自身上的成员属性和成员方法。如果没
   有找到,则使用 __proto__上面的原型属性和原型方法。如果依然没有继续沿原型链
   查找,最后返回Undefined。
 
6.6   习惯上,我们会将属性写为成员属性,讲方法定义为原型方法:
    例如:
function Person(){
    this.name = "张三"; // 成员属性
}
Person.prototype.say = function(){};
   原因:
   ① 原型属性在定义后不能改变,无法在实例化时进行赋值。所以属性不能使用原型
        属性。但是方法,写完以后基本不用改变,所以,方法可以使用原型方法。
   ② 实例化出对象后,属性全在对象上,方法全在原型上,结构清晰。
   ③ 使用for-in遍历对象时,会将属性和方法全部打印出来。而方法往往并不需要展
        示,那么将方法写在原型上,就可以使用hasOwnProperty将原型方法过滤掉。
   ④ 将方法写道prototype上,将更节省内存
   ⑤ 官方都这么写
 
6.7   通过prototype扩展系统内置函数的原型方法
/**
* 给数组添加一个遍历打印所有值的方法
*/
Array.prototype.eachAll = function(){
    for (var i=0;i<this.length;i++) {
        console.log(this[i]);
    }
}
var arr = [1,2,3,4,5,6,7];
arr.eachAll();    

 

7. for-in循环
for-in 循环主要用于遍历对象
for()中的格式:for(keys in zhangsan){}
 
keys表示obj对象的每一个键值对的键!所以循环中,需要使用obj[keys]来取到每一个的值
 
for-in循环,遍历时不只能读取对象自身上面的成员属性,也能沿原型链遍历出对象的原型属性。
所以,可以使用hasOwnProperty判断一个属性是不是对象自身上的属性。
zhangsan.hasOwnProperty(keys)==true 表示这个属性是对象的成员属性,而不是原型属性。
        function Person(){
            this.name = "张三";
            this.age = 14;
            this.func1 = function(){
} } Person.prototype.name1
= "zhangsan"; Person.prototype.age1 = 15; Person.prototype.func2 = function(){}; var zhangsan = new Person(); for(keys in zhangsan) { if (zhangsan.hasOwnProperty(keys)) { console.log(zhangsan[keys]); } }

 

8. 继承

 

8.1扩展Object实现继承

8.1.1   扩展Object实现继承
      ① 声明父类
   function Parent(){}
          声明子类
   function Son(){}
 
   ② 通过prototype给Object类添加一个扩展方法:
    Object.prototype.extend = function(parent){
        for(var i in parent){
            this[i]=parent[i];
        }
    }
 
   ③ 分别拿到父类对象和子类对象:
   var p = new Parent();
   var s = new Son();

 

   ④ 用子类对象,调用扩展方法,实现继承操作:
   s.extend(p);

 

8.1.2   实现继承的原理:
   通过循环将父类对象的所有属性和方法,全部赋给子类对象。关键点在于for-in循环,
   即使不扩展Object,也能通过简单的循环实现操作。
 
8.1.3   扩展Object继承的缺点:
   ① 无法通过一次实例化,直接拿到完整的子类对象,而需要先拿到父类对象和子类对象两个对象,再手动合并。
   ② 扩展Object的继承方法,也会保留在子类的对象上。
 

8.2使用原型实现继承

8.2.1   使用原型实现继承
   ① 定义父类
   function Parent(){}
    定义子类
   function Son(){}
 
   ② 将父类对象,赋值给子类的prototype
   Son.prototype = new Parent();

 

   ③ 拿到子类对象,就会将父类对象的所有属性和方法,添加到__proto__
   var s = new Son();

 

8.2.2   使用原型继承的原理:
   将父类对象,赋值给子类的prototype,那么父类对象的属性和方法就会出现在子类的
   prototype中,那么,实例化子类时,子类的prototype又会到子类对象的__proto__
   中,最 终,父类对象的属性和方法,会出现在子类对象的__proto__中。
 
8.2.3   这种继承的特点:
   ① 子类自身的所有属性,都是成员属性,父类继承过来的属性,都是原型属性
   ② 依然无法通过一步实例化拿到完整的子类对象。
 

8.3call/apply/bind实现继承

[call/bind/apply]
1、 三个函数的作用:通过函数名调用这三个函数,可以强行将函数中的this指定为某个对象
 
2、 三个函数的写法(区别):
  call写法:func.call(func的this指定的obj,func参数1,func参数2,...);
  apply写法:func.call(func的this指定的obj,[func参数1,func参数2,...]);
  bind写法:func.call(func的this指定的obj)(func参数1,func参数2,...);
 
3、 三个函数的唯一区别,在于接收func的参数列表的方式不同,除此之外,功能上没有任何差异!!!
 
[使用call/bind/apply实现继承]
1、 实现步骤:
  ① 定义父类
  function Parent(name){}

 

  ② 定义子类时,在子类中使用三个函数,调用父类,将父类函数中的this,指向位子类函数中的this:
    function Son(no,name){
        this.no = no;
        Parent.call(this,name);
    }

 

  ③ 实例化子类时,将自动继承父类属性
  var s = new Son(12,"张三");

 

9. 闭包
 
[JS中的作用域]
1、 全局变量:函数外声明的变量,成为全局变量;
  局部变量:函数内部使用var声明的变量,称为局部变量;
 
  在JS中,只有函数作用域,没有块级作用域!!也就是说,if/for等有{}结构体,
  并不能具备自己的作用域
 
  所以,函数外部不能访问函数内部的局部变量(私有属性)。因为,函数内部的变量,在
  函数执行完毕以后,就会被释放掉。
 
2、 使用闭包,可以访问函数的私有变量!
  JS中,提供了一种"闭包"的概念:在函数内部,定义一个子函数,子函数可以访问父
  函数的私有变量。可以在子函数中进行操作,最后将子函数通过return返回
       function func1(){
         var num = 1;
         function func2(){
            return num;
         }
         return func2;
      }
      var num = func1()();

 

3、 闭包的作用:
  ① 可以在函数外部访问函数的私有变量;
  ② 让函数内部的变量,可以始终存在于内存中,不会在函数完成后释放掉


posted on 2017-10-15 20:04  0&  阅读(521)  评论(1编辑  收藏  举报