JavaScript面向对象

 

JavaScript面向对象（oop）  --  Object Oritented Programming

声明对象：

1. 字面式声明
2. New
3. 构造函数声明
4. 工厂方法声明
5. 原型模式声明
6. 混合模式声明

声明完对象，看下如何遍历对象中的属性和方法，继承等方面内容

1. 遍历属性和方法
2. 封装，原型，原型链
3. 继承：原型继承，构造函数继承，call(),apply()
4. 对象冒充

面向对象

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

基于原型的面向对象

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

JavaScript面向对象的名词解释

属性：事物的特性

方法：事物的功能

对象：事物的一个实例

原型：JavaScript函数中由prototype属性引用了一个对象，即原型对象

所有的函数都有一个prototype属性。

每个函数prototype属性都是一个对象。

人和汽车：

属性：  人 -- 名字、身高、年龄   汽车 -- 长、宽、高、颜色

方法：  人 -- 学习、玩耍、唱歌   汽车 -- 拉人、载货

对象：事物的一个实例   --- 众多人中一个人

function f(){
}
alert(f.prototype);//[object Object]
//f.prototype 指向一个内存地址，内存地址里存储了一个对象

//检测对象
alert(f.prototype instanceof Object);//true

//构造函数
var obj = new Function(var1,var2,functionBody());
//var1,var2 正常变量    functionBody()自定义函数体
//注意：1、正常函数变量在自定义函数体中顺序不能改变，必须先var1，后var2
//      2、效率低

var obj = new Function("a","b","return a+b");
var s = obj(2,5);
alert(s);

注意如下：

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

 

闭包

闭包是一个拥有很多变量和绑定了这些变量的环境的表达式（通常就是一个函数）

变量作用域：

1. 全局作用域
2. 函数作用域（局部作用域）

3. function a(){
       var i= 0; 
       function b(){
         alert(++i);
       }
       return b;
   }
   var c = a();cb
   c();//1 --  c就是b函数的闭包函数 
   //特点：函数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：应用某一个对象的一个方法，以另一个对象替换当前对象

结果都弹出8

 

JavaScript多继承方式如下，拓展了解：

 

JavaScript面向对象的关键词

关键词：

instanceof  delete  call  apply   arguments  callee  this

所有对象本质上都是继承于Object

delete可以删除函数对象里的属性和方法

delete不能删除 变量、原型链上的属性和方法

arguments.callee输出函数本身

此时的this相当于全局变量，可以当作不存在

此时的this就是test

对象冒充

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