javascript面向对象编程的概念，应用（复杂）

一、面向对象编程的概念

面向对象的特点：

1、封装：将细节隐藏，不向外部暴露；
2、继承：子类对父类的继承；
3、多态：不同对象的同一方法会不相同，例如不同的职业对应不同的工作，工作就类似于封装的方法；

javascript面向对象概述：对代码的一种抽象，对外统一提供调用接口的编程思想

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

构造器 利用 原型 构造出 对象

javascript面向对象的名词解释：
属性：事物的特性；
方法：事物的功能；
对象：事物的一个实例；
原型：JS函数中由prototype属性引用了一个对象，即原型对象（原型）

构造函数对象：函数构造器 创建函数对象

var obj = new Function(var1,var2,…,functionBody());

函数构造器的语法：

new Function ([arg1[, arg2[, …argN]],] functionBody)

通过new Functino创建的就是函数对象

其他的都是普通对象

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

了解闭包的前提是作用域，作用域分为两种：1、全局变量；2、局部变量

javascript的特点，函数内部可以直接访问全局变量

闭包的优缺点

优点：有利于封装，可以访问局部变量

缺点：内存占用浪费严重，内存泄露

二、声明对象的方式(上)

1、字面式对象声明
var obj = {
属性名称：属性值，
属性名称：属性值，
属性名称：属性值，
…
方法名称：function(){},
方法名称：fucntion(){},
…
}
特殊
var person = {
paly:function(sportsl){
alert( “im playing” + sports );
}
}
person.play(“bascketball”)
控制台输出： im playing bascketball;

2、new 操作符后跟Object构造函数

var obj = new Object();
obj.属性 = 属性值；
obj.属性 = 属性值；
obj.方法 = function(str){
方法代码
};
Object是所有对象的基类、根，所有的javascript对象都是由Object延伸的；

3.js中构造方法声明对象

function test([参数列表arguments]){
this.属性= 属性值；
this.方法=function(){
方法中的代码
}
}

var obj = new test (参数列表）；

function person(name,sex,age){
this.name = name; //this.name属性
this.sex = sex;
this.age = age;
this.show = function(){
alert(this.name + “—” + this.sex + “—” + this.age);
}
}
//this 代表当前对象，obj1 and obj2 两者之间是独立的，函数内部只能用this访问属性和方法

声明对象的方式(中)

1、工厂方式声明对象（载入内存，准备调用）
function createObject(name,age){
var obj = new Object();
obj.name = name;
obj.age = age;
obj.run = function(){
return this.name + this.age + ‘running …’;
//在object对象中，调用object对象的属性，通过this关键词来进行
};
return obj;
//这里的obj将会返回到box1、box2中；
}
var box1 = createObject(‘zhangsan’,100);
//工厂模式，将调用赋值，调用完成后，return obj;
var box2 = createObject(‘lisi’,200);

声明对象的方式(下)

1、js中原型模式声明对象
function test(){
}
test.prototype.属性 = 属性值；
test.prototype.属性 = 属性值；
test.prototype.方法名称 = fu nction(){
执行代码
}
var obj = new test();
2、js中混合模式声明对象
构造 + 原型
function test(v1,v2,v3){
this.v1 = v1;
this.v2 = v2;
this.v3 = v3;
}
test.prototype.方法名称=function(){
执行代码
}
var obj = new test(v1,v2,v3);

三、对象遍历及存储

1、对象的遍历

遍历对象的属性

带有属性的对象
var ren = {};
ren.name = “zhangsan”;
ren.age = 18;
ren.demo = function(){
document.write(“aaaaa”);
}
对对象进行遍历
for(var i in ren){
alert(ren[i]);
}

2、对象的存储

数据段被分为三个部分分别为栈内存，堆内存，代码段；

栈内存只保留对象的地址

堆内存保留对象的属性和方法名

而方法的内容被保留到代码段中

四、封装

封装（Encapsulation): 把对象内部数据和操作细节进行隐藏

大多面向对象的语言都支持封装的特性，提供了private关键字来隐藏某些属性或方法，用来限制被封装的数据或者内容的访问，只对外提供一个对象的专门访问的接口；

接口一般来说是调用的方法

javascript中并没有提供封装的关键词，但是可以通过闭包来封装

封装后，函数内部声明的变量，外部是访问不到的，能不能访问就决定了公有内容和私有内容，公有内容便是都能够访

问的内容，而私有内容就是不能够被访问的内容

举例：

function demo(){
var n = 1;//局部变量，在方法外部不能直接访问
function test(){//这个方法能访问demo()的变量
n++;
}
test();
return n;
}
alert(n)//这个方法不能访问demo中的变量n;

五、继承

1、原型继承（我只能理解到通过prototype输入对象的属性，输入进原型对象，原型对象的属性可以被对象继承？）

原型和原型链

原型：是利用prototype添加属性和方法，js中所有的函数都有一个prototype属性，该属性引用了一个对象，即原型对象，也简称原型；

原型链：JS在创建对象（不论是普通对象还是函数对象）的时候，都有一个叫做_proto_的内置属性，用于指向创建它的函数对象的原型对象prototype，原型链的最终指向null；

讨论原型和原型链是为了引出JS中的继承概念；

2、构造继承

构造函数继承，在子类内部构造父类的对象实现继承；

构造函数是使用this关键词，定义相关的属性和方法；

例：

function parents(name){
this.name = name;
this.say = function(){
alert( “parents’name” + this.name );
}
}

function child(name,age){//继承parents
this.pObj = parents;//子对象的参数name传递到父对象中(用父对象创建子对象，从而调用父对象中属性以及方法)
this.pObj(name);
this.age = age;
this.sayC = function(){
alert(“child:”+this.name+"—"+“age:”+this.age);
}
}

var p = new parents(“zhangsan”);
p.say();
var c = new child(“李四”，20);
c.sayC();//在调用环节进行继承
//过程：李四 —》 this.pObj(name); —》 parents （name) —》this.name=name=“李四”
//this.sayC —>this.name—>parents—>this.name
//父对象，被子对象继承，所有的属性和方法，都将传递到子对象中

3、对象内置方法用于继承，apply and call都可以用来继承，区别在于传参方式的不同

call:调用一个对象的一个方法，以另一个对象替换当前对象；

apply:应用某一对象的一个方法，用另一个对象替换当前对象；

call —》 obj.call(方法，var1,var2,var3…)

apply —》 obj.apply(方法，[var1,var,var3]);

例：
function person(name,age,len){
this.name = name;
this.age = age;
this.len = len;
this.say = function say (){
alert(this.name + “:” + this.age + “:” + this.len);
}
}
//call继承
function student(name,age){
person.call(this,name,age);
}
//apply继承
function teacher(name,age,len){
person.apply(this,[name,age,len])
}
var person = new person("张三“，25，”170”);
per.say();
var stu = new student(“李四”，10)；
stu.say(); // 李四 18 undefined
var tea = new teacher(“wangwu”,20,“180”);
tea.say();

六、关键词

js 面向对象关键词

instanceof、delete、call、apply、arguments、callee、this

instanceof 变量是否是对象的实例

function test(){}
var obj = new test();
alert(obj instanceof Object)//关键字的使用位置

delete 删除属性
function fun(){
this.name = “zhansan”;
this.say = function(){
alert(this.name);
}
}
var obj = new fun();
alert(obj.name);
delete obj.name;//关键字的使用位置
alert(obj.name);

call、apply、arguments、callee方法不常用，略过；

七、对象冒充

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

function person(name,age){
this.name = name;
this.age = age;
function sayHi = function(){
alert(“hi”);
}
}
person.prototype.walk = function(){
alert(“walk …”);
}
function student(name,age,grade){
this.newMethod = person; //冒充person对象，传递特权属性和特权方法给子类
this.newMethod(name,age)；
this.grade = grade;
}