Javascript面向对象总结

继承
Ajax实战并没有实例，这里选取一些已经验证过的方法
1.在运行时给对象分配任意的属性：
function ClassA() {
this.color = ‘red’;
this.sayColor = function(){
alert(this.color);
}
}
function ClassC() {
this.newMethod = ClassA; //在运行时给对象分配任意的属性,
this.newMethod(); //如果ClassA的构造函数有参数，在这里传入
delete this.newMethod; //删除对ClassA的引用，避免以后被调用
}
function test(){//验证
var c=new ClassC();
c.completelyNewProperty=”something”;//在运行时给对象分配任意的属性,
alert(c.newMethod);
c.sayColor();
alert(c.completelyNewProperty); // alert(“something”);
}
2.使用Prototype链：
function ClassA() {}
ClassA.prototype.color = “red”;
ClassA.prototype.sayColor = function() {
alert(this.color);
}

function ClassB(){}
ClassB.prototype = new ClassA();
ClassB.prototype.name = “who”;
ClassB.prototype.sayName = function() {
alert(this.name);
}
function test(){
var b=new ClassB();
b.sayColor();
b.sayName();
}
3.使用call方法:
function ClassA(sColor) {
this.color =sColor;
this.Name =’name’;
this.sayColor = function() {
alert(this.color);
}
this.sayName = function() {
alert(this.Name);
}
}
function ClassB(sColor){
ClassA.call(this, sColor);
}
function test(){
var b=new ClassB(‘red’);
b.sayColor(); //alert(‘red’)
b.sayName(); //alert(‘name’);
}

javaScript对象的反射(了解对象拥有的属性或方法)
1.了解一个对象是否支持一个特定的属性或者方法：
if(MyObject.someProperty){…}//如果MyObject.someProperty的值为false、数字0或者null，无法进入if语句体
更加严格的测试应用这样写：
if(typeof(MyObject.someProperty)!=’undefined’){…}
如果关心属性的类型：
if(myobj instanceof Array){…}

2.查看一个对象的所有属性和函数：
var debug=’discovering…\n’;
for(var I in myobj){
debug+=i+’ ->’+myobj[i]+’\n’;
}
alert(debug);

接口和“鸭子类型”
我们经常说接口在不同的软件组件之间定义了一个契约。接口提供了好的概念分离，并且支撑了很多的设计模式。一个对象是否实现了一个接口，要看它是否实现了接口的方法(方法包括：方法名、参数和返回值)
1.是否有特定名称的函数：
function implements(){
this.implement=function(obj,funcName){
return obj && obj[funcName] && obj[funcName] instanceof Function;
}
}
2.是否遵守了一个完整的接口：
function isShape(obj){
var imp=new implements();
return imp.implement(obj,”getArea”)&& imp.implement(obj,”getPerimeter”);
}
3.参数和返回值类型是否一致(以是否为float类型为例子)：
function isNum(arg){
return parseFloat(arg)!=NaN;//NaN:为非数的简写
}

方法和函数
Javascript函数是自由浮动的实体，自身就可以作为正常对象(静态的Java方法位于这两者之间－它并没有捆绑在任何对象实例上，但是仍然捆绑在类的定义上)。在Javascript中Function是一个内建的对象类型。JavaScript函数的参数列表的长度不固定，且忽略任何额外的参数，并给缺少的参数赋值undefined。一个智能的函数可以通过arguments属性查询它自已的参数列表，并为缺少的值分配默认值、抛出一个异常或采取其他的补救措施。如：
function Dish(){
this.say=function(){
alert(arguments[0]);
}
}
Dish.prototype.description=function (){　//使用Dish.description会出错，因为Dish还不是对象
for( var i = 0; i < arguments.length; i++ ){
alert(arguments[i]);
}
}
function test(){
var dish=new Dish();
dish.say(‘s’);
dish.say(‘a’,’y’); //这个方法可以执行，可变参数
dish.description(‘descript’);
dish.description(‘value’,’value2’);//这个方法不可以执行，通过prototype捆绑的方法，执行带参方法后，此方法无效了
}
//getter或setter方法
function area(value){
if(value){this.area=value;}
return this.area;
}

向对象附加函数
定义函数：
function doSomething(x,y,z){…}
或：
var doSomething=function(x,y,x){…}
myObj.doSomethingNew=doSomething;// 附加到对象：
myObj.doSomethingNew(x,y,z);//调用方法

从其他对象借用函数(借用函数，通过这种方式可以模拟继承)
1.定义一个树类
function Tree(name,leaf,bark){
this.name=name;
this.leaf=leaf;
this.bark=bark;
}
2.添加一个函数
Tree.prototype.describe=function(){
return this.name+”: leaf=”+this.leaf+”,bark=”+this.bark;
}
3.实例化一个Tree对象
var Beech=new Tree(‘Beech’,”green,serrated edge”,’smooth’);
alert(Beech.describe());
4.定义一个类表示狗
function Dog(name,bark){
this.name=name;
this.bark=”wau! wau!”;
}
5.实例化一个Dog类
var Snowy=new Dog(“Snowy”,”wau!wau!”);
6.借用函数
var temFunc=Beech.describe;
tmpFunc.call(Snowy);//Function.call()第一个参数是上下文对象。狗狗借用describe()方法。方法中的this被改了，由于Dog没有leaf属性，所以leaf的值为：undefined;

javascript中的闭包
关于闭包，最简单的描述就是 ECMAScript 允许使用内部函数－－即函数定义和函数表达式位于另一个函数的函数体内。

Java代码
function Robot(){
var createTime=new Date();
this.getAge=function(){
var now=new Date();
var age=now-createTime;
return age;
}
}
function Robot(){
var createTime=new Date();
this.getAge=function(){
var now=new Date();
var age=now-createTime;
return age;
}
}

闭包仅仅当内部函数创建在外部函数之内的时候才可以运行，因为它使用了外部函数的局部变量。这样的话使得局部变量不能被垃圾器收集，会造成内存泄漏。闭包的替代方法，就是避免使用它，方法：
function Robot(){
this.createTime=new Date();
}
Robot.prototype.getAge=function(){
var now=new Date();
var age=now-createTime;//createTime是一个可以访问的变量
return age;
}