JS面向对象 关于类的封装、继承、多态

一、封装:把实现一个功能的代码放在一个函数中封装起来，以后再想实现这个功能的时候，我们不需要重新的编写代码了，只需要执行对应的函数即可，我们把这种机制就称之为"函数的封装" -->低耦合高内聚:减少页面中的冗余代码,提高代码的重复使用率

二、多态

后台语言[java、C#、ASP.net、php...]中的多态：重载、重写
重载(Reload)：多个方法,方法名相同,参数的个数或者参数的类型不一样
重写(Rewrite)：子类重写父类的方法

JS严格意义上不存在重载，后面的方法会把前面的方法覆盖掉；

JS中的多态指的是一个方法的多种形态:一个方法,我们通过传递进来的参数值的不一样,实现不一样的功能

//根据传递的n和m的值不一样,我们获取的结果也不一样,例如:如果执行的时候不传递任何的参数,返回[0-1)之间的随机小数,如果传递了两个值1/10,返回的是[1-10]之间的随机整数

function getRandom(n,m){
n = NUmber(n);
m = Number(m);
if(isNaN(n) || isNaN(m)){
return Math.random();
}
if(n>m){
n= n+m;
m= n-m;
n =n-m
}
return Math.round(Math.random()*（m-n）+n);
}

三、继承

继承:子类继承父类中的属性和方法(私有的/公有的)

1.原型继承：子类.prototype = new 父类；既可以继承父类私有的，也可继承父类公有的，并且都继承到子类的公有上了 ->父(私有+公有) 变为 子(公有)；

->核心原理:和生活中儿子继承爹的基因原理是不一样的;生活中是儿子把爹的基因克隆一份一模一样的到自己的身上,接下来儿子怎么改都跟父亲没关系;但是原型继承并不是把父类的属性和方法克隆一份到自己这,只是改变了原有的原型的指向,当我们在使用父类方法的时候,是通过原型链的查找机制一级级的向上查找使用的...

  function A() {
        this.x = 100;
    }
    A.prototype.getX = function () {
        console.log(this.x);
    };

    function B() {
        this.y = 200;
    }
    //想让B作为子类,继承A这个父类中的私有的/公有的属性和方法
    B.prototype = new A;

    var b = new B;
    b.getX();

->重写:子类重写父类的方法
b.aa=function(){} ->写在b这个小的实例私有属性上,和B的其他实例没有任何的关系
b.__proto__.bb=function(){} ->写在B.prototype上的
b.__proto__.__proto__.cc=function(){} ->写在A.prototype上的.

---

2.call继承：call继承只能把父类的私有的属性，继承到子类的私有属性上 ->父(私有) 变为 子(私有)；

->原理:在子类B中,把父类A当做普通的函数的执行(A原型上写的方法等都起不到作用了),然后让A执行的时候,里面的this变为B的一个实例,也就是在A函数体中写的this.xxx=xxx其实也相当于给B的实例增加了一些私有的属性(属于直接把A中的拿过来一份)...

    function A() {
        this.x = 100;//->也就是此时A作为一个普通函数执行,私有作用域中的this->b ->b.x=100;
    }
    A.prototype.getX = function () {
        console.log(this.x);
    };

    function B() {
        //this->B的实例b
        this.y = 200;//->b.y=200;

        A.call(this);//->执行A这个方法,让里面的this关键字变为b
    }
    var b = new B;

3.混合继承:call继承/冒充对象继承+原型继承

 function A() {
        this.x = 100;
    }
    A.prototype.getX = function () {
        console.log(this.x);
    };

    function B() {
        this.y = 200;
        A.call(this);
    }
    B.prototype = new A;
    var b = new B;

    //b
    //私有的 y:200 x:100
    //b.__proto__-> x:100
    //b.__proto__.__proto__-> getX:function...

4.冒充对象继承

->原理:在子类B的函数体中,创建父类A的一个实例temp(此时的temp就拥有了A的私有和公有的属性),接下来把temp当做一个普通的对象进行遍历,把遍历到的私有和公有的属性分别的添加给B的实例b(这样也相当于把父类中的克隆一份一样的拿到子类上了)...
->父(公有+私有) 变为 子(私有)

 function A() {
        this.x = 100;
    }
    A.prototype.getX = function () {
        console.log(this.x);
    };

    function B() {
        //this->b
        this.y = 200;

        var temp = new A;//->创建A的一个实例temp,它是一个对象数据类型,temp就拥有了A这个类的私有和公有的属性和方法 x:100 getX:function...
        for (var key in temp) {//->for in即可以循环temp私有的,也可以循环公有的
            this[key] = temp[key];//->第一次 b.x=temp.x=100 ...
        }
        temp = null;
    }
    var b = new B;