构造函数

	function Star (uname, age){
		this.uname = uname
		this.age = age
		
		this.sing = function(){ log('唱歌~') }
	}
	
	let xzq = new Star('薛之谦', 30)
	
	let ldh = new Star('刘德华', 20)
	log(ldh) // { uname: '刘德华', age: 20, sing: f }
	ldh.sing() // 唱歌~
	
	log(ldh.sing === xzq.sing) // false

# 实例成员：构造函数内部，通过this添加的成员，如上面的：uname、age、sing
			实例成员，只能通过实例化的对象来访问，如：ldh.sing()才行，Star.sing()就不行

# 静态成员：在构造函数本身上，添加的成员，如：Star.sex = '男'
			静态成员只能通过构造函数访问，如：log(Star.sex) // 男
			不能通过实例化对象来访问（ldh.sex就不行）

# 构造函数 new 的执行过程
	1、new构造函数，可以在内存中创建一个空的对象
	2、this就会指向刚才创建的空对象
	3、执行构造函数里面的代码，就给这个空对象添加属性、方法
	4、返回这个对象（所以构造函数里面不用return）

---

prototype 原型对象

# js规定，每一个构造函数都有一个prototype属性，这个prototype就是一个对象
  所以，我们可以把'公共的方法'添加到这个'原型对象prototype上'（原型对象prototype的作用就是共享方法）

  所以：公共的属性，定义到，构造函数里面
		公共的方法，定义到，原型对象prototype上

	function Star (uname, age){
		this.uname = uname
		this.age = age
	}
	Star.prototype.sing = function(){ log('唱个歌') }
	
	let ldh = new Star('刘德华', 20)
	let xzq = new Star('薛之谦', 30)
	log(ldh.sing === xzq.sing) // true
	
	# console.log( ldh ) // 系统会自动，在对象的身上，添加一个'__proto__'，指向构造函数的原型对象
	
	# prototype
		console.log( ldh.__proto__ === Star.prototype ) // true

方法的查找规则：

	首先看`ldh对象`，它身上是否有sing()方法，如果有，就执行它的这个方法
	如果没有这个方法，但因为`__proto__`存在，就去`构造函数的原型对象prototype上`去找这个sing()方法

proto：对象原型

	每个对象身上都有一个`__proto__`对象原型，指向`指向构造函数的原型对象prototype`
	之所以，对象可以使用`构造函数的原型对象prototype`上的属性、方法
	是因为，对象有`__proto__(对象原型)`的存在
	
	`__proto__对象原型` 和 `构造函数的原型对象prototype`是等价的
	
	`__proto__对象原型`的意义：在于为对象的查找机制提供一个方向，或者说一条线路，
	但它是一个非标准属性，因此实际开发中，不可用使用这个属性，它只是内部指向原型对象prototype

---

原型链

	function Star(uname, age){
		this.uname = uname
		this.age = age
	}
	let ldh = new Start('刘德华', 123)
	
	log( ldh.__proto__ === Star.prototype ) // true
	
	log( Star.prototype.__proto__ === Object.prototype ) // true
	
	log( Star.prototype.__proto__ ) // null

原型链的查找规则

	当访问一个对象的属性(方法)时，首先看这个对象本身有没有该属性，
	
	如果没有，就查找它的原型（也就是`__proto__对象原型`，指向的是，`prototype原型对象`）
	
	如果还没有，就查找，原型对象的原型(Object的原型对象)
	
	依次类推，直到找到Object为止（null）
	
	`_proto_对象原型`的意义：在于为对象的查找机制提供一个方向，或者说一条路线，
	但是它是一个非标准属性，因此实际开发中，不可以使用这个属性，它只是内部指向原型对象prototype

---

可以通过原型对象，为JavaScript的（原来的）内置对象，进行扩展自定义的方法

如下：通过数组的原型对象，添加求和的方法

	Array.prototype.sum = function(){
		console.log(this) // 指向它的调用者
		let sum = 0
		for(let i=0; i<this.length; i++){
			sum += this[i]
		}
		return sum
	}
	
	let arr = [1, 2, 3] // let arr = new Array(1,2,3)
	
	console.log(arr.sum()) // 6

---

constructor 指回 原来的原型对象

// 定义一个构造函数Star
  function Star(uname, age) {
    this.uname = uname
    this.age = age
  }

  Star.prototype.sing = function () {
    console.log('唱歌~~')
  }

  // 对象.xxx：这样是向对象添加xxx属性，并不会覆盖这个对象
  Star.prototype.song = function () {
    console.log("我会唱歌")
  }

  Star.prototype.dance = function () {
    console.log("我会跳舞")
  }


  // 对象 = {}：这样是重新给对象赋值，会把原来的对象覆盖掉
  // 其实这里就是把 构造函数Star 的原型对象prototype 覆盖了，但是并不会影响uname、age在构造函数中定义的属性
  Star.prototype = {
    aaa() { console.log("我会唱歌aa") },
    bbb() { console.log("我会唱歌bbb") },
    // ....
    // ....
    // ....
  }

  // 手动用 constructor 指回原来的原型对象
  Star.prototype = {
    constructor: Star, // 指回原来的原型对象
    ccc() { console.log("我会唱歌ccc") },
    ddd() { console.log("我会唱歌ddd") },
    // ....
    // ....
    // ....
  }

  let ldh = new Star('刘德华', 123)
  console.log('ldh=', ldh) // ldh= Star {uname: '刘德华', age: 123}
  console.log('ldh.uname=', ldh.uname) // ldh.uname= 刘德华
  console.log('ldh.age=', ldh.age) // ldh.age= 123

  // ldh.sing() // Uncaught TypeError: ldh.sing is not a function
  ldh.song() // Uncaught TypeError: ldh.song is not a function

  // ldh.aaa() // Uncaught TypeError: ldh.aaa is not a function
  // ldh.bbb() //  Uncaught TypeError: ldh.bbb is not a function

  ldh.ccc() // 我会唱歌ccc.
  ldh.ddd() // 我会唱歌ddd