js面向（基于）对象编程-三大特征

①抽象

js提供以下几种控制方法和属性的访问权限：

（1）公开级别：对外公开

（2）私有级别：类本身可以访问，不对外公开

案例如下所示：

function Person(name,age,sal){
        this.name=name;//公开的属性
        var age=age;//私有属性
        var salary=sal;//私有属性

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

    var p1=new Person("sp",20,50000);
    window.alert(p1.name+" "+p1.age);
    p1.show();
    //p1.show2();//报错，因为show2是私有方法。

输出：sp undefined

20 50000

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

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

    Person.prototype.fun1=function(){
        window.alert(this.name);
        //window.alert(age);//这会报错，因为prototype添加的方法不能访问类的私有属性和方法。
        this.abc();//必须用this.abc(),如果用abc()会报错
        //this.abc2();//报错，但是如果直接用abc2()又没有出问题
    }

    var p=new Person();
    p.fun1();

②继承

（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(){
                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中实际上是通过对象冒充，来实现继承，这句话不能少
    }

    function Pupil(name,age){
        this.stu=Stu;
        this.stu(name,age);
    }

    var midStu=new MidStu("顺平",20);

    midStu.show();

this.stu=Stu;后的this.stu(name,age)这句话是不能少的。

//抽象出一个学生类，（即把中学生和小学生的共性提取出来）
    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;//相当于把函数赋值给stu,赋值以后，一定要执行stu
        //this.stu(name,age);//js中实际上是通过对象冒充，来实现继承，这句话不能少
　　　　　//因为js是动态语言，如果不执行该语句，则不能实现继承效果。

    }

    function Pupil(name,age){
        this.stu=Stu;
        this.stu(name,age);
    }

    var midStu=new MidStu("顺平",20);
    window.alert(midStu.name);//没有this.stu(name,age);这句话，打印出undefined

    //midStu.show();//没有this.stu(name,age);这句话会报错，没有执行Stu函数

js可以不可以继承

没有extends关键字，但是可以通过对象冒充的方式实现继承，而且是多重继承。

特别说明：通过对象冒充，js可以实现多重继承的效果。

js不支持重载，但是函数的调用又和参数类型和参数个数是没有关系（其实也是另一种形式的重载，只是不是通过函数名来实现的）。

js的重载和重写

重载：js中不支持重载（即，不可以通过参数的个数 来决定调用哪个函数，但是因为js天热支持可变参数，所以，可以看做天热支持重载）。

结论：js只是不可以写几个同名函数（会被最后一个覆盖），但是因为函数调用时和参数没有关系，所以它具有函数重载所实现的功能。

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

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中实际上是通过对象冒充，来实现继承，这句话不能少
        //MidStu可以覆盖Stu父类的show
        this.show=function(){
            window.alert("MidStu show()");
        }
    }
　　

　　　 var midStu=new MidStu("顺平",20);
　　　　midStu.show();

重写，覆盖父类的方法。

③多态

所谓多态，就是指一个引用（类型）在不同情况下的多种状态。在java中多态是指通过指向父类的引用，来调用在不同子类中实现的方法。

js实际上是无态的，是一种动态语言，一个变量的类型是在运行的过程中由js引擎来决定的，所以说js天生就支持多态。

②封装