Beyond the dream——飛雪飄寒
————磨難不過是人生鍵盤的回車。。。。。。
posts - 73, comments - 220, trackbacks - 29, articles - -1
博客园
::
首页
:: ::
联系
::
订阅
::
管理
javascript 面向对象编程(续)
Posted on 2006-11-18 18:32
飛雪飄寒
阅读(243)
评论(0)
编辑
收藏
所属分类:
Javascript
Jscript中内置了一些类,例如String、Array、Math等,用户可以直接从这些类实例化出对象,并使用其中的属性和方法。单凭这一点,不能说js符合面向对象语言的特征。一种面向对象的语言,应当具有封装,继承,多态等基本特性。Jscript并没有直接提供实现这些特性的方法,但是,也并非完全无法实现。
一、Js中的封装
一种面向对象的语言应当允许用户创建自定义类型,这一点js做到了,只是它的自定义类型不是用class限定,而是作为function,这个function的作用相当于其他语言中的构造函数。在自定义类型中,用户可以添加属性、方法。但是,js中并未显式提供public、private、protected等访问限定,也没有提供static之类的作用域限定。下面通过几个例子,逐一说明创建自定义类型及实现各种限定的方法。
示例1-1:该例子演示了创建及使用包含属性和方法的自定义类型的过程。本例子中,我们创建了一个名为MyClass的类,其中包含了一个Name属性和一个showName方法,然后将这个类实例化,即可调用其中的方法,使用其中的属性。注意,在类中定义的方法和属性应当使用this关键字绑定到这个类,调用时使用绑定名字来访问,而不是通过实际名字。
1
<
html
>
2
<
head
>
3
<
script language
=
"
Jscript
"
>
4
<!--
5
function
MyClass(name)
6
{
7
this
.Name
=
name;
8
this
.showName
=
writeName;
9
10
function
writeName()
11
{
12
document.write(
this
.Name);
13
document.write(
"
<br />
"
);
14
}
15
}
16
-->
17
</
script
>
18
</
head
>
19
<
body
>
20
<
script language
=
"
Jscript
"
>
21
<!--
22
var
myClass
=
new
MyClass(
"
Tom
"
);
23
myClass.showName();
24
document.write(myClass.Name);
//
show "Tom"
25
document.write(
"
<br />
"
);
26
myClass.Name
=
"
Jerry
"
;
27
myClass.showName();
//
show "Tom" "Jerry"
28
-->
29
</
script
>
30
</
body
>
31
</
html
>
示例1-2:该例子演示了public和private访问限定的实现。本例子中,我们修改了上个例子中的MyClass类,将其扩充为两个属性和两个方法。注意到PrivateName的声明,它并没有绑定到这个类,因此只具有局部作用域,生命期仅在本类中,如果在类的方法中调用它的话,是可以正常调用的(调用的时候不加this关键字)。同理,没有绑定的方法也只能在类的内部调用。因此,js中的public与private限定可以通过这种方式来实现。
1
<
html
>
2
<
head
>
3
<
script language
=
"
Jscript
"
>
4
<!--
5
function
MyClass(pubName, privName)
6
{
7
var
PrivateName
=
privName;
8
this
.PublicName
=
pubName;
9
this
.showName
=
writePublicName;
10
11
function
writePublicName()
12
{
13
document.write(
this
.PublicName);
14
document.write(
"
<br />
"
);
15
//
document.write(PrivateName);
16
}
17
18
function
writePrivateName()
19
{
20
document.write(PrivateName);
21
document.write(
"
<br />
"
);
22
}
23
24
//
writePrivateName();
25
}
26
-->
27
</
script
>
28
</
head
>
29
<
body
>
30
<
script language
=
"
Jscript
"
>
31
<!--
32
var
myClass
=
new
MyClass(
"
Tom
"
,
"
Cat
"
);
33
document.write(myClass.PublicName);
34
document.write(
"
<br />
"
);
35
//
document.write(myClass.PrivateName);
36
myClass.showName();
37
//
myClass.writePrivateName();
38
myClass.PublicName
=
"
Jerry
"
;
39
myClass.showName();
40
document.write(
"
<br />
"
);
41
-->
42
</
script
>
43
</
body
>
44
</
html
>
在这里,需要注意到一个现象,既然js把类本身作为一个构造函数,它在实例化的时候将逐个执行其中的语句,保留其中的方法定义,一直把整个函数执行完。因此,本例子中注释掉的writePrivateName();语句如果正常执行,将在MyClass类实例化的时候运行。
示例1-3:该例子演示了static限定的实现。本例子中,我们将MyClass类修改为带一个普通属性、一个静态属性和两个静态方法的类。这个类可以被实例化,所能够访问的仅仅是在类中定义的普通属性。当不实例化,通过类名访问的时候,可以访问类中的静态方法和静态属性,静态方法只能访问静态属性。与C++类似,静态成员的初始化需要在类的外面进行。
1
<
html
>
2
<
head
>
3
<
script language
=
"
Jscript
"
>
4
<!--
5
function
MyClass()
6
{
7
this
.Name
=
"
Cat
"
;
8
}
9
10
MyClass.Number
=
0
;
11
12
MyClass.addNumber
=
function
()
13
{
14
MyClass.Number
++
;
15
document.write(
"
One had been added to Number.
"
);
16
document.write(
"
<br />
"
);
17
}
;
18
19
MyClass.showNumber
=
function
()
20
{
21
MyClass.addNumber();
22
document.write(MyClass.Number);
23
document.write(
"
<br />
"
);
24
//
document.write(MyClass.Name);
25
}
;
26
-->
27
</
script
>
28
</
head
>
29
<
body
>
30
<
script language
=
"
Jscript
"
>
31
<!--
32
MyClass.addNumber();
33
MyClass.showNumber();
34
var
myClass
=
new
MyClass();
35
document.write(myClass.Name);
36
document.write(
"
<br />
"
);
37
//
document.write(myClass.Number);
38
-->
39
</
script
>
40
</
body
>
41
</
html
>
通过以上三个示例,我们能够看出,js很好地支持了封装,并且支持了基本的访问限定。
二、Js中的继承
继承是面向对象语言中扩展已有类型的一种有效途径,js没有提供用于实现继承的extends关键字或者“:”操作符,但是,由于它是一种动态语言,可以在需要的时候添加属性和方法。以下示例中继承机制的实现均基于这种原理。
示例2-1:该例子演示了从基类派生出一个子类的方法。子类中创建了基类的对象,为它添加了新的属性和方法,然后将它作为子类构造函数的结果返回出去,得到子类对象。子类对象比基类对象多了一些属性和方法,分配到了更多内存空间。注意到每次输出的constructor属性的值,发现它们两次返回的都是基类的构造函数,这并不奇怪,因为子类的构造函数最后返回的是添加了新属性、新方法的基类对象,js执行环境仍然会认为它是一个基类对象。
1
<
html
>
2
<
head
>
3
<
script language
=
"
Jscript
"
>
4
<!--
5
function
BaseClass(name)
6
{
7
this
.TypeName
=
name;
8
this
.writeBaseName
=
writeBaseName;
9
10
function
writeBaseName()
11
{
12
document.write(
"
Base Name:
"
);
13
document.write(
this
.TypeName);
14
document.write(
"
<br />
"
);
15
}
16
}
17
18
function
DeriveClass(name)
19
{
20
var
base
=
new
BaseClass(
"
Cat
"
);
21
base.Name
=
name;
22
base.writeDeriveName
=
writeDeriveName;
23
24
function
writeDeriveName()
25
{
26
document.write(
"
Derived Name:
"
);
27
document.write(base.Name);
28
document.write(
"
<br />
"
);
29
30
}
31
32
return
base;
33
}
34
-->
35
</
script
>
36
</
head
>
37
<
body
>
38
<
script language
=
"
Jscript
"
>
39
<!--
40
var
cat
=
new
DeriveClass(
"
Tom
"
);
41
cat.writeBaseName();
42
cat.writeDeriveName();
43
-->
44
</
script
>
45
</
body
>
46
</
html
>
示例2-2:该例子演示了从两个不同基类派生出一个子类的方法。子类中分别创建了两个基类的对象,将其中一个的所有属性和方法添加到另外一个上,然后将后者作为子类构造函数的结果返回出去,得到子类对象。通过这种途径,变相地实现了多重继承。这里有一个注意点,不同的基类中如果包含同名变量或方法,需要自己指定以哪个作为实际绑定。
1
<
html
>
2
<
head
>
3
<
script language
=
"
Jscript
"
>
4
<!--
5
function
Apple()
6
{
7
this
.SmellLike
=
"
Apple
"
;
8
this
.showSmell
=
showSmell;
9
10
function
showSmell()
11
{
12
document.write(
"
Smell like:
"
);
13
document.write(
this
.SmellLike);
14
document.write(
"
<br />
"
);
15
}
16
}
17
18
function
Pear()
19
{
20
this
.TasteLike
=
"
Pear
"
;
21
this
.showTaste
=
showTaste;
22
23
function
showTaste()
24
{
25
document.write(
"
Taste like:
"
);
26
document.write(
this
.TasteLike);
27
document.write(
"
<br />
"
);
28
}
29
}
30
31
function
ApplePear()
32
{
33
var
result
=
new
Apple();
34
var
pear
=
new
Pear();
35
result.TasteLike
=
pear.TasteLike;
36
result.showTaste
=
pear.showTaste;
37
38
return
result;
39
}
40
-->
41
</
script
>
42
</
head
>
43
<
body
>
44
<
script language
=
"
Jscript
"
>
45
<!--
46
var
applePear
=
new
ApplePear();
47
applePear.showSmell();
48
applePear.showTaste();
49
-->
50
</
script
>
51
</
body
>
52
</
html
>
通过以上两个示例能够看出,js其实支持了继承的机制,只不过这种机制需要更多的手工控制。
既然提到继承,顺便讨论一下protected限定,它的作用是使得被限定的变量或方法不能被类的实例调用,但是能够被派生类调用。写这篇文章的时候本人曾经花了不少时间来考虑是否有可能使用js模拟出这种限定,后来发现,既然public跟private限定是通过指定绑定来实现的,那么,没法创建一种介于绑定和不绑定之间的关系,也就不好用这种方式模拟。再转念一想,protected限定几乎都是实现在编译型的语言中。在目标代码或者中间代码层次,这种限定非常重要,它能够有效配合软件工程理论进行开发,但是js是纯解释型语言,源代码公开的级别,不存在有效的模块保护机制,任何人可以随意修改代码,这样,protected关键字完全没有用武之地。
C++等语言拥有一种特殊类:接口。接口的作用是为类提供规范、约束,它规定了继承这个接口所必须实现的方法集合。我们当然可以实现这样一个机制,当类继承接口的时候,检查它是否实现了接口中的全部方法,或者是否提供了这些方法的声明,但这种做法并不必要。当继承这个接口的时候,根据上面实现的这种继承机制,将会直接创建接口的一个对象(有的语言中禁止把接口实例化),这个时候,它已经包含了接口中所定义的方法集合,即使不重新定义这些方法并绑定,他们显然已经被声明了,而且,js不提供一个机制用于识别抽象方法,接口中的方法是否已被实现也无从得知。
三、Js中的多态
多态能够让对象在运行时决定实际调用的方法体。由于js是一种动态语言,支持运行时绑定,讨论它的多态实际上并没有太大意义。Js不支持virtual关键字,而virtual关键字在现在的js里面也不会有明显用处。最根本的一点,js能够在运行时改变数据类型,可以随时根据新类型来取得它所拥有的方法,而忽视原有类型的影响。
示例3-1:该例子创建了一个基类跟一个子类,拥有一个同名方法,分别将基类和子类实例化并调用这个方法,显示的结果将随着方法所属类的不同而不同。原因很简单,因为例子使用的这种“继承”机制本身就是利用js语言的动态特性实现的,在一个类实例化的时候,它已经知道自己拥有哪些方法,而且,它也不关心这些方法从哪个类继承,只是将它们作为普通的成员方法来调用,所以,每一个类调用的同名方法都是属于自己的那个。再者,js是弱类型语言,它的变量声明的时候并不知道自己的类型,也并不知道将要被初始化成什么类型,赋予它什么类型的值,它就是什么类型的变量。本例子中分别注释掉的两段语句就说明了这个问题:Js在运行时既能够将子类变量赋给基类变量(这个特性在C++等语言中正是实现多态的关键),也可以将基类变量赋给子类变量(一般在静态语言中不允许,因为缺少附加信息)。
1
<
html
>
2
<
head
>
3
<
script language
=
"
Jscript
"
>
4
<!--
5
function
BaseClass(name)
6
{
7
this
.TypeName
=
name;
8
this
.writeName
=
writeName;
9
10
function
writeName()
11
{
12
document.write(
"
Base Name:
"
);
13
document.write(
this
.TypeName);
14
document.write(
"
<br />
"
);
15
document.write(
this
.constructor);
16
document.write(
"
<br />
"
);
17
}
18
}
19
20
function
DeriveClass(name)
21
{
22
var
base
=
new
BaseClass(
"
Cat
"
);
23
base.Name
=
name;
24
base.writeName
=
writeName;
25
26
function
writeName()
27
{
28
document.write(
"
Derived Name:
"
);
29
document.write(base.Name);
30
document.write(
"
<br />
"
);
31
document.write(
this
.constructor);
32
document.write(
"
<br />
"
);
33
}
34
35
return
base;
36
}
37
-->
38
</
script
>
39
</
head
>
40
<
body
>
41
<
script language
=
"
Jscript
"
>
42
<!--
43
var
base
=
new