JavaScript对象创建、原型链与继承机制详解

 
/* 
JavaScript中的对象本质上是属性（包括方法）的集合。
若变量名或方法名不符合标准的标识符声明规范，
则必须使用方括号“[]”来引用它。
* 
*/ 
/** 
<1.>该语句声明了一个class1类，class1相当于构造方法，又叫构造器
也可说声明了一个class1方法
*/ 
function class1(){
this.name="xjl"; //给对象添加属性
this.say= function(){alert("大家好！");}; //给对象添加方法
}; 
/** 
<2.>创建实例使用new关键字，new操作符不仅对内部类有效，对用户定义的类也是同样的用法
每个对象可以看作是多个属性（方法）的集合，即对象名.属性（方法）名或对象名[“属性（方法）名”]
方括号'[]'适合不确定具体要引用哪个属性（方法）的场合
*/ 
var a = new class1();
//alert(typeof(a)); //typeof(a)返回a的类型
//alert(a.name); //每个对象可以看作是多个属性（方法）的集合,
//alert(a['name']); //用方括号（[]）引用对象的属性和方法
//下拉框对象名[下拉框对象.value]即可获得用户所选的值也可用eval(“下拉框对象名.”+下拉框对象.value);
//a.say(); //调用对象的方法
//var arr=new Array();
//arr['push']('abc'); //为数组添加一个元素，其中的push为内置的属性
//arr['push']('1234'); //为数组添加一个元素
//alert(arr);
/** 
<二.>动态添加、修改、删除对象的属性和方法
* 
*/ 
var obj = new Object();
//添加属性……其中的属性名可任意取
obj.name="徐建龙";
obj.sex = '男';
obj['my name'] = "xujianlong"; //使用方括号“[]”可以使用非标识符字符串作为属性名称
//添加方法……方法名也可任意取,也可传参数
obj.alert = function(a){
alert(a+"你好！");
} 
//修改属性，就是把属性的值改成别的内容
obj.name = "张三";
obj['name'] = 'anme';
//删除属性，就是把属性的值改成undefined或null
obj.name = 'undefined';
/** 
<三>使用大括号（{}）语法创建无类型对象
*/ 
//在大括号中方属性和方法，属性与属性用逗号隔开,属性与值之间用冒号隔开
var ob = {
name:"123",
say:function(){alert("123")} //最后一个属性或方法不用逗号
} 
//也可用如下方法定义对象的属性和方法
var ob1 = {"name":'123','say':function(){alert("abcd");}};
/** 
Prototype原型链与对象成员<四>prototype原型对象
*所有的函数（function）对应的类是（Function）
*prototype实际上就是表示了一个类的成员的集合。
*当通过new来获取一个类的对象时，prototype对象的成员都会成为实例化对象的成员。
*/ 
function class2(){ //创建一个对象
} 
var ob2 = new class2();
class2.prototype.me = function(){alert("123");} //在prototype的前面是，你所创建的类名
class2.prototype.name = "123"; //
/** 
*函数对象和其他内部对象的关系
*/ 
//typeof(new Function()),typeof(Function),typeof(Array),typeof(Object)返回字符串“function”这些参数称之为构造器
//typeof(new Date())，typeof(new Array())，typeof(new Object())返回字符串“object”
/** 
*传递给函数的隐含参数：arguments，它具有数组的特点，但它不是数组，可用下标来访问它
*/ 
//arguments中包含了一个参数callee，它表示对函数对象本身的引用，如下：
var sum=function(n){
if(1==n)
return 1;
else
return n+arguments.callee(n-1);
} 
//该语句表示声明一个namespace1的命名空间,如下：
var namespace1 = new Object();
namespace1.class1 = function(){alert("123");};
var obj1=new namespace1.class1(); //页面加载时就执行
/** 
类成员的动态定义与静态属性*使用prototype对象定义类成员
*/ 
//在创建实例的语句之后使用函数的prototype属性给类定义新成员，只会对后面创建的对象有效
//在prototype中的constructor()方法，相当于构造方法
function class1(){
//alert('adf');
} 
//class1.prototype.constructor(); //页面加载时就执行
//用prototype定义的简化
class1.prototype={
//放入一些属性或方法
//多个属性或方法是用逗号（,）隔开
} 
//如下代码即是静态方法和属性
class1.name="abc";
class1.say = function(){/*codes*/}
//利用反射机制，可以改变element中指定的样式，而其他样式不会改变，得到了所要的结果，例如：
function setStyle(_style){
//得到要改变样式的界面对象
var element=getElement();
for(var p in _style){
element.style[p]=_style[p];
} 
} 
对象继承机制与实现对比//可以通过拷贝一个类的prototype到另外一个类来实现继承，但有缺陷。例如：
//function class4(){}
// 
//function class2(){
// 
// 
//class2.prototype=class4.prototype; //实现的继承
//class2.prototype.f = function(){alert("a");}
// 
//当对class2进行prototype的改变时，class4的prototype也随之改变
//instanceof操作符来判断一个对象是否是某个类的实例,例如：
var a = new class2();
a instanceof class2; //返回一个bool，如果a的class2中的继承类，则也是true
//一种更好的继承
for(var p in class1.prototype){
class2.prototype[p]=class1.prototype[p];
} 
class2.prototype.ma=function(){
alert(123);
} 
//当对class2进行prototype的改变时，class4的prototype不会改变
/** 
框架中的继承实现与抽象类*prototype-1.3.1框架中的类继承实现机制
*/ 
//------------------------------------------------------------------------------------------- 
//该语句为每个对象天加一个extend方法，代码如下;
Object.extend = function(destination, source) {
for (property in source) {
destination[property] = source[property]; //将source中所有的属性或方法都赋值给destination
} 
return destination;
} 
//通过Object类为每个对象添加方法extend
Object.prototype.extend = function(object) {
return Object.extend.apply(this, [this, object]);
} 
Object.extend.apply(this,[this,object]);
//class1继承与class2，好处是通过new class2（）相当于把class2的prototype的副本赋给class1
//在class1中的prototype的改变，不会影响class2中的prototyp
class1.prototype=(new class2()).extend({/*class1要增加的属性或方法*/});
/** 
*只做了一个声明而未实现的方法，具有虚函数的类就称之抽象类，抽象类是不能实例化的
*/ 
//里虚方法不需经过声明，而直接使用了。这些方法将在派生类中实现，例如：
function c1(){}
c2.prototype={
fun:function(){ this.fn();}//其中的fn方法未定义
} 
function c2(){}
c1.prototype=(new c2()).extend({
fn:function(){var x = 1;}
}); 
//this.initialize.apply(this, arguments);该语句是把创建对象时的参数传给initialize方法
/*** 
异常处理与错误捕获*在javascript中也可以用try-catch-finally语句用于捕获异常或错误信息
*其中在catch（e）的小括号中的e是必须的e是一个名为error的对象
*e=new Error(message)来创建这个对象，异常的描述被作为error对象的一个属性message，
*/ 
//该代码演示了异常的抛出
function s(a,b){
try{
if(b==0)
throw new Error("除数不能为零！........");
else
alert(a/b)
}catch(e){
document.write(e.message);///通过message获得Error中的实参
} 
} 
onlaod=s(1,0);