构造函数：
基本用法
function 类名（参数列表）{ 属性=参数值； }
案例：
function Person(name,age){ this.name=name; this.age=age; }
//创建Person对象的时候，就可以直接给名字,年龄 var p1=new Person(\顺平\
特别说明：在给一个对象初始化一个属性值的时候，也可以指定函数属性 案例：
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(\
window.alert(p1.myfun(89,90,\输出179
创建对象的另一种形式：
如果一个对象比较简单，我们可以直接创建。可以指定普通属性和函数属性。 var dog={name:\小狗\age:8,
fun1:function(){window.alert(\fun2:function(){window.alert(\};
window.alert(dog.name+dog.age); window.alert(dog.constructor); dog.fun1(); dog.fun2();
有时我们会看到这样一种调用方法：函数名.call（对象实例） 这样调用,该函数的this就是这个对象实例。 小案例：
var dog={name:\function test(){
window.alert(this.name); }
test.call(dog);//==dog.test; 输出：hello
for ..in的用法
var dog={name:\小明\//循环列出 dog对象的所有属性和方法 对象名[\属性名\for(var key in dog){
window.alert(key+\属性 dog[key]属性值 }
//遍历window对象的所有属性 for(var key in window){
document.write(key+\}
JS面向对象编程的三大特性
1封装
js提供有以下几种控制方法和属性的访问权限: 1)公开级别:对外公开
2)私有级别:类本身可以访问,不对外公开 案例：
function Person(name,age,sal){ this.name=name;//公开的属性 var age=age;//私有的属性 var sal=sal;//私有的属性
//在类中如何定义公开方法（特权方法），私有方法（内部方法） //如果我们希望操作私有的属性则可用公开方法去实现 this.show=function(){
window.alert(age+\}
//私有方法,可以访问对象的属性 function show2(){
window.alert(age+sal); } }
var p1=new Person(\
p1.show();//这个可以成功//不能在类的外部去访问私有的方法 p1.show2();//不能在类的外部去访问私有的方法 特别强调：
我们前面学习的通过prototype给所有的对象添加方法，但是这种方式不能去访问类的私有变量和方法。 function Person(){
this.name=\var age=90;
this.abc=function(){ window.alert(\}
function abc2(){ window.alert(\} }
Person.prototype.fun1=function(){ window.alert(this.name);//ok //window.alert(age);//no ok //abc2();//no ok this.abc();//ok }
var p1=new Person(); p1.fun1();
2.继承
1）为什么需要继承
//解决代码冗余问题-->继承
//抽象出一个学生类，即把中学生和小学生的共性拿出来 function Stu(name,age){ this.name=name; this.age=age;
this.show=function(){
window.alert(this.name+\} }
function MidStu(name,age){ this.stu=Stu;
this.stu(name,age);
//JS中实际上是通过对象冒充来实现继承，这句话不可少，因为JS是动态语言，如果不执行，则不能实现继承效果 }
function Pupil(name,age){ this.stu=Stu;
this.stu(name,age); }
var midStu=new MidStu(\顺平\midStu.show(); 特别说明：
通过对象冒充，JS可以实现多重继承的效果，用的少. JS的函数重载和重写的问题
重载：JS中不支持重载，即不可以通过参数的个数或者是类型来决定调用哪个函数，但是因为JS天然的支持可变参数的，所以，它可以是看成天然支持重载。 function abc(){
if(arguments.length==…){
}else{ }
重写：子类可以重新写函数来覆盖父类的某个方法 父类：
function Stu(name,age){ this.name=name; this.age=age;
this.show=function(){
window.alert(this.name+\}
子类：
function MidStu(name,age){ this.stu=Stu;
this.stu(name,age);//JS中实际上是通过对象冒充来实现继承，这句话不可少 //MidStu可以覆盖Stu父类的show方法 this.show=function(){ window.alert(\} }
var midStu=new MidStu(\顺平\midStu.show(); //这里调用的是子方法
多态的例子： function Master(){
this.feed=function(animal,food){
window.alert(\主人给\喂\} }
function Food(name){ this.name=name; }
function Fish(name){ this.fish=Food; this.fish(name); }
function Bone(name){ this.bone=Food; this.bone(name); }
function Animal(name){ this.name=name; }
function Cat(name){ this.cat=Animal; this.cat(name); }
function Dog(name){
this.dog=Animal; this.dog(name); }
var master = new Master(); var cat=new Cat(\小猫\var fish=new Fish(\鱼\master.feed(cat,fish); 输出：主人给小猫喂鱼
补讲闭包： 解释：
1） 闭包和垃圾回收gc是相关联的
2） 闭包实际上是在涉及到一个对象的成员属性何时被gc处理的问题 3） 怎样才能对对象的属性形成一个闭包
案例：
//闭包closure function A(){ var i=0;
function b(){
window.alert(i++); }
return b; }
//A();//此时内存中有i的空间就被回收了
var c=A();//这种用法gc不会把i当成垃圾处理 c();//0
c();//0从而证明i被闭包了