JavaScript基础--面向对象三大特性（八）：继承封装多态

一、构造函数
基本用法：
function 类名（参数列表）{
属性=参数值
}

 function Person(name,age){
    this.name = name;
    this.age = age;
 }
 
 //创建Person对象的时候，可以直接给名字和年龄
 var p1 = new Person('abc',80);
 window.alert(p1.name);
 var p2 = new Person('hello',9);
 window.alert(p2.name);
 
 //在给一个对象初始化普通属性值的时候，也可以指定函数属性
 
        function jiSuan(num1,num2,oper){
         if(oper=="+"){
            return num1 + num2;
         }else if(oper=="-"){
            return num1 - num2;
         }else if(oper=="*"){
            return num1 * num2;
         }else{
            return num1 / num2;
         }
     }
 
     function Person(name,age,fun){
         this.name = name;
         this.age =age;
         this.myfun = fun;
     }
 
     //创建对象时，不仅要可以初始化变量，还可以初始化一个函数
     var p1 = new Person("aa",9,jiSuan);
         window.alert(p1.myfun(90,89,"+"));

二、创建对象的有一种形式【加强篇】

2.1 JSON创建对象

//如果一个对象比较简单，我们可以直接创建。(可以指定普通属性和函数)
   var dog ={name:'小狗',age:8};
   window.alert(dog.constructor);
   window.alert(dog.name + dog.age);
 
//扩展：
    var dog = {name:'小狗',
           age:8,
           fun1:function(){window.alert('hello,world');},
           fun2:function(){window.alert('okok');}
           };
    window.alert(dog.constructor);
    window.alert(dog.name + dog.age);
    dog.fun1();
    dog.fun2();
 
//有时，我们看到这样一种调用方法，函数名.call(对象实例)
//这样调用，该函数的this就是对象实例
var dog ={name:'hello'};
function test(){
   window.alert(this.name);
}
test();
window.test();
//这两个方法都打印出undefine
test.call(dog);  //<==>dog.test();

2.2 使用for...in 遍历

 var dog= {name:'小明',sayHello:function(a,b){window.alert("结果="+(a+b));}};
 //循环列出dog对象的所有属性和方法 对象名['属性名']
 for(var key in dog){
    window.alert(dog[key]);
 }
 
 //document.write("****当前浏览器window对象所有属性和方法****<br/>");
 for(var key in window){
    document.writeln(key+":"+window[key]+"<br/>");
 }

三、JS面向对象的三大特性：继承、封装和多态

3.1 封装

　　js提供有以下几种控制方法和属性的访问权限：
　　　　(1) 公开级别：对外公开
　　　　(2) 私有级别：类本身可用访问，不对外公开。

 function Person(name,agei,sal){
       this.name = name;  //公开的属性
       var age=agei;   //私有属性
       var salary=sal; //私有属性
       //在类中如何定义公开方法（特权方法）,私有方法(内部方法)
       //如果我们希望操作私有的属性，则可用公开方法实现
       this.show=function(){
        window.alert(age+" "+salary);
       }
 
       //私有方法
       function show2(){
             window.alert(age+" "+salary);
       }
       show2();
    }
 
    var p1 = new Person('sp',20,50000);
    window.alert(p1.name+" "+p1.age);
    p1.show(); //这个可以ok
    //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); //ok
         //window.alert(age);  //no ok  私有变量
       //abc2(); //no ok   私有方法
       //window.alert(age);  //no ok   私有变量
 
     }
 
     var p1 = new Person();
     p1.fun1();

3.2 继承

A、为什么需要继承

 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("顺平",20);
   window.alert(midStu.name);
   midStu.show();
 
//特别说明：通过对象冒充，js可以实现多重继承的效果，用的比较少

3.3  js的重载和重写

3.3.1 重载：js中不支持重载（即，不可用通过参数的个数来决定调用哪个函数，但是因为js本身支
持可变参数，所有，它可以看成天然支持重载）

　　

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

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

//父类
 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();");//这里就会去调用子类的show方法
        }*/
   }
   var midStu = new MidStu("zhangsan",3);
   midStu.show();

3.4 多态：一个引用类型在不同情况下的多种状态，在java中多态是指通过父类的引用，来调用在不同子类中实现的方法。js实际上是无态的，是一种动态语言，一个变量的类型是在运行的过程中由js引擎来决定的，所有说，js天生就是支持多态。

 function Person(){
   this.test1=function(){
       window.alert("Person test1");
   }
 }
 function Cat(){
   this.test1=function(){
        window.alert("Cat test1()");
   }
 }
 var  v = new Person();
 v.test1();
 v = new Cat();
 v.test1();

3.4.1 面向对象三大特征案例

 function Master(){
         //给动物喂食
        this.feed =function(animal,food){
             document.write("主人给"+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 Peach(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);
     }
 
     function Monkey(name){
            this.animal = Animal;
            this.animal(name);
     }
 
     var cat = new Cat("小猫咪");
     var dog = new Dog("小狗");
     var fish = new Fish("小鱼");
     var bone = new Bone("骨头");
 
     var master = new Master();
     master.feed(cat,fish);
     master.feed(dog,bone);
     master.feed(new Monkey("小猴"),new Peach("水蜜桃"));

四、闭包

4.1 解释：

　　　　（1）闭包和gc是相关联的
　　　　（2）闭包实际是涉及到一个对象的属性，何时被gc处理的问题
　　　　（3）怎样才能对对象的属性形成一个闭包

 //案例：
  function A(){
         var i=0;
         function b(){
             window.alert(i++);
         }
         return b;
    }
    var c =A();  //执行完A函数后，i的值已变成1，然后把b的构造函数赋值给c,但是i在A函数中，虽然A已执行完，但是i没有被立即回收，而是在C函数中继续执行，这样i就被闭包了。
    c();
   /*闭包的作用就是在a执行完并返回后，闭包使得Javascript的垃圾回收机制GC不会收回a所占用的资源，因为a的内部函数b的执行需要依赖于a中的变量i*/

分析：
//闭包<---->gc
A();//此时内存中会有i的空间被gc处理
var c = A(); //这种用法，gc不会把i当做垃圾
//c();
window.alert("aa");
//..
//..
c(); //输出0;
c(); //输出1;从而证明i变量被闭包