js 对象的封装，继承，多态的理解

//对象的继承，这里采用构造函数继承+类式继承
function Person(name,sex,age){
	this.name = name;
	this.sex = sex;
	this.age = age;
}

Person.prototype.getName = function(){
	return this.name;
}

function Student(school,name,sex,age){
	Person.call(this,name,sex,age);//构造函数继承，保证实例之间不会互相影响
	this.school = school;
}

Student.prototype = new Person();//类式继承，解决构造函数继承不能继承定义在外面的原型链的方法
Student.prototype.constructor = Student;//不然student1.constructor = Person

var student1 = new Student("西都小学1","1","男1",21);
var student2 = new Student("西都小学2","2","男2",22);

console.log(student1.getName());//1
student1.name = "修改";
console.log(student1.name);//修改
console.log(student2.name);//2

//多态就是构造函数根据传入的变量不同，对同一方法，有不同的返回结果
//比如
function Math(){
	function zero(){
		return 10;
	}
	function one(num){
		return 10+num;
	}
	this.add = function(){
		switch(arguments.length){
			case 0:
				return zero();
				break;
			case 1:
				return one(arguments[0]);
				break;
		}
	}
}
var math1 = new	Math();
console.log(math1.add());//10
console.log(math1.add(10));//20

//封装就是有些私有的属性和方法，用户只能通过公有方法去访问这些私有属性
function Company(name){
	var personNum = 0;
	this.name = name;
	this.getNum = function(){
		return personNum;
	}
	this.addNum = function(){
		personNum++;
	}
}
var company1 = new Company("保时捷");
var company2 = new Company("宝马");
console.log(company1.getNum());//0
company1.addNum();
console.log(company1.getNum());//1
console.log(company2.getNum());//0
console.log(company1.personNum);//undefined

当然对象的继承不仅仅只有这种，但我觉得这是比较好的一种选择，ES6的class语法让我们更容易去实现面向对象编程。

// 推荐 用 Object.create实现类式继承（https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/create）

//对构造函数+类式继承的完善，寄生组合继承

function Person(name, sex, age) {
    this.name = name;
    this.sex = sex;
    this.age = age;
}

Person.prototype.getName = function() {
    return this.name;
}

function Student(school, name, sex, age) {
    Person.call(this, name, sex, age); //构造函数继承，保证实例之间不会互相影响
    this.school = school;
}

(function() {
    // 创建一个没有实例方法的类
    var Super = function() {};
    Super.prototype = Person.prototype;
    //将实例作为子类的原型
    Student.prototype = new Super();//通过寄生方式，砍掉父类的实例属性，这样，在调用两次父类的构造的时候，就不会初始化两次实例方法/属性，避免了上面组合继承的缺点
       Student.prototype.constructor = Student

})();

 ES5 的继承，实质是先创造子类的实例对象this，然后再将父类的方法添加到this上面（Parent.apply(this)）。ES6 的继承机制完全不同，实质是先创造父类的实例对象this（所以必须先调用super方法），然后再用子类的构造函数修改this。

如何理解这个的意思呢？！

class a{
      constructor(y,z){
        this.y =y;
        this.z =z;
        console.log("a");
      }
      render(){
        console.log(this.y)
      }
 }
    
 class b extends a{
      constructor(m,n,x,y){
        super(x,y);//在super()前面定义this.n = n;是会报错的，这就是上面的意思，this还没有创建
        console.log("b");
        this.n=n;
        this.m=m;
   　　}
      
      render(){
        console.log(this.m);
      }
 }

我们将其转为es5的代码

"use strict";

var _createClass = function() {
    function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
        }
    }
    return function(Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
    };
}();

function _possibleConstructorReturn(self, call) {
    if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return call && (typeof call === "object" || typeof call === "function") ? call : self;
}

function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true
        }
    });
    if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
}

function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}

var a = function() {
    function a(y, z) {
        _classCallCheck(this, a);

        this.y = y;
        this.z = z;
        console.log("aaaa");
    }

    _createClass(a, [{
        key: "render",
        value: function render() {
            console.log(this.y);
        }
    }]);

    return a;
}();

var b = function(_a) {
    _inherits(b, _a);

    function b(m, n, x, y) {
        _classCallCheck(this, b);
　　　　　
　　　　　　　//this.n = n;
　　　　　　　//this.m = m;//对于es5，我们在这里写也是没问题的，但如果是在这里写，就是先创建了子类的实例，然后再去调用父类的，这就是上面那句话本人的理解　

        var _this = _possibleConstructorReturn(this, (b.__proto__ || Object.getPrototypeOf(b)).call(this, x, y));

        console.log("bbb");
        _this.n = n;
        _this.m = m;
        return _this;
    }

    _createClass(b, [{
        key: "render",
        value: function render() {
            console.log(this.m);
        }
    }]);

    return b;
}(a);

可以看到确实是想打印“aaa”，再打印“bbb”的，但是我们发现其继承方式与前面es5写的组合继承差不多。