JavaScript OOP多态、封装、继承

封装

　　封装就是把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，

程序的其它部分只有通过被授权的操作(成员方法)，才能对数据进行操作。

JS封装只有两种状态，一种是公开的，一种是私有的。

 <script type="text/javascript"> 
      function Person(name, agei, sal){ 
        // 公开 
        this.name = name; 
        // 私有
        var age = agei; 
        var salary = sal; 
      } 
      var p1 = new Person('zs', 20, 10000); 
      window.alert(p1.name + p1.age); 
 </script> 
//切记this和var的区别，this指向的是公开的意思，而var是定义为私有的意思

通过构造函数添加成员方法和通过原型法添加成员方法的区别
1、通过原型法分配的函数是所有对象共享的.
2、通过原型法分配的属性是独立.(如果你不修改属性，他们是共享)
3、建议，如果我们希望所有的对象使用同一个函数，最好使用原型法添加函数，这样比较节省内存。

特别强调：我们前面学习的通过prototype给所有的对象添加方法，但是这种方式不能去访问类的私有变量和方法。

多态

JS的函数重载

这个是多态的基础,虽然JS函数不支持多态，但是事实上JS函数是无态的，支持任意长度，类型的参数列表。

如果同时定义了多个同名函数，则以最后一个函数为准。

<html> 
<head> 
<script type="text/javascript"> 
  //一下例子说明js不支持重载
  /*function Person(){ 
    this.test1=function (a,b){ 
      window.alert('function (a,b)');  
    } 
    this.test1=function (a){ 
      window.alert('function (a)'); 
    } 
  } 
  var p1=new Person(); 
  //js中不支持重载. 
  //但是这不会报错，js会默认是最后同名一个函数，可以看做是后面的把前面的覆盖了。 
  p1.test1("a","b"); 
  p1.test1("a");*/ </script> 
</html>

所以得利用全局变量arguments可以实现，arguments是类数组，通过判断传入参数的长度可以访问到参数列表的值。

多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

说白点就是一个父类被多个子类继承，然后多个子类可以添加他们不同的属性和方法。

    function doAdd(){  
      if(arguments.length==1){  
        alert(arguments[0]+10);  
      }else if(arguments.length==2){  
        alert(arguments[0]+arguments[1]);  
      }  
    }  
    doAdd(10); //outputs "20"  
    doAdd(30,20);//outputs "50"

继承

继承可以解决代码复用，让编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时，可以从这些类中抽象出父类，

在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过继承父类中的属性和方法。

JS中实现继承的方式

//父类

function People(){

this.species ="人类";

}

//it子类

function ITDesigner(name,age){

this.name = name;

this.age = age;

}

用apply处理

　　　　ps:apply和call的区别其实很简单：apply的第二个参数必须是参数的数组，call的是可以是字符串，也可以是多个

function ITDesigner(name,age){  
    //在子类内部调用apply  
   People.apply(this,arguments);  
   this.name = name;  
   this.age = age;  
}

在举个与上面无关的例子区分apply和call

function Person(args){ //父类
this.Name = "李四";
}
function Studnt(a,b,c){ //子类
Person.apply(this,arguments); //技能方法一
Person.call(this,a,b,c); //技能方法二
}

用prototype处理

<script type="text/javascript">  
    function Person(name,age){  
        this.name=name;  
        this.age=age;  
    }  
    Person.prototype.sayHello=function(){  
        alert("使用原型得到Name："+this.name);  
    }  
    var per=new Person("周杰伦",37);  
    per.sayHello(); //输出：使用原型得到Name:周杰伦

      
    function Student(){}  
    Student.prototype=new Person("小明",19);  
    var stu=new Student();  
    Student.prototype.grade=5;  
    Student.prototype.intr=function(){  
        alert(this.grade);  
    }  
    stu.sayHello();//输出：使用原型得到Name:小明
    stu.intr();//输出：5  
</script>

JavaScript OOP多态、封装、继承

封装

多态

继承

用apply处理

用prototype处理