[150823]Js学习笔记

1、Function对象 与其内置的属性。

<script type="text/javascript">

//1、函数的一般创建方法

/*     function say (name,age) {
        this.name=name;
        this.age=age;
        alert("she is " + name + " and age is " + age);
    }
    say("lilyth",8); */
    
    //2、※※※※※※用函数对象的方法new 一个Fuction对象
    var funcObject = new Function ("name","age","alert('she is ' + name + ' and age is ' + age)");
    funcObject("adom",8);
    
</script>

2、Js闭包「closure」的概念及应用。

<script type="text/javascript">
    function test () {
        a = 22;
        var name= "hello";
        
        //闭包是一个函数 内部的接口，这个接口提供 「外部」访问「该函数内部」的「私有变量」的方法。
        function closure () {
            return name;
        }
        
        //返回一个可以被执行的函数对象，在后面加上“()”便可以执行该函数。
        return closure;
    }
    
    //在函数外边调用该私有变量的方法。这是一个「单例工厂设计模式」的体现，※※※内部的变量由内部的接口定义由外边使用※※※。
    //alert("私有变量name=" + test()());

    //除了在一般的函数对象使用闭包以外，还能在基于原型「prototype」的对象中使用
    var object={
            name:"对象里面的变量",
            getFunc:function () {
                //对象里面的函数(or「方法」)的私有变量，本来不能被外界访问。
                var v = 20;
                //对象里面的方法闭包接口，提供内部方法的私有变量的访问权限。
                function getPri() {
                    return v;
                };
                //对象函数提供的闭包接口
                return getPri;
            }
        //访问对象方法里面的函数私有变量
    
    };
    alert("访问对象方法里面的函数私有变量： " + object.getFunc()());
    
</script>

3、Js对象的创建方法，Js模拟java中「类」的实现。

<script type="text/javascript">
    //定义「对象」（不是类，是对象）的方法：直接定义法
    var girl= {
        name:"lilyth",            
        age:8,
        say:function () {
            alert("我是" + this.name + "我" + this.age + "岁了哦" );
        },
        can:function () {
            alert("我会吃");
        }
    };
    //girl已经是一个「实体」。
    girl.say();
    girl.can();
    
    //函数（类）定义对象的方法：函数构造定义法。与java的（类到具体对象的）构造方法差不多。
    //该函数可以定义多个不同的对象，所以这就在js中模拟了「类」的概念。
    function boy (name,age) {
        this.name=name;
        this.age=age;
        this.say=function () {
            alert("我是" + this.name + "我" + this.age + "岁了哦" );
        };
        this.can=function () {
            alert("我会吃");
        };
    }
    //用构造函数定义对象。
    var b = new boy("adom",8);
    b.say();
    b.can();
</script>

4、Js类字段的分类 与 方法的分类。

<script type="text/javascript">
	//Js类的字段(属性)分类：1、对象字段 2、私有字段 3、类字段
	function A () {
		//对象字段定义方法1
		this.field1="对象字段一";
		//对象字段定义方法2:用原型定义
		A.prototype.field2="对象字段二";
		//私有字段定义方法
		var field3="私有字段三";
	}
	//Js类字段定义方法
	A.field4="类字段四";
	
	var a = new A ();
	
	//测试
	alert(a.field1);
	alert(a.field2);
	/* alert(a.field3); 私有字段可以通过闭包获得。*/ 
	alert(A.field4);
	
	//Js类的方法分类：1、对象方法 2、私有方法 3、类方法
	function B () {
		//对象方法定义方法1
		this.fun1=function () {
			alert("对象方法一");
		};
		//对象方法定义方法2:用原型定义
		B.prototype.fun2=function () {
			alert("对象方法二");
		}
		
		//私有方法定义(一般情况下无法被外界访问)
		var privatefun=function () {
			alert("私有方法");
		}
	}
	//类方法定义
	B.classFun=function () {
		alert("类方法");
	}
	
	//Test
	var b = new B ();
	b.fun1();
	b.fun2()
	//b.privatefun(); 执行时Firebug提示TypeError: b.privatefun is not a function
	B.classFun();
	
</script>

5、Js继承与多态的「模拟实现」。

PS:用apply()方法与 prototype实现 Js的继承与多态。

继承的实现：

	function Animal(name,age){
		this.name=name;
		this.age=age;
		this.shout=function(){
			alert("我是："+this.name+",今年："+this.age);
		};
		this.action=function(){
			alert("会吃");
		};
	}
	
	function Dog(name,age){
		Animal.apply(this, [name,age]);
	}
	Dog.prototype=new Animal();
	
	var jack=new Dog("jack",1);
	alert(jack.name);
	alert(jack.age);
	jack.shout();
	jack.action();

多态的实现：

<script type="text/javascript">
	function Animal(){
		this.say=function(){
			alert("我是动物");
		};
	}
	
	function Dog(){
		this.say=function(){
			alert("我是狗");
		};
	}
	Dog.prototype=new Animal();
	
	function Cat(){
		this.say=function(){
			alert("我是猫");
		};
	}
	Cat.prototype=new Animal();
	
	function say(animal){
		if(animal instanceof Animal){
			animal.say();
		}
	}
	
	var dog=new Dog();
	var cat=new Cat();
	say(dog);
	say(cat);
</script>