《Javascript权威指南》学习笔记之八：静态成员、静态类、枚举、重载和覆盖

一、创建静态成员

       直接将属性或者方法赋给类本身

[javascript] view plain copy print ?

1. function Person(name,age) 
2. { 
3.     this.myname = name; 
4.     this.age = age; 
5. } 
6. Person.showInfo = function()               //静态方法，只能访问静态属性 
7. { 
8.     return ("我的性别是："+Person.sex); 
9. }; 
10. var per = new Person("yuan",20); 
11. Person.sex = "男";                         //静态属性 
12. alert(Person.showInfo());

function Person(name,age)
{
	this.myname = name;
	this.age = age;
}
Person.showInfo = function()               //静态方法，只能访问静态属性
{
	return ("我的性别是："+Person.sex);
};
var per = new Person("yuan",20);
Person.sex = "男";                         //静态属性
alert(Person.showInfo());

Google中运行结果：

也可以改为this.sex访问，结果相同。但是不可以用this.myname/this,age访问实例属性。

二 、注意事项

    2.1   静态成员一般是公共成员，不能被继承，但可以在子类中直接使用

    2.2   JS中允许定义同名的静态属性和实例属性，二者互相独立

[javascript] view plain copy print ?

1. function Person(name,age,sex) 
2. { 
3.     this.myname = name; 
4.     this.age = age; 
5.     this.sex = sex; 
6. } 
7. Person.showInfo = function()               //静态方法，只能访问静态属性 
8. { 
9.     return ("我的性别是："+Person.sex); 
10. }; 
11. var per = new Person("yuan",20,"女"); 
12. Person.sex = "男";                         //静态属性 
13. alert(Person.showInfo()); 

function Person(name,age,sex)
{
	this.myname = name;
	this.age = age;
	this.sex = sex;
}
Person.showInfo = function()               //静态方法，只能访问静态属性
{
	return ("我的性别是："+Person.sex);
};
var per = new Person("yuan",20,"女");
Person.sex = "男";                         //静态属性
alert(Person.showInfo());

运行结果：

    2.3    静态方法中不能访问实例属性，且不能使用关键字super,但是实例方法可以访问静态属性和实例属性

[javascript] view plain copy print ?

1. function Person(name,age,sex) 
2. { 
3.     this.myname = name; 
4.     this.age = age; 
5.     this.sex = sex; 
6. } 
7. Person.prototype.showInfo = function()               //静态方法，只能访问静态属性 
8. { 
9.     return ("我的性别是："+Person.sex+"\n我的年龄是："+this.age); 
10. }; 
11. var per = new Person("yuan",20,"女"); 
12. Person.sex = "男";                         //静态属性 
13. alert(per.showInfo()); 

function Person(name,age,sex)
{
	this.myname = name;
	this.age = age;
	this.sex = sex;
}
Person.prototype.showInfo = function()               //静态方法，只能访问静态属性
{
	return ("我的性别是："+Person.sex+"\n我的年龄是："+this.age);
};
var per = new Person("yuan",20,"女");
Person.sex = "男";                         //静态属性
alert(per.showInfo());

运行结果：

    2.4    如果一个类的成员全是静态成员，则这个类是静态类，不能被实例化。

三 、枚举：一组静态常量

[javascript] view plain copy print ?

1. function Day() 
2. { 
3.     throw new Error("这是静态类，不能实例化"); 
4. } 
5. Day.MONDAY = 1; 
6. Day.TUE = 2; 
7. Day.WED = 3; 
8.  
9. var date = new Date(); 
10. var day = date.getDay(); 
11. switch(day) 
12. { 
13.     case Day.MONDAY: 
14.     alert("周一"); 
15.     break; 
16.     case Day.TUE: 
17.     alert("周二"); 
18.     break; 
19.     case Day.WED: 
20.     alert("周三"); 
21.     break; 
22. } 

function Day()
{
	throw new Error("这是静态类，不能实例化");
}
Day.MONDAY = 1;
Day.TUE = 2;
Day.WED = 3;

var date = new Date();
var day = date.getDay();
switch(day)
{
	case Day.MONDAY:
	alert("周一");
	break;
	case Day.TUE:
	alert("周二");
	break;
	case Day.WED:
	alert("周三");
	break;
}

四、重载和覆盖

    4.1   重载：在JS中，不允许有两个同名的方法，且参数没有数据类型，所以JS中的重载是通过参数的个数不同实现的

[javascript] view plain copy print ?

1. function OverLoad() 
2. { 
3.     this.method = function() 
4.     { 
5.         var len =  arguments.length; 
6.         if(len == 2) 
7.         { 
8.             document.write("正在调用的是两个参数的方法<br/>"); 
9.         } 
10.         else if(len == 3) 
11.         { 
12.             document.write("正在调用的是三个参数的方法"); 
13.         } 
14.     } 
15. } 
16. try 
17. { 
18.     var over = new OverLoad; 
19.     over.method(1,2); 
20.     over.method(1,2,3); 
21. } 
22. catch(err) 
23. { 
24.     document.write(err); 
25. } 

function OverLoad()
{
	this.method = function()
	{
		var len =  arguments.length;
		if(len == 2)
		{
			document.write("正在调用的是两个参数的方法<br/>");
		}
		else if(len == 3)
		{
			document.write("正在调用的是三个参数的方法");
		}
	}
}
try
{
	var over = new OverLoad;
	over.method(1,2);
	over.method(1,2,3);
}
catch(err)
{
	document.write(err);
}

运行结果

    4.2   覆盖：用于继承中，指子类中定义了与父类中同名的方法，父类的同名方法被隐藏

[javascript] view plain copy print ?

1. //父类 
2. function Father(myName,age) 
3. { 
4.     this.myname = myName; 
5.     this.age = age; 
6. } 
7. Father.prototype.show = function() 
8. { 
9.     return("Father's name: "+this.myName+", and age: "+this.age); 
10. }; 
11.  
12. //子类 
13. function Child(myName,age) 
14. { 
15.     this.$super = Father;     //继承父类 
16.     this.$super(myName,age);  //调用父类的构造方法 
17.     this.show = function() 
18.     { 
19.         return ( "Child's age: "+this.age); 
20.     }; 
21. } 
22. Child.prototype = new Father(); 
23. var child = new Child("yuan",20); 
24. alert(child.show()); 

//父类
function Father(myName,age)
{
	this.myname = myName;
	this.age = age;
}
Father.prototype.show = function()
{
	return("Father's name: "+this.myName+", and age: "+this.age);
};

//子类
function Child(myName,age)
{
	this.$super = Father;     //继承父类
	this.$super(myName,age);  //调用父类的构造方法
	this.show = function()
	{
		return ( "Child's age: "+this.age);
	};
}
Child.prototype = new Father();
var child = new Child("yuan",20);
alert(child.show());

运行结果：