js中的对象创建与继承

对象创建

1.工厂模式

优点：解决了创建多个相似对象的问题

缺点：没有解决对象识别问题；每一个对象都有一套自己的函数，浪费资源

function createPerson(name, age, job) {
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function () {
alert(this.name);
};
return o;
}

//////////////////////////////////////////////////////////////
var person1 = createPerson("Nicholas", 29, "Software Engineer");
var person2 = createPerson("Greg", 27, "Doctor");

person1.sayName(); //"Nicholas"
person2.sayName(); //"Greg"

2.构造函数模式

优点：可以用来创建特定类型的对象

缺点：每个方法都要在每个实例上重新创建一遍

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

/////////////////////////////////////////////////////////////
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

3.原型模式

优点：所有对象实例可以共享它所包含的属性和方法

缺点：共享性，所有的均共享，对龚鸥的固然很好，但不能私有各自属性了

// 写法1：
function Person() {}
Person.prototype = {
constructor: Person,
name: "Nicholas",
age: 29,
job: "Software Engineer",
sayName: function() {
alert(this.name);
}
}

// 写法2：
function Person(){}
Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
alert(this.name);
};

//////////////////////////////////////////////
var person1 = new Person();
person1.sayName(); //"Nicholas"
var person2 = new Person();
person2.sayName(); //"Nicholas"
alert(person1.sayName == person2.sayName); //true

4.构造函数模式和原型模式

思路：构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性

优点：每个实例都会有自己的一份实例属性副本，但同时又共享着对方法的引用，最大限度的节省了内存

缺点：

关于constructor的补充知识点：

只要创建了一个新函数，就会根据一组特定的规则为这个函数创建一个prototype属性，这个属性指向函数的原型对象。

在默认情况下，所有原型对象都会自动获得一个constructor构造函数属性，这个属性会包含一个指向protoype属性所在函数的指针。

```

function Person(name, age, job){

this.name = name;

this.age = age;

this.job = job;

this.friends = ["Shelby", "Court"];

}

Person.prototype = {

constructor : Person,

sayName : function(){

alert(this.name);

}

}

/////////////////////////////////////////////////////////

var person1 = new Person("Nicholas", 29, "Software Engineer");

var person2 = new Person("Greg", 27, "Doctor");

person1.friends.push("Van");

alert(person1.friends); //"Shelby,Count,Van"

alert(person2.friends); //"Shelby,Count"

alert(person1.friends === person2.friends); //false

alert(person1.sayName === person2.sayName); //true

#### 5.动态原型模式
思路：和4相比只是多了一个函数存在的检测

function Person(ame,age,job){

//属性

this.name = name;

this.age = age;

this.job = job;

//方法

if (typeof this.sayName != "function"){

Person.prototype.sayaName = function(){

alert(this.name);

}

}

}

/////////////////////////////////////////////////////////

var friend = new Person("Nicholas",29,"Software Engineer");

friend.sayName(); // Nicholas

#### 6.寄生构造函数模式
从表面上看是和工厂模式一样，只是最后实例化了一次，而工厂模式是没有再实例化

function Person(name,age,job){

var o = new Object();

o.name = name;

o.age = age;

o.job = job;

o.sayName = function(){

alert(this.name);

}

}

/////////////////////////////////////////////////////////

var friend = new Person("Nicholas",29,"Software Engineer");

friend.sayName(); // Nicholas

#### 7.稳妥构造函数模式
所谓稳妥对象，指的是没有公共属性，而且其方法也不引用this的对象。稳妥构造函数遵循与寄生构造函数类似的模式，有两点不同：
1.新创建对象的实例方法不引用this
2.不使用new操作符调用构造函数

function Person(name,age,job){

//创建要返回的对象

var o = new Object();

// 可以在这里定义私有变量和函数

//添加方法

o.sayName = function(){

alert(name);

}

return o;

}

/////////////////////////////////////////////////////////

var friend = Person("Nicholas",29,"Software Engineer");

friend.sayName(); // Nicholas

### 继承
#### 1.原型链继承
**思路**：用父类实例来充当子类实例对象
**缺点**：
1.共享(包含引用类型值的原型属性会被所有实例共享)
2.不能传参（没有办法在不影响对象实例的情况下给超类型的构造函数传递参数）

function SuperType() { // 定义父函数

this.property = true;

};

SuperType.prototype.getSuperValue = function() { // 给父函数添加方法

return this.property;

};

function SubType() { // 定义子函数

this.subproperty = false;

};

SubType.prototype.getSubValue = function() { // 给子函数添加方法

return this.subproperty;

};

/////////////////////////////////////

SubType.prototype = new SuperType(); // (关键)

var instance = new SubType(); // 实例化instance

alert(instance.getSuperValue()); //true

#### 2.借用构造函数
**思路**：借父类的构造函数来增强子类实例（等于把父类的实例属性复制了一份给子类实例装上了）
**优点**：可传参（可以在子类型的构造函数向超类型的构造函数传递参数）
**缺点**：不能复用（超类型原型链中定义的方法对子类是不可见的）

function SuperType() { // 定义父函数

this.colors = ["red", "blue", "green"];

}

function SubType() { // 定义子函数

SuperType.call(this); // (关键)

}

/////////////////////////////////////////////////

var instance1 = new SubType();

instance1.colors.push("black");

alert(instance1.colors); // "red,blue,green,black"

var instance2 = new SubType();

alert(instance2.colors); // "red,blue,green"

#### 3.组合继承
**思路**：把实例函数放在原型对象上，以实现函数复用
**优点**：无共享问题，可传参，可复用
**缺点**：父类构造函数会被调用两次，生成两份，而子类实例上的那一份屏蔽了子类原型上的，内存浪费。

function SuperType(name) { // 定义父函数

this.name = name;

this.colors = ["red", "blue", "green"];

}

SuperType.prototype.sayName = function() { // 给父函数添加方法

alert(this.name);

};

function SubType(name, age) { // 定义子函数

//继承属性

SuperType.call(this, name); // (关键：继承私有属性)

this.age = age;

}

//继承方法

SubType.prototype = new SuperType(); // (关键：继承公有方法)

SubType.prototype.constructor = SubType;

SubType.prototype.sayAge = function() {

alert(this.age);

};

///////////////////////////////////////////////////

var instance1 = new SubType("Nicholas", 29);

instance1.colors.push("black");

alert(instance1.colors); // "red,blue,green,black"

instance1.sayName(); // "Nicholas";

instance1.sayAge(); // 29

var instance2 = new SubType("Greg", 27);

alert(instance2.colors); // "red,blue,green"

instance2.sayName(); // "Greg";

instance2.sayAge(); // 27

#### 4.原型式继承
**思路**：用Object函数得到一个空的新对象，再逐步增强填充实例属性
**优点**：从已有的对象上衍生新对象，不需要创建自定义类型
**缺点**：共享问题

Object.create() :ES5中规范了原型式继承
参数1：用作新对象原型的对象
参数2：为新对象定义额外属性的对象

function object(o){

function F(){}

F.prototype = o;

return new F();

}

var person = { // 父函数

name: "Nicholas",

friends: ["Shelby", "Court", "Van"]

};

var anotherPerson = object(person); // （关键）子1继承父

anotherPerson.name = "Greg";

anotherPerson.friends.push("Rob");

var yetAnotherPerson = object(person); // （关键）子2继承父

yetAnotherPerson.name = "Linda";

yetAnotherPerson.friends.push("Barbie");

alert(person.friends); //"Shelby,Court,Van,Rob,Barbie"

#### 5.寄生式继承
**思路**：创建一个用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后返回
**优点**：不需要创建自定义类型
**缺点**：不能复用

function createAnother(original) {

var clone = object(original); //通过调用函数创建一个新对象

clone.sayHi = function(){ //以某种方式来增强这个对象

alert("hi");

};

return clone; //返回这个对象

}

var person = { // 父函数

name: "Nicholas",

friends: ["Shelby", "Court", "Van"]

};

var anotherPerson = createAnother(person); // （关键）子函数继承父函数

anotherPerson.sayHi(); //"hi"

#### 6.寄生组合式
**思路**：切掉了原型对象上多余的那份父类实例属性

function inheritPrototype(subType, superType) {

var prototype = object(superType.prototype); //创建对象

prototype.constructor = subType; //增强对象

subType.prototype = prototype; //指定对象

}

function SuperType(name) {

this.name = name;

this.colors = ["red", "blue", "green"];

}

SuperType.prototype.sayName = function() {

alert(this.name);

};

function SubType(name, age) {

SuperType.call(this, name); // (关键)

this.age = age;

}

inheritPrototype(SubType, SuperType); // (关键)

SubType.prototype.sayAge = function() {

alert(this.age);

};

```