JavaScript学习总结(二)--JavaScript原型 继承

工厂函数模式

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 0;
    }
    var person1 = createPerson('Nicholas', 29, 'software engineer');
    var person2 = createPerson('greg', 27, 'doctor')

构造函数模式

function Person(name, age, job) {
      this.name = name;
      this.age = age;
      this.job = job;
      this.sayName = function () {
        alert(this.name);
      }
      return 0;
    }
    var person1 = new Person('Nicholas', 29, 'software engineer');
    var person2 = new Person('greg', 27, 'doctor');
    alert(person1.constructor == Person) // true

• 构造函数始终都应该以一个大写之母开头，而非构造函数则应该以小写之母开头。

• 建立Person的新实例，必须使用new操做符。

  • 使用new这种方式调用构造函数会经历4个步骤
    1.建立一个新对象
    2.将构造函数的做用域赋给新对象（所以 this就指向了这个新对象）
    3.执行构造函数中的代码 为这个新对象添加属性
    4.返回新对象

• 构造函数与普通函数的区别

  • 任何函数经过new操做符来调用，那它就是构造函数

• 构造函数的缺点

  • 就是每一个方法都要在每一个实例上从新建立一遍。
  • person1和person2都有一个名为sayName()的方法，但那两个方法不是同一个Function的实例。
  • 每定义一个函数，也就是实例化了一个对象。

• 从逻辑上讲，能够这样

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = new Function('alert(this.name)'); //与声明函数在逻辑上是等价的
  }
  alert(person1.sayName == person2.sayName) // false

• 把函数定义转移到构造函数外部

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

  function sayName() {
    alert(this.name);
  }
  var person1 = new Person('Nicholas', 29, 'software engineer');
  var person2 = new Person('greg', 27, 'doctor')
// 咱们把sayName()定义在外部，person1 和person2 共享了在全局做用域中定义的同一个sayname()函数。
// 若是对象须要定义不少方法，那么就要定义不少个全局函数，因而这个自定义的引用类型没有分装性可言
// 可使用原型模式

原型模式

使用原型对象的好处是可让全部对象实例共享它所包含的属性和方法

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

    //  什么是原型对象
    // 只要建立了一个函数，就会根据一组特定的规则为该函数建立一个prototype属性，这个属性指向函数的原型对象。
    // 在默认状况下，全部的原型对象都会自动得到一个constructor（构造函数）属性。这个属性包含一个指向prototype属性所在函数的指针。
    // Person.prototype  constructor指向Person.
    // 而经过这个构造函数，咱们能够原型对象添加其余属相和方法。

简单的原型模式语法

function Person() {
    }
    Person.prototype = {
      name: 'nicholas',
      age: 29,
      job: 'software engineer',
      sayName: function() {
        alert(this.name);
      }
    }
  
  var friend = new Person();

• 原型对象的缺点
  • 不能为构造函数传递初始化参数
  • 最大的问题是 是由其共享本性所致使的。
  • 原型中全部属性是被不少实例共享的。

原型链

原型链是做为实现继承的主要方法。

• 其基本思想就是利用原型让一个引用类型继承另外一个引用类型的属性和方法、

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

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

借用构造函数继承

使用apply() 和call() 方法也能够在未来新建立的对象上执行构造函数

function SuperType() {
    this.colors = ['red', 'blue', 'green'];
  }
  function SubType() {
    // 继承了 supertype
    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'

// 1.传递参数
  function SuperType(name) {
    this.name = name;
  }
  function SubType() {
    // 继承了SuperType同时还传递了参数
    SuperType.call(this, 'nicholas');
    // 实例属性
    this.age = 29;
  }
  var instance = new SubType();
  alert(instance.name);
  alert(instance.age);

• 借用构造函数的问题
  • 方法都在构造函数中定义，所以函数的复用就无从谈起。

组合继承

经过借用构造函数来实现对实例属性的继承。这样，即经过在原型上定义方法实现了函数复用，有能保证每一个实例都有它本身的属性、

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