面向对象

为什么要学习面向对象（面向对象思想）

面向对象奇数是目前流行的系统设计开发技术，它包括面向对象分析和面向对象程序设计。面向对象程序设计技术的提出，主要是为了解决传统程序设计方法——结构化程序设计所不能解决的代码重用问题。

---

面向对象三个基本特征

1、封装

封装是面向对象的特征之一，是对象和概念的主要特性。封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治。封装的对象，这些对象通过一个受保护的接口访问其他对象。一旦定义了一个对象的特性，则有必要决定这些特性的可见性，即哪些特性对外部世界是可见的，哪些特性用于表示内部状态。在这个阶段定义对象的接口。通常，应禁止直接访问一个对象的实际表示，而应通过操作接口访问对象，这成为信息隐藏。事实上，信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。

animate函数是动画封装函数 
  @para0  elem参数就是运动的对象 
  @para1  targetJSON参数就是运动的终点状态，可以写px，也可以不写px 
            { 
                "left": 500, 
                "top": 600 
            } 
  @para2  time是运动总时间，毫秒为单位 
  @para3  tweenString缓冲描述词，比如"Linear"，可选 
  @para4  callback是回调函数，可选 
  return    本函数没有返回值 

function animate(elem , targetJSON , time , tweenString , callback){ 
    //函数重载，用户传进来的参数数量、类型可能不一样 
    //检查数量和类型 
    if(arguments.length < 3 || typeof arguments[0] != "object" || typeof arguments[1] != "object" || typeof arguments[2] != "number"){ 
        throw new Error("对不起，你传进来的参数数量不对或者参数类型不对，请仔细检查哦！"); 
        return; 
    }else if(arguments.length == 3){ 
        //用户只传进来3个参数，表示tweenString、callback被省略了，那么我们默认使用Linear当做缓冲词 
        tweenString = "Linear"; 
        //默认回调函数是null 
        callback = null; 
    }else if(arguments.length == 4){ 
        //用户只传进来4个参数，第4个参数可能传进来的是tweenString，也可能是callback 
        switch(typeof arguments[3]){ 
            case "string" :  
                //用户传进来的是缓冲描述词儿，所以就把callback补为null 
                callback = null; 
                break; 
            case "function" :  
                callback = arguments[3]; 
                tweenString = "Linear"; 
                break; 
            default :  
                throw new Error("抱歉，第4个参数要么是缓冲描述词，要么是回调函数，请检查！"); 
        } 
    } 

2、继承

由于js不像java那样是真正面向对象的语言，js是基于对象的，它没有类的概念。所以，要想实现继承，可以用js的原型prototype机制或者用apply和call方法去实现。
在面向对象的语言中，我们使用类来创建一个自定义对象。然而js中所有事物都是对象，那么用什么办法来创建自定义对象呢？这就需要用到js的原型：我们可以简单的把prototype看做是一个模版，新创建的自定义对象都是这个模版（prototype）的一个拷贝 （实际上不是拷贝而是链接，只不过这种链接是不可见，新实例化的对象内部有一个看不见的Proto指针，指向原型对象）。
js可以通过构造函数和原型的方式模拟实现类的功能。 另外，js类式继承的实现也是依靠原型链来实现的。

function People(name,age,sex){
                this.name = name;
                this.age = age;
                this.sex = sex;
            }
            People.prototype.sayHello = function(){
                alert("你好我是人" + this.name);
            }
            People.prototype.chifan = function(){
                alert("我吃饭了！mia mia");
            }
            function Student(name,age,sex,xuehao,xiaohonghuageshu){
                this.name = name;
                this.age = age;
                this.sex = sex;
                this.xuehao = xuehao;
                this.xiaohonghuageshu = xiaohonghuageshu;
            }
            //核心语句，继承的实现全靠这条语句了：
            Student.prototype = new People();
            Student.prototype.sayHello = function(){
                alert("你好我是小学生，我的学号是" + this.xuehao);
            }
            Student.prototype.study = function(){
                alert("好好学习，天天向上");
            }
            Student.prototype.lol = function(){
                alert("玩儿英雄联盟啊！");
            }
            var xiaohong = new Student("小红",11,"女",20160001,4);
            //xiaohong.lol();
            //xiaohong.chifan();
            xiaohong.sayHello();

3、多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
实现多态，有二种方式，覆盖，重载。
覆盖，是指子类重新定义父类的虚函数的做法。
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”
那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

var makeSound=function (animal) {
        animal.sound();
    }
    var Duck=function () {
    }
    var Dog=function () {
    }
    Duck.prototype.sound=function () {
        console.log("嘎嘎嘎")
    }
    Dog.prototype.sound=function () {
        console.log("旺旺旺")
    }
    makeSound(new Duck());
    makeSound(new Dog());

---

面向对象程序设计的优点

1、开发时间短，效率高，可靠性高，所开发的程序更强壮。由于面向对象编程的可重用性，可以在应用程序中大量采用成熟的类库，从而缩短了开发时间。
2、应用程序更易于维护、更新和升级。继承和封装使得应用程序的修改带来的影响更加局部化。