面向对象总结

//基本的面向对象程序
function Aaa(){
this.name = '小明';
}
Aaa.prototype.showName = function(){
alert( this.name );
};
var a1 = new Aaa();
a1.showName();




//在JS源码 : 系统对象也是基于原型的程序
function Array(){
this.lenglth = 0;
}
Array.prototype.push = function(){};
Array.prototype.sort = function(){};



//尽量不要去修改或者添加系统对象下面的方法和属性
var arr = [1,2,3];
Array.prototype.push = function(){
//this : 1,2,3
//arguments : 4,5,6
for(var i=0;i<arguments.length;i++){
this[this.length] = arguments[i]
}
return this.length;
};




//包装对象 : 基本类型都有自己对应的包装对象 : String  Number  Boolean
String.prototype.charAt = function(){};
str.charAt(0);  基本类型会找到对应的包装对象类型，然后包装对象把所有的属性和方法给了基本类型，然后包装对象消失


var str = 'hello';
str.number = 10;基本类型找到了包装对象,定义了属性,但是包装对象随后消失
alert( str.number );  undefined  这会找到的包装对象是新的对象




//原型链 : 实例对象与原型之间的连接，叫做原型链
原型链的最外层 : Object.prototype

a1      _proto_         Aaa.prototype     _proto_       Object.prototype

function Aaa(){
this.num = 20;
}
Aaa.prototype.num = 10;
Object.prototype.num = 30;

var a1 = new Aaa();




//hasOwnProperty : 看是不是对象自身下面的属性,这个方法挂在Object.prototype.hasOwnProperty 下面
var arr = [];
arr.num = 10;自身
Array.prototype.num2 = 20;原型

alert(  arr.hasOwnProperty('num')  );  //true
alert(  arr.hasOwnProperty('num2')  );  //false




//constructor : 查看对象的构造函数
function Aaa(){

}
var a1 = new Aaa();
alert( a1.constructor );  //Aaa

var arr = [];
alert( arr.constructor == Array );  //true


function Aaa(){
}
每一个函数创建的时候自动生成constructor挂在原型下面
Aaa.prototype.constructor = Aaa; 


function Aaa(){
}
Aaa.prototype.name = '小明';
Aaa.prototype.age = 20;
//这种误操作，因为对象的引用，重新赋值，导致新的{}的constructor=Object
Aaa.prototype = {
name : '小明',
age : 20
};
//正确的写法
Aaa.prototype = {
constructor:Aaa,
name : '小明',
age : 20
};




//instanceof : 实例对象与构造函数在原型链上是否有关系  
实例对象a1      构造函数Aaa    构造函数Object
function Aaa(){
}
var a1 = new Aaa();
alert( a1 instanceof Aaa );  //true
alert( a1 instanceof Object );  //true




//toString() 把对象转成字符串
系统对象下面都是自带的  系统对象 Array  
arr.toString==Array.prototype.toString
arr.toString == Object.prototype.toString //false
自己写的对象都是通过原型链找object下面的
var a1 = new Aaa();
a1.toString == Object.prototype.toString //ture


[1,2,3].toString()  //'1,2,3'*/

数字的16进制转换
var num = 255;
alert( num.toString(16) );  //'ff' 


//跨frame类型判断错误  constructor instanceof
var ifArray = window.frames[0].Array;
var arr = new ifArray();

alert( arr.constructor == Array );  //false
alert( arr instanceof Array );  //false
alert( Object.prototype.toString.call(arr) == '[object Array]' );  //true  


类型判断--判断数组的最好方法  
var arr = [];
Object.prototype.toString.call(arr) == '[object Array]' 




//继承 : 子类不影响父类，子类可以继承父类的一些功能 ( 代码复用 )
属性的继承 : 调用父类的构造函数 call
方法的继承 : for in :  拷贝继承 (jquery也是采用拷贝继承extend)

function CreatePerson(name,sex){   //父类
this.name = name;
this.sex = sex;
}
CreatePerson.prototype.showName = function(){
alert( this.name );
};

function CreateStar(name,sex,job){  //子类
//属性的继承 
CreatePerson.call(this,name,sex);
this.job = job;
}
//CreateStar.prototype = CreatePerson.prototype; 方法的继承
extend( CreateStar.prototype , CreatePerson.prototype );

function extend(obj1,obj2){
for(var attr in obj2){
obj1[attr] = obj2[attr];
}
}




//类 : JS是没有类的概念的 , 把JS中的构造函数看做的类----类式继承

function Aaa(){   //父类
this.name = [1,2,3];
}
Aaa.prototype.showName = function(){
alert( this.name );
};

function Bbb(){   //子类
}

//直接实例化构造函数赋给子类的构造函数的原型；
Bbb.prototype=new Aaa();
问题1
子类的构造函数是父类需要修改一下:  Bbb.prototype.constructor=Bbb;
问题2
子类实例对象操作属性name, 会影响到下一次子类实例对象的属性值 name;

正确办法: 属性和方法分开继承


属性继承:  在子类构造函数里面执行父类构造函数,并且修改this 指向
function Bbb(name){   //子类
Aaa.call(this,name)
}
方法继承: 采用中间对象 中转
var mid=function(){};
mid.prototype=Aaa.prototype;
Bbb.prototype=new mid();



//原型继承
var a = {
name : '小明'
};

function cloneObj(obj){
var F = function(){};
F.prototype = obj;
return new F();
}
var b = cloneObj(a);
b.name = '小强';

拷贝继承:  通用型的  有new或无new的时候都可以
类式继承:  new构造函数
原型继承:  无new的对象