Javascript-面向对象

创建对象

工厂模式

抽象创建的具体过程，工厂，顾名思义，按模版产生对象

function Person(name,age,job){
  var o = new Object();
  o.name = name;
  o.age = age;
  o.job = job;
  o.sayName = function(){
    console.log(this.name);
  }
}

调用： p = Person("Arno",22,"st");
缺点：无法识别对象类别

构造函数模式

自定义构造函数，可以声明某一类对象

function Person(name,age,job){
  this.name = name;
  this.age = age;
  this.job = job;
  this.sayName = function(){
    console.log(this.name);
  }
}

没有返回对象，直接调用 new操作获取对象： p = new Person("Arno_z", 22, "st")
此时过程如下：
1:创建一个新对象
2:将构造函数的作用域赋值给新对象（this指向新对象）
3:执行构造函数中的代码
4:返回新对象
此时可以判断类型：

p.constructor == Person // true
p instance Person // true

缺点：对象的每个方法都是单独声明的，不能共享方法

原型模式

在Javascript中实现共享数据的方法是采用prototype方式，如下：

function Person(){
}
Person.prototype.name="Arno";
Person.prototype.age=22;
Person.prototype.job="st";
Person.prototype.sayName=function(){
  console.log(this.name);
}

调用： p = new Person();
每一个声明的函数都会有一个对应的prototype属性，指向函数的原型对象，然后每一个prototype都会有一个constructor的属性指向prototype属性所在的函数的指针。
当调用构造函数声明一个实例之后，实例内部会有一个指针prototype指向构造函数的原型对象。注意是(构造函数的prototype属性指向prototype，每一个实例的prototype也指向构造函数的原型对象)
当创建完实例之后，访问实例属性的时候，除了访问本地属性还会访问原型上的属性，这就是所谓的原型链访问模式。
判断函数的属性是本身的还是原型上的采用函数 hasOwnProperty
if 实例.hasOwnProperty(属性)返回true 则证明是本身的属性，否则就不是
还存在一个in方法，查看目标属性是否在实例的本身或者原型链上，只要存在就返回true
for in 方法返回的是本身和原型链上可枚举的变量
缺点：没有构造函数传递参数的操作，所有的实例都共享同样的数据和方法

组合使用构造函数模式和原型模式

针对的原型模式的缺点，提出了组合使用构造函数模式和原型模式，这也是目前比较流行的做法，既有自身特性，又有共享方法和数据

function Person(name, age, job){
  this.name = name;
  this.age = age;
  this.job = job;
}
Person.prototype.sayName = function(){
  console.log(this.name);
}

寄生构造函数模式

假设我们想创建一个具有额外方法的特殊数组，但不能修改Array的构造函数，所有可以如下操作：

function spray(){
  var values = new Array();
  values.push.apply(values, arguments);
  value.toPipedString = function(){
    return this.join("|");
  };
  return values;
}
}

类似于工厂模式，相当于对于某个已存在的对象的拓展

继承

原型链继承

原型和实例的关系：每个构造函数都有一个原型对象，原型对象都包含指向构造函数的指针，而实例都包含一个指向原型对象的内部指针。那么，如果我们将原型对象等于另一个类型的实例，那么此时的原型对象将包含一个指向另一个原型的指针，相应的，另一个原型中也包含着一个指向另一个构造函数的指针，假如另一个原型又是另一个类型的实例，那么上述关系依然成立，如此蹭蹭地柜，就构成了实例与原型的链条，这就是所谓的原型链。
原型链样例如下：

function SuperType(){
  this.property = true;
}
SuperType.prototype.getSuperValue = function(){
  return this.property;
};
function SubType(){
  this.subproperty = false;
}
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function(){
  return this.subproperty;
}
var instance = new SubType();
alert(instance.getSuperValue()); //true

缺点：由于把父类的实例赋给了子类的原型，所以所有的子类的实例都共享同一个父类实例，那么就会造成互相的变量影响。

借用构造函数

针对上述的问题，一种方法就是为每一个子类声明一个对应的父类。也叫借用构造函数（伪造对象或经典继承）；实现的思路就是在子类的构造函数中调用父类的构造函数，如下：

function SuperType(){
  this.colors = ["Red","Blue","Green"];
}
function SubType(){
  SuperType.call(this);
}

这样声明子类实例的时候，每个子类都有对应的父类实例，互不影响。
缺点：如果父类有需要共享的方法或者属性则无法实现

组合继承

针对前面两种的缺点，组合原型链和借用构造函数的优点解决问题。使用原型链实现原型属性和方法的继承，对于实例属性通过借用构造函数实现。

function SuperType(name){
  this.colors = ["Red","Blue","Green"];
  this.name = name;
}
SuperType.prtotype.sayName = function(){
  console.log(this.name);
}
function SubType(name, age){
  SuperType.call(this, name);
}
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
  console.log(this.age);
}