1.对象，类，实例
2.面向对象的实现方法
3.类的继承

对象，类，实例

• 对象的定义：ECMA-262 把对象（object）定义为“属性的无序集合，每个属性都存放在一个原始值，对象或函数”。

• 类：每个对象都由类定义。

• 实例：程序实用类创建对象时，生成的对象是类的实例，由创建对象实例的过程是实例化

• 对象的构成：属性和方法

• 对象引用：在 ECMAScript 中，不能访问对象的物理表示，只能访问对象的引用：每次创建对象，存储在变量中的都是该对象的引用，而不是对象本身。

• 对象废除：ECMAScript 拥有无用存储单元收集程序（garbage collection routine），意味着不必专门销毁对象来释放内存。当再没有对对象的引用时，称该对象被废除（dereference）了。运行无用存储单元收集程序时，所有废除的对象都被销毁。每当函数执行完它的代码，无用存储单元收集程序都会运行，释放所有的局部变量，还有在一些其他不可预知的情况下，无用存储单元收集程序也会运行。
  把对象的所有引用都设置为 null，可以强制性地废除对象
  注意：废除对象的所有引用时要当心。如果一个对象有两个或更多引用，则要正确废除该对象，必须将其所有引用都设置为 null。
  var oObject = new Object;// do something with the object here oObject = null;

• 对象类型(系统对象)：本地对象、内置对象和宿主对象
  本地对象+内置对象--与宿主环境无关 即与执行环境无关

  • 本地对象
    ECMA-262 把本地对象（native object）定义为“独立于宿主环境的 ECMAScript 实现提供的对象”。简单来说，本地对象就是 ECMA-262 定义的类（引用类型）。它们包括：
    Object
    Function
    Array
    String
    Boolean
    Number
    Date
    RegExp
    Error
    EvalError
    RangeError
    ReferenceError
    SyntaxError
    TypeError
    URIError
  • 内置对象
    ECMA-262 只定义了两个内置对象，即 Global 和 Math （它们也是本地对象，根据定义，每个内置对象都是本地对象）
  • 宿主对象
    所有非本地对象都是宿主对象（host object），即由 ECMAScript 实现的宿主环境提供的对象。
    所有 BOM 和 DOM 对象都是宿主对象。

• 对象作用域：ECMAScript 只有公用作用域

  • 定义自己的类和对象时，必须格外小心。记住，所有属性和方法默认都是公用的
  • 建议性的解决方法
    ·由于缺少私有作用域，开发者确定了一个规约，说明哪些属性和方法应该被看做私有的。这种规约规定在属性前后加下划线：
    obj.color = "blue";
    这段代码中，属性 color 是私有的。注意，下划线并不改变属性是公用属性的事实，它只是告诉其他开发者，应该把该属性看作私有的。
    有些开发者还喜欢用单下划线说明私有成员，例如：obj._color。

• 关键字 this：this 总是指向调用该方法的对象

• 类的声明
  1.传统构造函数模拟类

  • function Animal(){
    this.name = 'blue';
    }
    2.ES6中class的声明
    class Animal{
    constructor(){//构造函数
    this.name = 'blue'
    }
    }

面向对象的实现方法

• 1.工厂方法
  //工厂模式
  function createPerson1(name,age,job){
  var o = new Object();
  o.name = name;
  o.age = age;
  o.job = job;
  o.sayName = function(){
  console.log(this.name);
  }
  return o;
  }
  var person1 = createPerson1("Nicholas",20,"Software Engineer");
  console.log(person1.name);
  var person2 = createPerson1("Greg",29,"Docter");
  console.log(person2.name==person1.name);//false
  console.log(person1 instanceof createPerson1);
  缺点：重复生成构造函数，可用外部函数重写构造函数
• 2. 构造函数方式
  function Car(color){
  this.color = color;
  this.showColor = function(){}
  }
  var car1 = new Car('red')
  var car1 = new Car('blue')
  构造函数与工厂模式的区别：
  ·1.构造函数没有创建对象，而用this关键字
  ·2.使用new创建对象
  ·3.不必return
  *使用 new 运算符构造函数时，在执行第一行代码前先创建一个对象，只有用 this 才能访问该对象。然后可以直接赋予 this 属性，默认情况下是构造函数的返回值（不必明确使用 return 运算符）
  构造函数缺点:
  就像工厂函数，构造函数会重复生成函数，为每个对象都创建独立的函数版本。不过，与工厂函数相似，也可以用外部函数重写构造函数，同样地，这么做语义上无任何意义
• 3.原型方式
  function Car() {
  }

Car.prototype.color = "blue";
Car.prototype.doors = 4;
Car.prototype.mpg = 25;
Car.prototype.showColor = function() {
alert(this.color);
};

var oCar1 = new Car();
var oCar2 = new Car();
缺点：
· 这个构造函数没有参数。使用原型方式，不能通过给构造函数传递参数来初始化属性的值，因为 Car1 和 Car2 的 color 属性都等于 "blue"，doors 属性都等于 4，mpg 属性都等于 25。这意味着必须在对象创建后才能改变属性的默认值
·属性指向的是对象，而不是函数时。函数共享不会造成问题，但对象却很少被多个实例共享

• 4.混合构造函数/原型方式
  function createPerson(name,sex,age){
  this.name = name;
  this.sex = sex;
  this.age = age;
  }
  createPerson.prototype.say = function(){
  console.log(this.name+" hello world");
  }
  createPerson.prototype.run = function(){
  console.log(this.name+" running");
  }
  var obj = new createPerson("blue", "girl","20");
  var obj1 = new createPerson("red","boy","10");
  obj.say();
  obj.run();
  obj1.say();
  //alert(obj.say()==obj1.say());//true
  console.log(obj instanceof createPerson);

类的继承

**继承的本质是原型链

1.借助构造函数实现继承
2.借助原型链
3.组合方式
4.组合继承优化--Object.create
5.组合继承优化--for in

function Parent(){
this.name = 'blue'
}
function B(){
A.call(this)
}

• 1. 借助构造函数实现继承
     在子函数中执行父函数，用call改变this指向
• 2. B.prototype = new A()
     缺点:
     实例多个对象，一改则全改
     不能判断对象由谁创建
• 3.B.prototype = A.prototype
  缺点：
  无法判断对象由谁创建
  子类prototype添加新东西会改变父类
• 4 B.prototype = Object.create(A.prototype)
  B.prototype.constructor = B
  5.for(var i in A.prototype){
  B.prototype[i]=A.protyotype[i]
  }