function A(){} // 外观上，构造器和普通函数没有什么区别。习惯上大写首字母

A.prototype = {
  aa: 'aa', // 原型属性
  method: function(){} // 原型方法
};

var a = new A; // 创建实例a
var b = new A; // 创建实例b

console.log(a.aa === b.aa); // true
console.log(a.method === b.method); // true

function A(){
  var count = 0; // 私有属性
  this.aa = 'aa'; // 特权属性
  this.method = function(){ return count; }; // 特权方法
  this.obj = {}; // 特权属性
}

A.prototype = {
  aa: 'aa',
  method: function(){}
};

var a = new A;
var b = new A;

console.log(a.aa === b.aa); // true， 由于aa的值为基本类型，所以比较的是原始值，但其实有不同的内存地址
console.log(a.obj === b.obj); // false 由于obj的值为引用类型，所以比较的是内存地址，可以看出是不同的对象
console.log(a.method === b.method); // false，函数其实也是特殊的对象，同引用类型的规则

delete a.method;
console.log(a.method === A.prototype.method); // true

A.method2 = function(){ console.log('A.method2') }; // 模拟Java的类方法

var c = new A;
console.log(c.method2); // undefined
A.method2(); // A.method2

function A(){}
A.prototype = {
  aaa: 1
}

function B(){}
B.prototype = A.prototype;

var b = new B;
console.log(b.aaa); // 1

A.prototype.bbb = 2;
console.log(b.bbb); // 2

// 使用时，传入的都是原型，将source中的成员都添加到destination，但会覆盖同名成员
function extend(destination, source){
  for(var property in source){
    destination[property] = source[property];
  }
  return destination;
}

function A(){}
A.prototype = {
  aa: function(){ alert(1) },
  aaa: 1
}

function bridge(){}
bridge.prototype = A.prototype;

function B(){}
B.prototype = new bridge; // 此处的new bridge操作得到了一个实例，
// 通过该实例能访问父类的原型成员，因为该实例的类的原型就是父类原型，
// 而在子类原型（其实是一个父类原型的实例）上添加新成员
// PS: 此处其实还有一个B.prototype.constructor的指向问题
//    实例的constructor（其实是创建一个函数的时候就自动添加到原型上的）指向其构造器
//    可参考：[深入分析js中的constructor 和prototype](https://www.cnblogs.com/yupeng/archive/2012/04/06/2435386.html)

var a = new A;
var b = new B;

console.log(A.prototype == B.prototype); // false,说明子类和父类的原型对象不是同一个对象了，成功分离
console.log(a.aa === b.aa); // true,子类共享父类的原型方法

A.prototype.bb = function(){ alert(2) } // 为父类动态添加原型方法
console.log(a.bb === b.bb); // true,子类总会共享父类的原型成员

B.prototype.cc = function(){ alert(3) } // 为子类动态添加原型方法
console.log(a.cc === b.cc); // false,父类不会获取到子类修改后的原型成员

// instanceof操作符能正确检测是否是实例
console.log(b instanceof A); // true
console.log(b instanceof B); // true

// 传入的o是一个原型对象（其实也可以是任意普通的对象）
// 返回子类的原型
Object.create = function(o){
  function F(){} // 相当于bridge函数，
  F.prototype = o;
  return new F();
}

B.prototype = Object.create(A.prototype); // 如此即可指定B的原型为A的原型的一个实例，即B继承A

//
function inherit(init, Parent, proto){
  // 声明一个构造器，即真正的子类
  function Son(){
    Parent.apply(this, argument); // 先继承父类的特权成员
    init.apply(this, argument); // 再执行自己的构造器
  }

  // 由于Object.create可能不是原生的，因此避免使用第二个参数,而是用一个空对象代替
  Son.prototype = Object.create(Parent.prototype, {});
  // IE下子类无法自动通过父类原型实例获取到父类的toString和valueOf方法
  Son.prototype.toString = Parent.prototype.toString;
  Son.prototype.valueOf = Parent.prototype.valueOf;
  Son.prototype.constructor = Son; // 此处确保构造器的正确指向，而不是Object，

  extend(Son.prototype, proto); // 向子类添加自定义的原型成员
  extend(Son, Parent); // 向子类添加父类的类成员

  return Son; // 最后返回子类
}

function A(){}
A.prototype = {
  aa: function(){ console.log(1) }
}

var a = new A;
console.log(a.aa); // ƒ (){ console.log(1) } 即 function(){ console.log(1) }

// 将A的整个原型换掉
A.prototype = {aa: 2};
console.log(a.aa); // 不影响，还是ƒ (){ console.log(1) }


// 测试是否能被constructor修改
function B(){}
B.prototype = {
  aa: 3
}
a.constructor = B;
console.log(a.aa); // 不影响

function A(){
  console.log(this.__proto__.aa); // 1
  this.aa = 2
}
A.prototype = {
  aa: 1
}

var a = new A;
console.log(a.aa); // 2
a.__proto__ = {
  aa: 3
}

delete a.aa; // 删除特权属性，暴露原型链上的同名属性
console.log(a.aa); // 3

function A(){}
A.prototype = {
  aa: 1
}

function B(){}
B.prototype.__proto__ = A.prototype;

var b = new B;
console.log(b.aa); // 1
console.log(b.constructor); // ƒ B(){} 即 function B(){}
console.log(b instanceof A); // true
console.log(b instanceof B); // true
console.log(b.__proto__ === B.prototype); // true

function A(){}
A.prototype = {
  aa: 1
}

function bridge(){}
bridge.prototype = A.prototype;

function B(){}
B.prototype = new bridge;
B.prototype.constructor = B;

var b = new B;
B.prototype.cc = function(){ alert(3); };
console.log(b.__proto__ === B.prototype); // true
console.log(b.__proto__.__proto__ === A.prototype); // true 父类的原型对象