面向对象程序设计

一、创建对象的几种方式

       1、工厂模式：缺点是不知道对象类型

function createPerson(age) {
    var o = new Object();
    o.age = age
    o.sayAge = function() {
        alert(this.age);
    }
    return o;
}

var p1 = createPerson(11);
var p1 = createPerson(12);

       2、构造函数模式:缺点就是每一次new Person的时候都是创建一个Function对象实例（sayAge）

function Person(age) {
   this.age = age;
   this.sayAge = function() {
       alert(this.age); 
   }
}

var p1 = new Person(11);
var p2 = new Person(12);

       3、原型模式:缺点数据共享的问题

           hasOwnProperty可以检测属性是实例属性还是原型中的属性;

           in:对象能够访问属性的时候返回true;

function Person() {
}
Person.prototype={
     constructor:Person,
     name:"gt",
     friends:['a','b'],
     sayName:functon(){
         alert(this.name);
     }
     
};
var p1 = new Person();
var p2 = new Person();
p1.friends.push('c');


这样p1和p2都有朋友c这就是他们的问题所在

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

             目前使用的最为广泛的一种模式

function Person(age) {
    this.age=age;
}
Person.prototype = {
    constructor:Person,
    sayAge:function(){
        alert(this.age);
    }
}

var p1 = new Person(11);
var p2 = new Person(12);

       5、动态原型模式

function Person(age) {
    this.age=age;
    if(typeof this.sayName != "function") {
        Person.portotype.sayName = function() {
            alert(this.name)
        }
    }
}
var p1 = new Person(11);

       6、寄生构造函数模式

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

var colors = new SpecialArray('a','b');

       7、稳妥构造函数模式:没有公共属性，而且其方法也没引用this的对象

function Person(age){
    var o = new Object();
    o.sayAge = function() {
        alert(name);
    }
    return o;
}
var p1 = new Person(11);]
p1.sayAge();

只能通过sayAge方式来访问name,多用于比较安全的环境中

        

二、继承（主要通过原型链来实现）

    1、原型链

function SuperType(){
    this.property = true;
}
SuperType.propotype.getSuperValue = function(){
    return this.property;
};
function SubType(){
    this.subProperty=false;
}
SubType.prototype = new SuperType();

SubType.propotype.getSubTypeValue = function(){
    return this.subProperty;
}
var instance = new SubType();
alert(instance.getSuperType());

    2、借用构造函数

function SuperType(name){
    this.name = name;
}

function SubType(){
   SuperType.call(this,"nnnn");
   this.age=20;
}
var instance = new SubType();

    3、组合继承

function SuperType(name){
    this.name= name;
    this.colors = [1,2,3]
}
SuperType.propotype.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.propotype.sayAge= function(){
    alert(this.age);
}
var instance = new SubType('aaaa',20);
instance.colors.push(4);

    4、原型式继承

function object(0) {
    function F(){}
    F.prototype=o;
    return new F();
}

var person = {
    name='1111';
    friends=[1,3];
}
var p1 = object(person);
var p2 = object(person);

friends会被共享

//用Object.create方法实现
 
var p1 = Object.create(person);
var p2 = Object.create(person);

    5、寄生式继承

function object(0) {
    function F(){}
    F.prototype=o;
    return new F();
}

function createAnother(original) {
    var clone = object(original);
    clone.sayHi = function() {
       alert('hi');
    }
}

var person = {
    name='1111';
    friends=[1,3];
}
var p1 = createAnother(person);
p1.sayHi();

    6、寄生组合式继承

function object(0) {
    function F(){}
    F.prototype=o;
    return new F();
}

function inheritPrototype(subType,SuperType) {
    var prototype=object(super.prototype);
    prototype.constructor = subType;
    subType.prototype=prototype;
}

function SuperType(name){
     this.name = name;
     this.colors = [1,2,3,4];
}
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);
}