Javascript面向对象-- 1-- 【基础-function对象和prototype--原型链-封装】

1. 在javascript中,function也是一个对象,具有二重性,即,可以被调用,也可以被作为普通对象来使用.

    当function作为方法时,在其名称后面加上(),即可完成方法调用.

    当function作为对象时,它具有一系列的方法和属性

 

   定义一个function可用如下方法:

   

function func(x) 
{
    alert(x);
}
func(“blah”);

 

 

或者也可以用:

 

var func = function(x)
 {
    alert(x);
};
func(“blah2”);

 也可以用:

 

 

var func = new Function(“x”, “alert(x);”);
func(“blah3”);

 这种方式,使用函数对象的构造函数Function了构造一个function对象.

 

关于Function对象,可参考 http://www.w3school.com.cn/js/pro_js_functions_function_object.asp

 

2. Javascript中没有类(class)

如果要在javascript中定义一个class需要使用function

比如:

	function Person(name,age)
	{
		this.name= name;
		this.age= age;
	}

 

 这里就定义了一个Person类.

 

当需要一个Person实例的时候,可以使用new关键字.

比如: 

 

aGuy = new Person('jack',29);

 

“new”运算符执行的操作很简单。首先，它创建一个新的空对象。然后执行紧随其后的函数调用，将新的空对象设置为该函数中“this”的值。换句话说，可以认为上面这行包含“new”运算符的代码与下面两行代码的功能相当：

var aGuy = {}; 
Person.call( aGuy, “Spot”);

上面两种方式创建的aGuy对象时不同的,new方式创建的对象属性更多,具体可使用chrome,调用console.log(aGuy);查看

第一种:

Person

1. age: 29
2. name: "jack"
3. __proto__: Person
1. constructor: function Person(name,age)
2. __proto__: Object

第二种:Object {name: "jack", age: 29}

(注: 

call方法是Function对象的一个方法,类似的还有apply方法,

call方法参数不确定,第一个参数是要传递到函数中作为this的,从第二个参数开始,对应要调用函数的参数

apply方法参数有两个,第一个参数和call第一个参数相同,第二个参数是一个数组,保存需要传递到调用函数的参数.

具体参考:http://www.cnitblog.com/yemoo/archive/2007/11/30/37070.aspx

http://jo2.org/%E7%9E%AC%E9%97%B4%E8%AE%B0%E4%BD%8Fjavascript%E4%B8%ADapply%E4%)B8%8Ecall%E7%9A%84%E5%8C%BA%E5%88%AB/

 

3. 为javascript类添加方法

 

(1)第一种方式,在作为class的function中,将一个function作为方法,比如:

// Think of this as class Dog
function Dog(name) {
    // instance variable 
    this.name = name;
    // instance method? Hmmm...
    this.respondTo = function(name) {
        if(this.name == name) {
            alert(“Woof”);        
        }
    };
}

var spot = new Dog(“Spot”);

 这里的respondTo就定义了一个方法.

在上面的 Dog 定义中，我定义了名为 name 的实例变量。使用 Dog 作为其构造函数所创建的每个对象都有它自己的实例变量名称副本（前面提到过，它就是对象词典的条目）。这就是希望的结果。毕竟，每个对象都需要它自己的实例变量副本来表示其状态。但如果看看下一行，就会发现每个 Dog 实例也都有它自己的 respondTo 方法副本，这是个浪费；您只需要一个可供各个 Dog 实例共享的 respondTo 实例！通过在 Dog 以外定义 respondTo，可以避免此问题，如下所示：

function respondTo() {
    // respondTo definition
}

function Dog(name) {
    this.name = name;
    // attached this function as a method of the object
    this.respondTo = respondTo;
}

 

(2)第二种方式,需要先了解 javascript的原型(prototype)

 

   每一个function都有一个属性prototype(原型),这个prototype属性也是一个对象,它也有自己的prototype属性,这样       就形成了prototype链(原型链),这个原型链的终点是Object.prototype,因为Object.prototype指向null.

 

函数(function)的prototype对象有一个constructor属性,指向function,这样就形成了循环引用.

 

var spot = new Dog(“Spot”);

// Dog.prototype is the prototype of spot
alert(Dog.prototype.isPrototypeOf(spot));

// spot inherits the constructor property
// from Dog.prototype
alert(spot.constructor == Dog.prototype.constructor);
alert(spot.constructor == Dog);

// But constructor property doesn’t belong
// to spot. The line below displays “false”
alert(spot.hasOwnProperty(“constructor”));

// The constructor property belongs to Dog.prototype
// The line below displays “true”
alert(Dog.prototype.hasOwnProperty(“constructor”));

 当您尝试访问对象的属性/方法时，JavaScript 将检查该属性/方法是否是在该对象中定义的。如果不是，则检查对象的原型。如果还不是，则检查该对象的原型的原型，如此继续，一直检查到 Object.prototype。

 

JavaScript 动态地解析属性访问和方法调用的方式产生了一些特殊效果：

• 继承原型对象的对象上可以立即呈现对原型所做的更改，即使是在创建这些对象之后。
• 如果在对象中定义了属性/方法 X，则该对象的原型中将隐藏同名的属性/方法。例如，通过在 Dog.prototype 中定义 toString 方法，可以改写 Object.prototype 的 toString 方法。
• 更改只沿一个方向传递，即从原型到它的派生对象，但不能沿相反方向传递。

  下面这个例子显示了如何解决前面遇到的不需要的方法实例的问题。通过将方法放在原型内部，可以使对象共享方法，而不必使每个对象都有单独的函数对象实例。在此示例中，rover 和 spot 共享 getBreed 方法，直至在 spot 中以任何方式改写 toString 方法。此后，spot 有了它自己版本的 getBreed 方法，但 rover 对象和用新 GreatDane 创建的后续对象仍将共享在 GreatDane.prototype 对象中定义的那个 getBreed 方法实例。

function GreatDane() { }

var rover = new GreatDane();
var spot = new GreatDane();

GreatDane.prototype.getBreed = function() {
    return “Great Dane”;
};

// Works, even though at this point
// rover and spot are already created.
alert(rover.getBreed());

// this hides getBreed() in GreatDane.prototype
spot.getBreed = function() {
    return “Little Great Dane”;
};
alert(spot.getBreed()); //当前对象覆盖了prototype中的getBreed(),但是不影响其他从prototype///继承的getBreed(),因为其他对象并没有覆盖这个方法
// but of course, the change to getBreed 

// doesn’t propagate back to GreatDane.prototype

// and other objects inheriting from it,

// it only happens in the spot object

alert(rover.getBreed());

 

 

参考:http://msdn.microsoft.com/zh-cn/magazine/cc163419.aspx

参考： http://www.ruanyifeng.com/blog/2010/05/object-oriented_javascript_encapsulation.html