JavaScript不区分类和实例的概念，而是通过原型（prototype）来实现面向对象编程。

<script>
var Student={
    name:'Robot',
    height:1.2,
    run:function(){
        console.log(this.name + " is running...");
    }
};
var xiaoMing = {
    name:'小明'
};
xiaoMing.__proto__=Student;
console.log(xiaoMing.name);
xiaoMing.run();
</script>

xiaoMing.__proto__=Student;把小明的原型指向了Student，就好像是继承自Student一样。
所谓的继承关系就是把一个对象的原型指向另一个对象。
在实际编程中，不要使用proto来改变一个对象的原型，而且低版本的ie也不支持
Object.create方法可以传入一个原型对象，并创建一个基于该原型的新对象，但是新对象什么属性都没有。下面我们试一试这种方法。

//原型对象
var Student = {
    name:'Robot',
    height:1.2,
    run:function(){
        console.log(this.name + ' is running');
    }
};
function createStudent(name){
    //基于Student原型创建一个新的对象
    var s = Object.create(Student);
    //初始化新对象
    s.name = name;
    return s;
}
var xiaoMing = createStudent('小明');
xiaoMing.run();//小明 is running
console.log(xiaoMing.__proto__ === Student);//true

创建对象

JavaScript对每个创建的对象都会设置一个原型，指向它的原型对象。
当我们访问obj.xxx的时候，JavaScript引擎首先在当前对象上查找该属性，如果没有找到，就到期原型对象上找，如果还是没有找到，就一直上溯到Object.prototype对象，最后，如果还没有找到，就只能返回undefined。
例如一个Array对象var arr = [1,2,3];，它的原型链是：
arr ----> Array.prototype ----> Object.prototype ----> null
因为Array.prototype定义了indexOf()等方法，所以你定义的arr对象可以直接使用这些方法。

创建一个函数：

function foo(){
  return 0;
}

原型链：
foo ----> Function.prototype ----> Object.prototype ----> null
Function.prototype定义了apply()等方法，所以所有的函数也都可以使用这些方法。

使用构造函数来创建对象

function StudentFun(name){
    this.name = name;
    this.hello = function(){
        alert('Hello' + this.name);
    }
}
//上面这只是一个普通的函数，但是如果用new来调用的话，就会返回一个对象
var xiaoMing = new StudentFun('小明');
console.log(xiaoMing.name);
xiaoMing.hello();

注意：如果不写new，就是一个普通的函数，返回undefined，如果写了new，就是一个构造函数，它绑定的this指向新创建的对象，并默认返回this，不需要再最后写return this。
xiaoMing的原型链：
xiaoming ----> Student.prototype ----> Object.prototype ----> null
console.log(xiaoMing instanceof StudentFun);//true

//比较
var xiaoHong = new StudentFun('小红');
console.log(xiaoMing.name==xiaoHong.name);
console.log(xiaoMing.hello==xiaoHong.hello);
//这里发现xiaoMing.name不等于xiaoHong.name，这个我们理解
//但是xiaoMing.hello也不等于xiaoHong.hello

两个对象的同一个方法不是同一个方法，导致这个问题的原因是，我们的方法是针对对象来创建的，我们可以把方法提取到原型上，这样就可以节约很多的内存。
多个对象指向一个方法

//将方法绑定到对象的原型上
function StudentFun1(name){
    this.name = name;
}
StudentFun1.prototype.hello = function(){
    alert('hello '+ this.name);
};
var xiaoMIng = new StudentFun1('小明');

注意：如果没有写new。在strict模式下，this.name会找不到this而报错。在非strict模式下，this绑定的是window，不会报错，但是创建了全局变量name，并且返回了undefined，这个情况更糟糕。
按照约定：构造函数首字母大写，普通方法的首字母小写。一些语法检查工具如jslint将可以帮你检测到漏写的new。
定义一个创建对象的方法来创建对象，这样绝对不会忘记new
这个createStudent2()
函数有几个巨大的优点：一是不需要new
来调用，二是参数非常灵活，可以不传，也可以这么传：

//为了防止漏掉new的情况发生，我们创建对象写一个方法，以后直接调这个方法就可以。
function StudnetFun2(props){
    this.name = props.name || '匿名';
    this.grade = props.grade || 1;
}
StudnetFun2.prototype.hello=function(){
    alert('hello' + this.name);
}
function createStudent2(props){
    return new StudnetFun2(props || {})
}
//使用map来作为参数可以方便传入任何多个数据
var xiaoMing = createStudent2({
    name:'小明'
});
var xiaoHong = createStudent2({
    name:'小红'   
});
console.log(xiaoMing.name);
console.log(xiaoMing.hello == xiaoHong.hello);
xiaoHong.hello();

原型继承

这个原理很啰嗦，但是实现很简单。

JavaScript的原型继承实现方式就是：

• 定义新的构造函数，并在内部用call()调用希望“继承”的构造函数，并绑定this；
• 借助中间函数F实现原型链继承，最好通过封装的inherits函数完成；
• 继续在新的构造函数的原型上定义新方法。

function Student(props){
    this.name=props.name || 'unnamed';
}
Student.prototype.hello = function(){
    alert('Hello,' + this.name);
}
//定义子类
function PrimaryStudent(props){
    //调用Student构造函数，绑定this对象
    Student.call(this,props);
    this.grade = props.grade || 1;
}
//实现原型的继承链
inherits(PrimaryStudent, Student);

//绑定其他的方法到PrimaryStudent原型
PrimaryStudent.prototype.getGrade = function(){
    return this.grade;
}

//把继承的过程定义成一个公共的方法
function inherits(child,parent){
    var F = function(){};
    F.prototype = parent.prototype;
    child.prototype = new F();
    child.prototype.constructor = child;
}
var primStu = new PrimaryStudent({name:'张三',grade:'132'});
console.log(primStu.getGrade());
primStu.hello();

class继承（一种比原型继承更简单的方法）

class这么好用，能不能现在就用上？现在用还早了点，因为不是所有的主流浏览器都支持ES6的class。
如果一定要现在就用上，就需要一个工具把class
代码转换为传统的prototype
代码，可以试试Babel这个工具。

//使用class来编写Student(但是class这个关键字必须在严格模式下运行，就我们目前的现状来看，严格模式编写的js代码会使整个项目都跑不起来了。)
class Student{
    constructor(name){
        this.name = name;
    }
    hello(){//注意这个方法没有function关键字
        alert('Hello,' + this.name + "!");
    }
}
var xiaoMing = new Student('小明');
xiaoMing.hello();
//继承
class PrimaryStudent extends Student{
    constructor(name,grade){
        super(name);//用super来调用父类的构造方法
        this.grade = grade;
    }
    myGrade(){
        alert('I am at grade=' + this.grade);
    }
}
xiaoHong = new PrimaryStudent('小红',38);
xiaoHong.hello();
xiaoHong.myGrade();