js面向对象编程-三大特征

1.抽象
在定义一个类的时候，实际上就是把一类事物的公有的属性和行为提取出来，形成一个物理模型（模板）。这种研究问题的方法称为抽象。

2.封装
封装就是把抽象出的属性和对属性的操作封装在一起，属性被保护在内部，程序的其他部分只有通过被授权的操作（函数），才能对属性进行操作。
js提供有以下几种控制方法和属性的访问权限：
（1）公开级别：对外公开
（2）私有级别：类本身可以访问，不对外公开

function Person(){
    this.name=name; //公开属性
    var age=agei;  //私有属性
    var salary=sal;  //私有属性
    //在类中如何定义公开方法（特权方法），私有方法（内部方法） 
    //如果我们希望操作私有的属性。则可用公开方法实现
    this.show=function(){
        window.alert(age+" "+salary);
    }
    //私有方法，可以访问对象的属性
    function show2(){
        window.alert(age+" "+salary);
    }
}

var p1=new Person('sp',23,34);
window.alert(p1.name);
p1.show();   //正常输出
//p1.show2();  //错误输出不能被定义

注意：前面学过通过prototype给所有对象添加方法，但是这种方式不能去访问类的私有变量和方法。
例如：

    function Person(){
        this.name="abc";
        var age=90;
        this.abc=function(){
            window.alert("abc()");
        }
        function abc2(){
            window.alert("abc2");
        }

    }
    Person.prototype.fun1=function(){
        window.alert(this.name);  //正确
        this.abc();   //正确
        //abc2();  错误不能访问私有方法
        //window.alert(age);  错误不能访问私有变量
    }
    var p1=new Person();
    p1.fun1();

3.继承
（1）为什么需要继承？
问题：

    function MidStu(name,age){
        this.name=name;
        this.age=age;
        this.show=function(){
        window.alert(this.name+" "+this.age);
        }
    //计算学费
        this.payFee=function(money){
            window.alert("应缴"+money*0.8);
        }
    }

    function pupil(name,age){
        this.name=name;
        this.age=age;
        this.show=function(){
        window.alert(this.name+" "+this.age);
        }
    //计算学费
        this.payFee=function(money){
            window.alert("应缴"+money*0.5);
        }
    }

上面的代码存在冗余的问题：
解决方法可以使用继承（对象冒充来实现继承效果的）

    function Stu(name,age){
        this.name=name;
        this.age=age;
        this.show=function(){
            window.alert(this.name+" "+this.age);
        }
    }   
    function MidStu(name,age){
        this.stu=Stu;
        this.stu(name,age);//js中实际上是通过对象冒充来实现继承，这句话不能少（因为js是动态语言，如果不执行这句话，那么不能实现继承效果）
        //MidStu可以覆盖Stu父类的show称为重写
        this.show=function(){
            window.alert("MidStu show();");
        }
    }   
    function Pupil(name,age){
        this.stu=Stu;
        this.stu(name,age);
    }
    //测试
    var midStu=new MidStu("abc",20);
    midStu.show();//这里就会调用子类的show()

说明：通过对象冒充，js可以实现多重继承的效果，用得少。
（2）js的重载和重写
重载：方法重载就是类的同一种功能的多种实现方式，到底采用哪种方式，取决于调用者给出的参数。
js中不支持重载（即不可以通过参数的个数来决定调用哪个函数），但是因为js本身支持可变参数，所以可以看成天然支持重载。

function abc(){
    if(argument.length=...){
    }else if(){
    }
}

重写：子类可以重新写函数来覆盖父类的某些方法。

4.多态
多态就是指一个引用（类型）在不同情况下的多种状态。
js实际上是无态的，是一种动态语言，一个变量的类型是在运行的过程中由js引擎来决定的，所以说js天生就支持多态。

多态经典案例

    function Master(){
        //给动物喂食
        this.feed=function(animal,food){
            document.writeln("主人给"+animal.name+"喂"+food.name);
        }
    }

    //写食物类
    function Food(name){
        this.name=name;
    }
    function Fish(name){
        this.food=Food;
        this.food(name);
    }   
    function Bone(name){
        this.food=Food;
        this.food(name);
    }

    //动物
    function Animal(name){
        this.name=name;
    }
    function Cat(name){
        this.animal=Animal;
        this.animal(name);
    }
    function Dog(name){
        this.animal=Animal;
        this.animal(name);
    }

    var cat=new Cat("小猫咪");
    var fish=new Fish("小鱼");
    var master=new Master();
    master.feed(cat,fish);
    master.feed(new Dog("小狗"),new Bone("骨头"));