一、基本概述
1、 为什么要使用面向对象
利用面向对象思想，我们可以将同一类事物的操作码封装成对象，将用到的变量和函数作为对象的属性和方法，然后通过对象去调用，这样可以使代码结构清晰、层次分明。
2、面向对象的特征
- 封装性
封装性指的是隐藏内部的实现细节，只对外开放操作接口，接口就是对象的方法，无论对象的内部多么复杂，用户只需要知道这些接口是怎么使用即可。 - 继承性
继承是指一个对象继承另一个对象的成员，从而在不改变另一个对象的前提下进行扩展 - 多态性
多态指的是同一个操作作用与不同的对象，会产生不同的执行结果，实际上JavaScript被设计成一种弱类型语言，就是多态性的体现
例如：
var obj=123;
console.log(obj.toString());//输出结果：123
var obj={1,2,3};
console.log(obj.toString());//输出结果：1，2，3
obj=function(){};
console.log(obj.toString());//输出结果：function（）{}
二、构造函数
面向对象编程的第一步就是要生成对象，通常需要一个模板，然后对象根据这个模板生成。
在以Java为代表的面向对象编程语言中，引入了类的概念，用来以模板的方式构造对象。其中，通过类创建对象的过程称为实例化，创建出来的对象称为该类的实例。但是，JavaScript语言的对象体系，不是基于类的，而是基于构造函数和原型链
构造函数就是专门用来生成实例对象的函数，就是对象的模板，描述实例对象的基本结构。一个构造函数可以生成多个实例对象，这些实例对象都有相同的结构。
构造函数就是一个普通的函数，但是又有自己的特征和用法
function Person(name,age){
this.name=name;
this.age=age;
this.sayHello=function(){
console.log('Hello,my name is'+this.name);
};
}
var p1=new Person('Jack',18);
var p2=new Person('Alice',19);
console.log(p1);
console.log(p2);
p1.sayHello();
console.log(p1.constructor);
从上述代码可以看出，在构造函数中通过this可以为对象添加成员。在添加方法体时，方法体中的this表示该对象本身，例如，当p1对象调用sayHello()方法时，方法体中的this.name表示p1.name();
构造函数的特征有两个:
- 函数体内部使用了this关键字，代表了所要生成的对象实例。
- 生成对象的时候，必须使用new命令。
三、this关键字
在JavaScript中，函数有多种调用的环境，如直接通过函数名调用、作为对象的方法调用、作为构造函数等。根据函数不同的调用方式，函数中的this指向会发生改变。但不管在什么场合，this都有一个共同的特点：它总是返回一个对象。简单地说，this就是属性或方法当前所在的对象。
在JavaScript中，函数内的this指向通常和以下三种情况有关：
- 使用new关键字将函数作为构造函数调用时，构造函数内部的this指向新创建的对象
- 直接通过函数名调用函数时，this指向的是全局对象（浏览器中表示window对象）
- 如果将函数作为对象的方法调用，this将会指向该对象
function foo(){
return this;
}
var o={name:'Jim',func:foo};
console.log(foo()===indow);//输出结果：true
console.log(o.func===o);//输出结果：true
对于同一个函数foo(),当直接调用时，this指向window对象，而作为对象的方法调用时，this指向的是o对象
四、原型与继承
1、为什么要使用原型
利用原型可以提高代码的复用性。假设有p1、p2两个对象，都是由构造函数Person创建的。如果我们在Person中定义一个introduce()方法，则p1、p2两个对象都有了introduce()方法
function Person(name){
this.name=name;
this.introduce=function(){};
}
var p1=new Person('Jim');
var p2=new Person('Alice');
console.log(p1.introduce==p2.introduce);//输出结果：false
虽然p1和p2都有introduce()，但他们本质上不是用同一个方法。为了解决这个问题，JS为函数提供了一个原型对象，通过原型对象来共享成员。
2、原型对象的使用方法
在JavaScript中，每定义一个函数，就随之有一个对象存在，函数通过prototype属性指向该对象。这个对象称为原型对象，简称原型。
在利用构造函数创建对象时，每个对象都默认与这个原型对象连接，连接后就可以访问到原型对象中的属性和方法
function Person(){
this.name=name;
}
Person.prototype.introduce=function(){};
var p1=new Person('Jim');
var p2=new Person('Alice');
console.log(p1.introduce);//输出结果：function
console.log(p1.introduce===p2.introduce);//输出结果：true
可以看出，构造函数Person原本没有introduce()方法，但是在为Person的原型对象添加了该方法后，p1、p2对象都具有了相同的introduce();
3、继承
- 利用原型对象实现继承
function Person(name) {
this.name=name;
}
Person.prototype.sayHello=function () {
console.log('你好，我是'+this.name);
};
var p1=new Person('Jim');
var p2=new Person('Tom');
p1.sayHello();//输出结果：你好，我是Jim
p2.sayHello();//输出结果：你好，我是Tom
- 替换原型对象实现继承
JavaScript实现继承的方式很灵活，我们可以将构造函数的原型对象替换成另一个对象A，基于该构造函数的对象就会继承新的原型对象，如：
function Person() {
Person.prototype={
sayHello:function () {
console.log('你好，我是新对象');
}
}
}
var p=new Person();
p.sayHello();//输出结果：你好，我是新对象
要注意的是，在基于构造函数创建对象时，代码应在替换原型对象之后，否则创建的对象仍然会继承原来的原型对象
function Person() {}
Person.prototype.sayHello=function () {
console.log('原来的对象');
};
var p1=new Person();
Person.prototype={
sayHello:function () {
console.log('替换后的对象')
}
};
var p2=new Person();
p1.sayHello();//输出结果：原来的对象
p2.sayHello();//输出结果：替换后的对象
- 利用Object.create()实现继承
var obj={
sayHello:function () {
console.log('我是一个带有sayHello方法的对象')
}
};
var newObj=Object.create(obj);
newObj.sayHello();//输出结果：我是一个带有sayHello方法的对象
newObj._proto_===obj;//返回结果：true
- 混入继承
混入就是将一个对象的成员加入到另一个对象中，实现对象功能的扩展，实现混入继承最简单的方法就是将一个对象的成员赋值给另一个对象
