javascript(js)基础3:.js面向对象三大特征(封装、继承、多态) and 内部类.js系统函数

标签：

封装
<script language="JavaScript">
    function Person(name,age,sal){
        this.name=name;//公开属性
        this.age=age;
        this.sal=sal;
        sal=sal;//私有属性
        //如何定义公开方法（特权方法）和私有方法
        //如果我们希望操作私有的属性，则使用公开方法
        this.show=function(){
            window.alert(age+sal)
        }
        //私有方法,可以访问对象的属性(只能在类内部使用)
        function show2(){
           window.alert(age+sal)
        }
    }
    var p1=new Person(‘sp‘,34,5000);
    p1.show()
    
</script>
通过前面的学习，通过prototype给所有对象添加方法，但是这种方法不能访问类的私有方法和属性

function p1(){
            this.a=1;//公开方法
            var age=20;//私有方法

        }
p1.prototype.func1=function(){
    alert(this.a)
    alert(age)
}
        var a=new p1();
        a.func1();

阮一峰 prototype

继承

<script language="JavaScript">
    function Stu(name,age){

        this.name=name;
        this.age=age;
        this.show=function(){

            alert(this.age+this.name)
        }
    }
    function M1(name,age){
        this.stu=Stu;
        this.stu(name,age);//js中实际上通过对象冒充，来继承，此句不能缺少

//M1可以覆盖Stu父类的show方法,重载与重写(覆盖)

    this.show=function(qian1){
        alert(qian1)
    }

    }
    function M2(aa,bb){
        this.stu=Stu;
        this.stu(aa,bb);
    }
    var m1=new M1(‘cc‘,30)
    m1.show()
</script>

js可以多重继承，不支持重载(不可以通过参数个数来决定调用哪个函数，但是，因为
JS天然可以支持可变参数,所以它可以看到天然支持重载)
function abc(){
if argument.length==1{
　　}
}
重写:子类可以重新实现一个方法，来覆盖父类的某个方法

function Stu(name,age){

        this.name=name;
        this.age=age;
        this.show=function(){

            alert(this.age+this.name)
        }
    }
    function M1(name,age){
        this.stu=Stu;
        this.stu(name,age);//js中实际上通过对象冒充，来继承，此句不能缺少

//M1可以覆盖Stu父类的show方法,重载与重写(覆盖)

    this.show=function(qian1){
        alert(qian1+‘重写‘)
    }

 var m1=new M1(‘cc‘,30)
    m1.show()//这边就会重新调用覆盖的方法

多态

 多态案例

//主人类
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 Bond(name){
    this.bond=Food;
    this.bond(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 cat=new Cat(‘小白‘)
var dog=new Dog(‘小黑‘)
var fish=new Fish(‘鲨鱼‘)
var bond=new Bond(‘认股‘)
var m=new Master()
m.feed(cat,fish)
m.feed(dog,bond)

闭包定义
1：与gc是相关的
2:闭实际上涉及到一个对象的成员属性，何时被gc处理
3:如何才能对对象属性形成一个闭包？

function A(){
　　var i=0;
　　function b(){
　　　　alert(i++);
　　}
return b;
}
A();//此时内存中i空间被gc处理
var c=A();//这种用法,gc不会把i当成垃圾
c();输出0
c()输出1，从而证明变量被闭包

系统
内部类
Object,array/math/boolean/string/regexp/data/number

//例子
//math,静态类
alert(Math.abs(-29))
//显示当前日期,动态类
var not1=new Date();
alert(not1.toLocaleDateString())

javascript(js)基础3:.js面向对象三大特征(封装、继承、多态) and 内部类.js系统函数

标签：

原文地址：http://www.cnblogs.com/mhxy13867806343/p/4380515.html