- 浏览: 452301 次
- 性别:
- 来自: 西安
文章分类
最新评论
-
进退取舍:
谢谢,这个用上了!!
Java 一个线程池的示例 -
pb_water:
感谢楼主,打算买楼主的书,支持一下,楼主功德无量
JavaScript内核系列第0版整理稿下载 -
lancezhcj:
有图会直观的多呢,再摸索摸索
有限自动机与建模 -
hsmsyy:
这里应该是原创了吧,楼主我觉得闭包的作用:实现面向对象。有待商 ...
JavaScript内核系列 第7章 闭包 -
wll52:
在应用退出之前,需要释放连接 con.disconnect() ...
使用smack与GTalk通信
第八章 面向对象的 Javascript
面向对象编程思想在提出之后,很快就流行起来了,它将开发人员从冗长,繁复,难以调试的过程式程序中解放了出来,过程式语 言如 C ,代码的形式往往如此:
Component comp; init_component(& comp, props);
而面向对象的语言如 Java ,则会是这种形式:
Component comp; comp.init(props);
可以看出,方法是对象的方法,对象是方法的对象,这样的代码形式更接近人的思维方式,因此 OO 大行其道也并非侥幸。
JavaScript 本身是基于对象 的,而并非基于类。但是, JavaScript 的函数式语言的特性使得它本身是可编程 的,它可以变成你想要的任何形式。我们在这一章详细讨论如何使用 JavaScript 进行 OO 风格的代码开发。
8.1 原型继承
JavaScript 中的继承可以通过原型链来实现,调用对象上的一个方法,由于方法在 JavaScript 对象中是对另一个函数对象的引用,因此解释器会在对象中查找该属性,如果没有找到,则在其内部对象 prototype 对象上搜索,由于 prototype 对象与对象本身的结构是一样的,因此这个过程会一直回溯到发现该属性,则调用该属性,否则,报告一个错误。关于原型继承,我们不妨看一个小例 子:
function Base(){
this .baseFunc = function (){
print ( "base behavior" );
}
}
function Middle(){
this .middleFunc = function (){
print ( "middle behavior" );
}
}
Middle. prototype = new Base();
function Final(){
this .finalFunc = function (){
print ( "final behavior" );
}
}
Final. prototype = new Middle();
function test(){
var obj = new Final();
obj.baseFunc();
obj.middleFunc();
obj.finalFunc();
}
|
图 原型链的示意图
在 function test 中,我们 new 了一个 Final 对象,然后依次调用 obj.baseFunc ,由于 obj 对象上并无此方法,则按照上边提到的规则,进行回溯,在其原型链上搜索,由于 Final 的原型链上包含 Middle ,而 Middle 上又包含 Base ,因此会执行这个方法,这样就实现了类的继承。
middle behavior
final behavior
但是这种继承形式与传统的 OO 语言大相径庭,初学者很难适应,我们后边的章节会涉及到一个比较好的 JavaScript 的面向对象基础包 Base ,使用 Base 包,虽然编码风格上会和传统的 OO 语言不同,但是读者很快就会发现这种风格的好处。
8.1.1 引用
引用是一个比较有意思的主题,跟其他的语言不同的是, JavaScript 中的引用始终指向最终的对象,而并非引用本身,我们来看一个例子:
var obj = {}; // 空对象
var ref = obj; // 引用
obj. name = "objectA" ;
print ( ref . name ); //ref 跟着添加了 name 属性
obj = [ "one" , "two" , "three" ]; //obj 指向了另一个对象 ( 数组对象 )
print ( ref . name ); //ref 还指向原来的对象
print (obj. length ); //3
print ( ref . length ); //undefined
运行结果如下:
objectA
3
undefined
obj 只是对一个匿名对象的引用,所以, ref 并非指向它,当 obj 指向另一个数组对象时
可以看到,引用 ref 并未改变,而始终指向这那个后来添加了 name 属性的 " 空 " 对象 ”{}” 。理解这一点对后边的内容有很大的帮助。
再看这个例子:
var obj = {}; // 新建一个对象,并被 obj 引用
var ref1 = obj; //ref1 引用 obj, 事实上是引用 obj 引用的空对象
var ref2 = obj;
obj.func = "function" ;
print (ref1.func);
print (ref2.func);
声明一个对象,然后用两个引用来引用这个对象,然后修改原始的对象,注意这两步的顺序,运行之:
function
根据运行结果我们可以看出,在定义了引用之后,修改原始的那个对象会影响到其引用上,这一点也应该注意。
8.1.2 new 操作符
有面向对象编程的基础有时会成为一种负担,比如看到 new 的时候, Java 程序员可能会认为这将会调用一个类的构造器构造一个新的对象出来,我们来看一个例子:
function Shape(type){
this .type = type || "rect" ;
this .calc = function (){
return "calc, " + this .type;
}
}
var triangle = new Shape( "triangle" );
print (triangle.calc());
var circle = new Shape( "circle" );
print (circle.calc());
运行结果如下:
calc, circle
Java 程序员可能会觉得 Shape 就是一个类,然后 triangle , circle 即是 Shape 对应的具体对象,而其实 JavaScript 并非如此工作的,罪魁祸首即为此 new 操作符。在 JavaScript 中,通过 new 操作符来作用与一个函数,实质上会发生这样的动作:
首先,创建一个空对象,然后用函数的 apply 方法,将这个空对象传入作为 apply 的第一个参数,及上下文参数。这样函数内部的 this 将会被这个空的对象所替代:
var triangle = new Shape( "triangle" );
// 上一句相当于下面的代码
var triangle = {};
Shape.apply(triangle, [ "triangle" ]);
8.2 封装
事实上,我们可以通过 JavaScript 的函数实现封装,封装的好处在于未经授权的客户代码无法访问到我们不公开的数据,我们来看这个例子:
function Person(name){
//private variable
var address = "The Earth" ;
//public method
this .getAddress = function (){
return address;
}
//public variable
this .name = name;
}
//public
Person.prototype.getName = function (){
return this .name;
}
//public
Person.prototype.setName = function (name){
this .name = name;
}
首先声明一个函数,作为模板,用面向对象的术语来讲,就是一个类 。用 var 方式声明的变量仅在类内部可见,所以 address 为一个私有成员,访问 address 的唯一方法是通过我们向外暴露的 getAddress 方法,而 get/setName ,均为原型链上的方法,因此为公开的。我们可以做个测试:
var jack = new Person( "jack" );
print(jack.name);//jack
print(jack.getName());//jack
print(jack.address);//undefined
print(jack.getAddress());//The Earth
直接通过 jack.address 来访问 address 变量会得到 undefined 。我们只能通过 jack.getAddress 来访问。这样, address 这个成员就被封装起来了。
另外需要注意的一点是,我们可以为类添加静态成员,这个过程也很简单,只需要为函数对象添加一个 属性即可。比如:
function Person(name){
//private variable
var address = "The Earth" ;
//public method
this .getAddress = function (){
return address;
}
//public variable
this .name = name;
}
Person.TAG = "javascript-core" ;// 静态变量
print(Person.TAG);
也就是说,我们在访问 Person.TAG 时, 不需要实例化 Person 类。这与 传统的面向对象语言如 Java 中的静态变量是一致 的。
8.3 工 具包 Base
Base 是由 Dean Edwards 开发的一个 JavaScript 的 面向对象的基础包, Base 本身很小,只有 140 行,但是这个很小的包对面向对象编程风格有很好的支持,支持类的定义,封装,继承,子类调用 父类的方法等,代码的质量也很高,而且很多项目都在使用 Base 作为底 层的支持。尽管如此, JavaScript 的面向对象风格依然非常古 怪,并不可以完全和传统的 OO 语言对等起来。
下面我们来看几个基于 Base 的例子, 假设我们现在在开发一个任务系统,我们需要抽象出一个类来表示任务,对应的,每个任务都可能会有一个监听器,当任务执行之后,需要通知监听器。我们首先定 义一个事件监听器的类,然后定义一个任务类:
var EventListener = Base.extend({
constructor : function(sense){
this.sense = sense;
},
sense : null,
handle : function(){
print(this.sense+" occured");
}
});
var Task = Base.extend({
constructor : function(name){
this.name = name;
},
name : null,
listener : null,
execute : function(){
print(this.name);
this.listener.handle();
},
setListener : function(listener){
this.listener = listener;
}
});
创建类的方式很简单,需要给 Base.extend 方 法传入一个 JSON 对象,其中可以有成员和方法。方法访问自身的成员时 需要加 this 关键字。而每一个类都会有一个 constructor 的方法,即构造方法。比如事件监听器类 (EventListener) 的构造器需要传入一个字符串,而任务类 (Task) 也需要传入任务的名字来进行构造。好了,既然我们已经有了任务类和事件监听器类,我们 来实例化它们:
var printing = new Task("printing");
var printEventListener = new EventListener("printing");
printing.setListener(printEventListener);
printing.execute();
首先,创建一个新的 Task , 做打印工作,然后新建一个事件监听器,并将它注册在新建的任务上,这样,当打印发生时,会通知监听器,监听器会做出相应的判断:
printing occurred
既然有了基本的框架,我们就来使用这个框架,假设我们要从 HTTP 服务器上下载一个页面,于是我们设计了一个新的任务类型,叫做 HttpRequester :
var HttpRequester = Task.extend({
constructor : function(name, host, port){
this.base(name);
this.host = host;
this.port = port;
},
host : "127.0.0.1",
port : 9527,
execute : function(){
print("["+this.name+"] request send to "+this.host+" of port "+this.port);
this.listener.handle();
}
});
HttpRequester 类继承了 Task ,并且重载了 Task 类 的 execute 方法, setListener 方法的内容与父类一致,因此不需要重载。
var requester = new HttpRequester("requester1", "127.0.0.1", 8752);
var listener = new EventListener("http_request");
requester.setListener(listener);
requester.execute();
我们新建一个 HttpRequester 任 务,然后注册上事件监听器,并执行之:
http_request occured
应该注意到 HttpRequester 类 的构造器中,有这样一个语句:
this.base(name);
表示执行父类的构造器,即将 name 赋 值给父类的成员变量 name ,这样在 HttpRequester 的实例中,我们就可以通过 this.name 来访问这个成员了。这套机制简直与在其他传统的 OO 语言并无二致。同时, HttpRequester 类 的 execute 方法覆盖了父类的 execute 方法,用面向对象的术语来讲,叫做重载。
在很多应用中,有些对象不会每次都创建新的实例,而是使用一个固有的实例,比如提供数据源的服务,报表渲染引擎,事件分发 器等,每次都实例化一个会有很大的开销,因此人们设计出了单例模式,整个应用的生命周期中,始终只有顶多一个实例存在。 Base 同样可以模拟出这样的能力:
var ReportEngine = Base.extend({
constructor : null,
run : function(){
//render the report
}
});
很简单,只需要将构造函数的值赋为 null 即 可。好了,关于 Base 的基本用法我们已经熟悉了,来看看用 Base 还能做点什么:
由于本涨篇幅较长,因此分为两部分 发 布!
附:由于作者本身水平有限,文中难免有纰漏错误等,或者语言本身有不妥当之处,欢迎及时 指正,提出建议,参与讨论,谢谢大家!
评论
不好意思,最近这段时间,刚刚在新公司入职,有很多东西要学习,暂时没有精力来写这个。等后边有时间了,在补充下,如果临时赶制,会影响文档的质量。
你看过精通JavaScript吗?其实你看没看过都无所谓,我不是jQuery之父。
首先,在JavaScirpt中,没有类的概念,比如:
function Shape(type){ this .type = type || "rect" ; this .calc = function (){ return "calc, " + this .type; } }
如果执行环境是客户端,那么此代码只是为window对象添加了一个名为Shape的属性,这个属性的值是一个对象,这个过程中没有类的概念。
这个没问题,从传统oo语言角度看,JS 是没有类的
我困惑的是,这本书的受众定位。从开头举的 C 和 Java 的例子,感觉这一章是写给有传统oo语言背景的读者看的。从这个出发点去写,提到了类,又说 JS 没有类,强调机制不同,但文中并没有深入解释,感觉这样读者更困惑。对于无传统oo语言背景的读者来说,则感觉有点蜻蜓点水,没说到点子上,感觉很不过瘾。
类的定义,我觉得也不必局限于传统oo的解释。类是什么?物以类聚,类的本意是同类,是共性。class 是种类,是分类。类在计算机语言里,是对自然界万事万物,按照属性和行为所进行的抽象。从这个角度讲,JS 里的 function, 已经能表达类的原生含义,为什么不能称呼为类呢?
传统oo语言里的 Class 是类,JS语言里的 function 也是类,只是实现机制不同。
而代码:
var triangle = new Shape( "triangle" ); print (triangle.calc());
不过是对函数使用new操作符:
如此而已,可以看到,整个过程中都是以对象作为流的,这里的new操作符并非实例化一个类。虽然从效果上来看,有点像是这么回事儿。
这个解释不够严格,会导致误解
原文中,“相当于以下两句” 可能会让读者认为 “等价为以下两句”,但实际上是不等价的
new 的过程中,还有原型链的构造过程。这个过程,我觉得就是 JS 里的类的实例化过程。你说的“这里的new操作符并非实例化一个类”,感觉是用传统oo的类的实例化来限定JS语言的实现,概念上有点狭义了
以上是一些个人想法,未必正确,希望对楼主能有所帮助
嗯,你的意见很好,可能跟个人的经历有关,就假想读者写文章的人和我有同样的背景,呵呵。说到传统的OO和JavaScript的一些核心概念的区别,我更倾向于不要进行类比。可是,这一章我自己却列举了C/Java中的例子,诱惑读者进行类比,呵呵。
我会考虑你的建议,并完善这个系列,谢谢。
<div class="quote_div">
<h2>
<a name="_Toc260749009"><span>第八章</span>
</a>
<span><span>面向对象的</span>
<span lang="EN-US">Javascript</span>
</span>
</h2>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span>面向对象编程思想在提出之后,很快就流行起来了,它将开发人员从冗长,繁复,难以调试的过程式程序中解放了出来,过程式语
言如</span>
<span lang="EN-US">C</span>
<span>,代码的形式往往如此:</span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"><span style="font-size: small;"><span style="font-size: 13px;"><br></span></span></p>
<p><span style="font-size: small;">
</span>
</p>
<pre name="code" class="c">Component comp;
init_component(& comp, props);</pre>
<p> </p>
<p class="MsoNormal"><span>而面向对象的语言如</span>
<span lang="EN-US">Java</span>
<span>,则会是这种形式:</span>
</p>
<p class="MsoNormal"><span lang="EN-US"> </span>
</p>
<p><span style="font-size: small;"><span style="text-decoration: underline;">
</span>
</span>
</p>
<pre name="code" class="java">Component comp;
comp.init(props);</pre>
<p> </p>
<p class="MsoNormal"><span>可以看出,方法是对象的方法,对象是方法的对象,这样的代码形式更接近人的思维方式,因此</span>
<span lang="EN-US">OO</span>
<span>大行其道也并非侥幸。</span>
</p>
<p class="MsoNormal"><span lang="EN-US"><span> </span>
JavaScript</span>
<span>本身是<strong>基于对象</strong>
的,而并非基于类。但是,</span>
<span lang="EN-US">JavaScript</span>
<span>的函数式语言的特性使得它本身是<strong>可编程</strong>
的,它可以变成你想要的任何形式。我们在这一章详细讨论如何使用</span>
<span lang="EN-US">JavaScript</span>
<span>进行</span>
<span lang="EN-US">OO</span>
<span>风格的代码开发。</span>
</p>
<h3>
<a name="_Toc260749010"><span lang="EN-US">8.1 </span>
</a>
<span><span>原型继承</span>
</span>
</h3>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span lang="EN-US">JavaScript</span>
<span>中的继承可以通过原型链来实现,调用对象上的一个方法,由于方法在</span>
<span lang="EN-US">JavaScript</span>
<span>对象中是对另一个函数对象的引用,因此解释器会在对象中查找该属性,如果没有找到,则在其内部对象</span>
<span lang="EN-US">prototype</span>
<span>对象上搜索,由于</span>
<span lang="EN-US">prototype</span>
<span>对象与对象本身的结构是一样的,因此这个过程会一直回溯到发现该属性,则调用该属性,否则,报告一个错误。关于原型继承,我们不妨看一个小例
子:</span>
</p>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span lang="EN-US"> </span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"> </p>
<p><span style="font-size: small;"><strong>
</strong>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">function Base(){
this .baseFunc = function (){
print ( "base behavior" );
}
}
function Middle(){
this .middleFunc = function (){
print ( "middle behavior" );
}
}
Middle. prototype = new Base();
function Final(){
this .finalFunc = function (){
print ( "final behavior" );
}
}
Final. prototype = new Middle();
function test(){
var obj = new Final();
obj.baseFunc();
obj.middleFunc();
obj.finalFunc();
}</pre>
</strong></p>
<p><strong><br></strong></p>
<p> </p>
<table style="height: 664px;" border="0" width="186"><tbody><tr>
<td>
<br><img src="http://dl.iteye.com/upload/attachment/244943/271d988b-ae09-31bb-a63f-7b6fc1261c31.png" alt="" width="206" height="479"><br>
</td>
</tr></tbody></table>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span>图</span>
<span style="font-size: 10.0pt;"> </span>
<span>原型链的示意图</span>
</p>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span style="font-size: 10.0pt;" lang="EN-US"> </span>
</p>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span>在</span>
<span style="font-size: 10.0pt;" lang="EN-US">function test</span>
<span>中,我们</span>
<span style="font-size: 10.0pt;" lang="EN-US">new</span>
<span>了一个</span>
<span style="font-size: 10.0pt;" lang="EN-US">Final</span>
<span>对象,然后依次调用</span>
<span style="font-size: 10.0pt;" lang="EN-US">obj.baseFunc</span>
<span>,由于</span>
<span style="font-size: 10.0pt;" lang="EN-US">obj</span>
<span>对象上并无此方法,则按照上边提到的规则,进行回溯,在其原型链上搜索,由于</span>
<span style="font-size: 10.0pt;" lang="EN-US">Final</span>
<span>的原型链上包含</span>
<span style="font-size: 10.0pt;" lang="EN-US">Middle</span>
<span>,而</span>
<span style="font-size: 10.0pt;" lang="EN-US">Middle</span>
<span>上又包含</span>
<span style="font-size: 10.0pt;" lang="EN-US">Base</span>
<span>,因此会执行这个方法,这样就实现了类的继承。</span>
</p>
<p class="MsoNormal"><span style="font-size: small;"><span style="font-size: 13px;"><br></span>
</span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"> </p>
<p><span style="font-size: small;">
</span>
</p>
<div class="quote_div">base behavior<br>
middle behavior<br>
final
behavior</div>
<p> </p>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span>但是这种继承形式与传统的</span>
<span lang="EN-US">OO</span>
<span>语言大相径庭,初学者很难适应,我们后边的章节会涉及到一个比较好的</span>
<span lang="EN-US">JavaScript</span>
<span>的面向对象基础包</span>
<span lang="EN-US">Base</span>
<span>,使用</span>
<span lang="EN-US">Base</span>
<span>包,虽然编码风格上会和传统的</span>
<span lang="EN-US">OO</span>
<span>语言不同,但是读者很快就会发现这种风格的好处。</span>
</p>
<h4>
<a name="_Toc260749011"><span lang="EN-US">8.1.1</span>
</a>
<span><span>引用</span>
</span>
</h4>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span>引用是一个比较有意思的主题,跟其他的语言不同的是,</span>
<span lang="EN-US">JavaScript</span>
<span>中的引用始终指向最终的对象,而并非引用本身,我们来看一个例子:</span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"><strong><span style="font-size: 10.0pt;" lang="EN-US"> </span>
</strong>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"> </p>
<p><span style="font-size: small;"><strong>
</strong>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">var obj = {}; // 空对象
var ref = obj; // 引用
obj. name = "objectA" ;
print ( ref . name ); //ref 跟着添加了 name 属性
obj = [ "one" , "two" , "three" ]; //obj 指向了另一个对象 ( 数组对象 )
print ( ref . name ); //ref 还指向原来的对象
print (obj. length ); //3
print ( ref . length ); //undefined</pre>
</strong></p>
<p><strong><br></strong></p>
<p class="MsoNormal"><span>运行结果如下:</span>
</p>
<p class="MsoNormal"> </p>
<p><span style="font-size: small;">
</span>
</p>
<div class="quote_div">objectA<br>
objectA<br>
3<br>
undefined</div>
<p> </p>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span lang="EN-US">obj</span>
<span>只是对一个匿名对象的引用,所以,</span>
<span lang="EN-US">ref</span>
<span>并非指向它,当</span>
<span lang="EN-US">obj</span>
<span>指向另一个数组对象时</span>
</p>
<p class="MsoNormal"><span>可以看到,引用</span>
<span lang="EN-US">ref</span>
<span>并未改变,而始终指向这那个后来添加了</span>
<span lang="EN-US">name</span>
<span>属性的</span>
<span lang="EN-US">"</span>
<span>空</span>
<span lang="EN-US">"</span>
<span>对象</span>
<span lang="EN-US">”{}”</span>
<span>。理解这一点对后边的内容有很大的帮助。</span>
</p>
<p class="MsoNormal"><span lang="EN-US"><span> </span>
</span>
<span>再看这个例子:</span>
</p>
<p class="MsoNormal"><span lang="EN-US"> </span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"> </p>
<p><span style="font-size: small;"><strong>
</strong>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">var obj = {}; // 新建一个对象,并被 obj 引用
var ref1 = obj; //ref1 引用 obj, 事实上是引用 obj 引用的空对象
var ref2 = obj;
obj.func = "function" ;
print (ref1.func);
print (ref2.func);</pre>
</strong></p>
<p><strong><br></strong></p>
<p class="MsoNormal"><span>声明一个对象,然后用两个引用来引用这个对象,然后修改原始的对象,注意这两步的顺序,运行之:</span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"><span style="font-size: small;"><span style="font-size: 13px;"><strong><br></strong>
</span>
</span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"> </p>
<p><span style="font-size: small;"><strong>
</strong>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<div class="quote_div">function<br>
function</div>
</strong></p>
<p> </p>
<p> </p>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span>根据运行结果我们可以看出,在定义了引用之后,修改原始的那个对象会影响到其引用上,这一点也应该注意。</span>
</p>
<h4>
<a name="_Toc260749012"><span lang="EN-US">8.1.2
new</span>
</a>
<span><span>操作符</span>
</span>
</h4>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span>有面向对象编程的基础有时会成为一种负担,比如看到</span>
<span lang="EN-US">new</span>
<span>的时候,</span>
<span lang="EN-US">Java</span>
<span>程序员可能会认为这将会调用一个类的构造器构造一个新的对象出来,我们来看一个例子:</span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"> </p>
<p><span style="font-size: small;"><strong>
</strong>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">function Shape(type){
this .type = type || "rect" ;
this .calc = function (){
return "calc, " + this .type;
}
}
var triangle = new Shape( "triangle" );
print (triangle.calc());
var circle = new Shape( "circle" );
print (circle.calc());</pre>
</strong></p>
<p> </p>
<p> </p>
<p class="MsoNormal"><span>运行结果如下:</span>
</p>
<p class="MsoNormal"><span style="font-size: small;"><span style="font-size: 13px;"><br></span></span></p>
<p><span style="font-size: small;">
</span>
</p>
<div class="quote_div">calc, triangle<br>
calc, circle</div>
<p> </p>
<p class="MsoNormal"><span style="font-size: 10.0pt;" lang="EN-US">Java</span>
<span>程序员可能会觉得</span>
<span style="font-size: 10.0pt;" lang="EN-US">Shape</span>
<span>就是一个类,然后</span>
<span style="font-size: 10.0pt;" lang="EN-US">triangle</span>
<span>,</span>
<span style="font-size: 10.0pt;" lang="EN-US">circle</span>
<span>即是</span>
<span style="font-size: 10.0pt;" lang="EN-US">Shape</span>
<span>对应的具体对象,而其实</span>
<span style="font-size: 10.0pt;" lang="EN-US">JavaScript</span>
<span>并非如此工作的,罪魁祸首即为此</span>
<span style="font-size: 10.0pt;" lang="EN-US">new</span>
<span>操作符。在</span>
<span style="font-size: 10.0pt;" lang="EN-US">JavaScript</span>
<span>中,通过</span>
<span style="font-size: 10.0pt;" lang="EN-US">new</span>
<span>操作符来作用与一个函数,实质上会发生这样的动作:</span>
</p>
<p class="MsoNormal"><span>首先,创建一个空对象,然后用函数的</span>
<span style="font-size: 10.0pt;" lang="EN-US">apply</span>
<span>方法,将这个空对象传入作为</span>
<span style="font-size: 10.0pt;" lang="EN-US">apply</span>
<span>的第一个参数,及上下文参数。这样函数内部的</span>
<span style="font-size: 10.0pt;" lang="EN-US">this</span>
<span>将会被这个空的对象所替代:</span>
</p>
<p class="MsoNormal"><span style="font-size: 10.0pt;" lang="EN-US"> </span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"> </p>
<p><span style="font-size: small;"><strong>
</strong>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">var triangle = new Shape( "triangle" );
// 上一句相当于下面的代码
var triangle = {};
Shape.apply(triangle, [ "triangle" ]);</pre>
</strong></p>
<p> </p>
<h3>
<a name="_Toc260749013"><span lang="EN-US">8.2</span>
</a>
<span><span>封装</span>
</span>
</h3>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span>事实上,我们可以通过</span>
<span lang="EN-US">JavaScript</span>
<span>的函数实现封装,封装的好处在于未经授权的客户代码无法访问到我们不公开的数据,我们来看这个例子:</span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"><strong><span style="font-size: 10.0pt;" lang="EN-US"> </span>
</strong>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"> </p>
<p><span style="font-size: small;"><strong>
</strong>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">function Person(name){
//private variable
var address = "The Earth" ;
//public method
this .getAddress = function (){
return address;
}
//public variable
this .name = name;
}
//public
Person.prototype.getName = function (){
return this .name;
}
//public
Person.prototype.setName = function (name){
this .name = name;
}</pre>
</strong></p>
<p><strong><br></strong></p>
<p class="MsoNormal"><span>首先声明一个函数,作为模板,用面向对象的术语来讲,就是一个<strong>类</strong>
。用</span>
<span lang="EN-US">var</span>
<span>方式声明的变量仅在类内部可见,所以</span>
<span lang="EN-US">address</span>
<span>为一个私有成员,访问</span>
<span lang="EN-US">address</span>
<span>的唯一方法是通过我们向外暴露的</span>
<span lang="EN-US">getAddress</span>
<span>方法,而</span>
<span lang="EN-US">get/setName</span>
<span>,均为原型链上的方法,因此为公开的。我们可以做个测试:</span>
</p>
<p class="MsoNormal"><span lang="EN-US"> </span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"><span style="font-size: small;"><span style="font-size: 13px;"><strong>
</strong>
</span>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">var jack = new Person( "jack" );
print(jack.name);//jack
print(jack.getName());//jack
print(jack.address);//undefined
print(jack.getAddress());//The Earth</pre>
</strong></p>
<p><strong><br></strong></p>
<p class="MsoNormal"><span>直接通过</span>
<span lang="EN-US">jack.address</span>
<span>来访问</span>
<span lang="EN-US">address</span>
<span>变量会得到</span>
<span lang="EN-US">undefined</span>
<span>。我们只能通过</span>
<span lang="EN-US">jack.getAddress</span>
<span>来访问。这样,</span>
<span lang="EN-US">address</span>
<span>这个成员就被封装起来了。</span>
</p>
<p class="MsoNormal"><span>另外需要注意的一点是,我们可以为类添加静态成员,这个过程也很简单,只需要为函数对象添加一个
属性即可。比如:</span>
</p>
<p class="MsoNormal"><span lang="EN-US"> </span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"><span style="font-size: small;"><span style="font-size: 13px;"><strong>
</strong>
</span>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">function Person(name){
//private variable
var address = "The Earth" ;
//public method
this .getAddress = function (){
return address;
}
//public variable
this .name = name;
}
Person.TAG = "javascript-core" ;// 静态变量
print(Person.TAG);</pre>
</strong></p>
<p> </p>
<p> </p>
<p class="MsoNormal"><span>也就是说,我们在访问</span>
<span style="color: black;">Person.TAG</span>
<span>时,
不需要<strong>实例化</strong>
</span>
<span style="color: black;">Person</span>
<span>类。这与
传统的面向对象语言如</span>
<span style="color: black;">Java</span>
<span>中的静态变量是一致
的。</span>
</p>
<h3>
<a name="_Toc260749014"><span lang="EN-US">8.3 </span>
</a>
<span><span>工
具包</span>
<span lang="EN-US">Base</span>
</span>
</h3>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span lang="EN-US">Base</span>
<span>是由</span>
<span lang="EN-US">Dean
Edwards</span>
<span>开发的一个</span>
<span lang="EN-US">JavaScript</span>
<span>的
面向对象的基础包,</span>
<span lang="EN-US">Base</span>
<span>本身很小,只有</span>
<span lang="EN-US">140</span>
<span>行,但是这个很小的包对面向对象编程风格有很好的支持,支持类的定义,封装,继承,子类调用
父类的方法等,代码的质量也很高,而且很多项目都在使用</span>
<span lang="EN-US">Base</span>
<span>作为底
层的支持。尽管如此,</span>
<span lang="EN-US">JavaScript</span>
<span>的面向对象风格依然非常古
怪,并不可以完全和传统的</span>
<span lang="EN-US">OO</span>
<span>语言对等起来。</span>
</p>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span>下面我们来看几个基于</span>
<span lang="EN-US">Base</span>
<span>的例子,
假设我们现在在开发一个任务系统,我们需要抽象出一个类来表示任务,对应的,每个任务都可能会有一个监听器,当任务执行之后,需要通知监听器。我们首先定
义一个事件监听器的类,然后定义一个任务类:</span>
</p>
<p class="MsoNormal"><span lang="EN-US"> </span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"><span style="font-family: 'Courier New'; color: #7f0055; font-size: small;"><span style="font-size: 13px;"><strong>
</strong>
</span>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">var EventListener = Base.extend({
constructor : function(sense){
this.sense = sense;
},
sense : null,
handle : function(){
print(this.sense+" occured");
}
});
var Task = Base.extend({
constructor : function(name){
this.name = name;
},
name : null,
listener : null,
execute : function(){
print(this.name);
this.listener.handle();
},
setListener : function(listener){
this.listener = listener;
}
});</pre>
</strong></p>
<p><strong><br></strong></p>
<p class="MsoNormal"><span>创建类的方式很简单,需要给</span>
<span lang="EN-US">Base.extend</span>
<span>方
法传入一个</span>
<span lang="EN-US">JSON</span>
<span>对象,其中可以有成员和方法。方法访问自身的成员时
需要加</span>
<span lang="EN-US">this</span>
<span>关键字。而每一个类都会有一个</span>
<span lang="EN-US">constructor</span>
<span>的方法,即构造方法。比如事件监听器类</span>
<span lang="EN-US">(EventListener)</span>
<span>的构造器需要传入一个字符串,而任务类</span>
<span lang="EN-US">(Task)</span>
<span>也需要传入任务的名字来进行构造。好了,既然我们已经有了任务类和事件监听器类,我们
来实例化它们:</span>
</p>
<p class="MsoNormal"><span lang="EN-US"> </span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"><span style="font-family: 'Courier New'; color: #7f0055; font-size: small;"><span style="font-size: 13px;"><strong>
</strong>
</span>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">var printing = new Task("printing");
var printEventListener = new EventListener("printing");
printing.setListener(printEventListener);
printing.execute();</pre>
</strong></p>
<p><strong><br></strong></p>
<p class="MsoNormal"><span>首先,创建一个新的</span>
<span lang="EN-US">Task</span>
<span>,
做打印工作,然后新建一个事件监听器,并将它注册在新建的任务上,这样,当打印发生时,会通知监听器,监听器会做出相应的判断:</span>
</p>
<p class="MsoNormal"> </p>
<p class="MsoNormal" style="text-align: left;" align="left"><span style="font-family: 'Courier New'; font-size: small;"><span style="font-size: 13px;">
</span>
</span>
</p>
<div class="quote_div">printing<br>
printing occurred</div>
<p> </p>
<p class="MsoNormal"><span>既然有了基本的框架,我们就来使用这个框架,假设我们要从</span>
<span lang="EN-US">HTTP</span>
<span>服务器上下载一个页面,于是我们设计了一个新的任务类型,叫做</span>
<span lang="EN-US">HttpRequester</span>
<span>:</span>
</p>
<p class="MsoNormal"><span lang="EN-US"> </span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"><span style="font-family: 'Courier New'; color: #7f0055; font-size: small;"><span style="font-size: 13px;"><strong>
</strong>
</span>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">var HttpRequester = Task.extend({
constructor : function(name, host, port){
this.base(name);
this.host = host;
this.port = port;
},
host : "127.0.0.1",
port : 9527,
execute : function(){
print("["+this.name+"] request send to "+this.host+" of port "+this.port);
this.listener.handle();
}
});</pre>
</strong></p>
<p><strong><br></strong></p>
<p class="MsoNormal"><span lang="EN-US">HttpRequester</span>
<span>类继承了</span>
<span lang="EN-US">Task</span>
<span>,并且重载了</span>
<span lang="EN-US">Task</span>
<span>类
的</span>
<span lang="EN-US">execute</span>
<span>方法,</span>
<span lang="EN-US">setListener</span>
<span>方法的内容与父类一致,因此不需要重载。</span>
</p>
<p class="MsoNormal"><span lang="EN-US"> </span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"><span style="font-family: 'Courier New'; color: #7f0055; font-size: small;"><span style="font-size: 13px;"><strong>
</strong>
</span>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">var requester = new HttpRequester("requester1", "127.0.0.1", 8752);
var listener = new EventListener("http_request");
requester.setListener(listener);
requester.execute();</pre>
</strong></p>
<p><strong><br></strong></p>
<p class="MsoNormal"><span>我们新建一个</span>
<span lang="EN-US">HttpRequester</span>
<span>任
务,然后注册上事件监听器,并执行之:</span>
</p>
<p class="MsoNormal"> </p>
<p class="MsoNormal" style="text-align: left;" align="left"><span style="font-family: 'Courier New'; font-size: small;"><span style="font-size: 13px;">
</span>
</span>
</p>
<div class="quote_div">[requester1] request send to 127.0.0.1 of port
8752<br>
http_request occured</div>
<p> </p>
<p class="MsoNormal"><span>应该注意到</span>
<span lang="EN-US">HttpRequester</span>
<span>类
的构造器中,有这样一个语句:</span>
</p>
<p class="MsoNormal"><span lang="EN-US"> </span>
</p>
<p class="MsoNormal"><span style="font-family: 'Courier New'; color: #7f0055; font-size: small;"><span style="font-size: 13px;"><strong>
</strong>
</span>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">this.base(name);</pre>
</strong></p>
<p> </p>
<p> </p>
<p class="MsoNormal"><span>表示执行父类的构造器,即将</span>
<span lang="EN-US">name</span>
<span>赋
值给父类的成员变量</span>
<span lang="EN-US">name</span>
<span>,这样在</span>
<span lang="EN-US">HttpRequester</span>
<span>的实例中,我们就可以通过</span>
<span lang="EN-US">this.name</span>
<span>来访问这个成员了。这套机制简直与在其他传统的</span>
<span lang="EN-US">OO</span>
<span>语言并无二致。同时,</span>
<span lang="EN-US">HttpRequester</span>
<span>类
的</span>
<span lang="EN-US">execute</span>
<span>方法覆盖了父类的</span>
<span lang="EN-US">execute</span>
<span>方法,用面向对象的术语来讲,叫做重载。</span>
</p>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span>在很多应用中,有些对象不会每次都创建新的实例,而是使用一个固有的实例,比如提供数据源的服务,报表渲染引擎,事件分发
器等,每次都实例化一个会有很大的开销,因此人们设计出了单例模式,整个应用的生命周期中,始终只有顶多一个实例存在。</span>
<span lang="EN-US">Base</span>
<span>同样可以模拟出这样的能力:</span>
</p>
<p class="MsoNormal" style="text-indent: 21.0pt;"><span lang="EN-US"> </span>
</p>
<p class="MsoNormal" style="text-align: left;" align="left"><span style="font-family: 'Courier New'; color: #7f0055; font-size: small;"><span style="font-size: 13px;"><strong>
</strong>
</span>
</span>
</p>
<p><strong>
</strong></p>
<p><strong>
<pre name="code" class="js">var ReportEngine = Base.extend({
constructor : null,
run : function(){
//render the report
}
});</pre>
</strong></p>
<p> </p>
<p class="MsoNormal"><span>很简单,只需要将构造函数的值赋为</span>
<span lang="EN-US">null</span>
<span>即
可。好了,关于</span>
<span lang="EN-US">Base</span>
<span>的基本用法我们已经熟悉了,来看看用</span>
<span lang="EN-US">Base</span>
<span>还能做点什么:</span>
</p>
<p class="MsoNormal"> </p>
<p class="MsoNormal"> </p>
<p class="MsoNormal"><strong>由于本涨篇幅较长,因此分为<span style="color: #ff0000;">两部分</span>
发
布!</strong>
</p>
<p class="MsoNormal"> </p>
<p class="MsoNormal"><span><strong style="font-weight: bold;">附:由于作者本身水平有限,文中难免有纰漏错误等,或者语言本身有不妥当之处,欢迎及时
指正,提出建议,参与讨论,谢谢大家!</strong>
</span>
</p>
<p class="MsoNormal"> </p>
<p class="MsoNormal"> </p>
</div>
<br>
首先,在JavaScirpt中,没有类的概念,比如:
function Shape(type){ this .type = type || "rect" ; this .calc = function (){ return "calc, " + this .type; } }
如果执行环境是客户端,那么此代码只是为window对象添加了一个名为Shape的属性,这个属性的值是一个对象,这个过程中没有类的概念。
这个没问题,从传统oo语言角度看,JS 是没有类的
我困惑的是,这本书的受众定位。从开头举的 C 和 Java 的例子,感觉这一章是写给有传统oo语言背景的读者看的。从这个出发点去写,提到了类,又说 JS 没有类,强调机制不同,但文中并没有深入解释,感觉这样读者更困惑。对于无传统oo语言背景的读者来说,则感觉有点蜻蜓点水,没说到点子上,感觉很不过瘾。
类的定义,我觉得也不必局限于传统oo的解释。类是什么?物以类聚,类的本意是同类,是共性。class 是种类,是分类。类在计算机语言里,是对自然界万事万物,按照属性和行为所进行的抽象。从这个角度讲,JS 里的 function, 已经能表达类的原生含义,为什么不能称呼为类呢?
传统oo语言里的 Class 是类,JS语言里的 function 也是类,只是实现机制不同。
而代码:
var triangle = new Shape( "triangle" ); print (triangle.calc());
不过是对函数使用new操作符:
如此而已,可以看到,整个过程中都是以对象作为流的,这里的new操作符并非实例化一个类。虽然从效果上来看,有点像是这么回事儿。
这个解释不够严格,会导致误解
原文中,“相当于以下两句” 可能会让读者认为 “等价为以下两句”,但实际上是不等价的
new 的过程中,还有原型链的构造过程。这个过程,我觉得就是 JS 里的类的实例化过程。你说的“这里的new操作符并非实例化一个类”,感觉是用传统oo的类的实例化来限定JS语言的实现,概念上有点狭义了
以上是一些个人想法,未必正确,希望对楼主能有所帮助
是重载? Override,一般不是都称之为重写或则覆盖么?
不好意思,是覆盖,并非重载。谢谢你的指正。
紧接着的 new 操作符,“Java 程序员可能会觉得 Shape 就是一个类,然后 triangle , circle 即是 Shape 对应的具体对象,而其实 JavaScript 并非如此工作的”。JS 里的函数对象理解成类好像也没什么不对。虽然实现的机理与传统oo不同,但从表象看,把 triangle 理解成 Shape 的一个实例,也可以的。
var triangle = new Shape('triangle');
应该相当于下面 2 句:
var taingle = {__proto__: Shape.prototype};
Shape.apply(triangle, ['triangle']);
原文中的写法破坏了原型链。
Base, Middle, Final 的写法,直接覆盖 prototype,丢失了 contructor,也存在陷进。
首先,在JavaScirpt中,没有类的概念,比如:
function Shape(type){ this .type = type || "rect" ; this .calc = function (){ return "calc, " + this .type; } }
如果执行环境是客户端,那么此代码只是为window对象添加了一个名为Shape的属性,这个属性的值是一个对象,这个过程中没有类的概念。
而代码:
var triangle = new Shape( "triangle" ); print (triangle.calc());
不过是对函数使用new操作符:
如此而已,可以看到,整个过程中都是以对象作为流的,这里的new操作符并非实例化一个类。虽然从效果上来看,有点像是这么回事儿。
是重载? Override,一般不是都称之为重写或则覆盖么?
紧接着的 new 操作符,“Java 程序员可能会觉得 Shape 就是一个类,然后 triangle , circle 即是 Shape 对应的具体对象,而其实 JavaScript 并非如此工作的”。JS 里的函数对象理解成类好像也没什么不对。虽然实现的机理与传统oo不同,但从表象看,把 triangle 理解成 Shape 的一个实例,也可以的。
var triangle = new Shape('triangle');
应该相当于下面 2 句:
var taingle = {__proto__: Shape.prototype};
Shape.apply(triangle, ['triangle']);
原文中的写法破坏了原型链。
Base, Middle, Final 的写法,直接覆盖 prototype,丢失了 contructor,也存在陷进。
var HttpRequester = Task.extend({ constructor : function(name, host, port){ this.base(name); this.host = host; this.port = port; }, host : "127.0.0.1", port : 9527, execute : function(){ print("["+this.name+"] request send to "+this.host+" of port "+this.port); this.listener.handle(); } });
是从实际项目中提取出来的,还是只是个例子?
呵呵,这个目前还只是一个例子,不能用于发送Http请求,但是如果结合宿主语言的话,应该是可以实现的。我现在也正在研究怎么把JavaScript变得更有用,特别是在其他环境下,而不仅仅局限在客户端。
var HttpRequester = Task.extend({ constructor : function(name, host, port){ this.base(name); this.host = host; this.port = port; }, host : "127.0.0.1", port : 9527, execute : function(){ print("["+this.name+"] request send to "+this.host+" of port "+this.port); this.listener.handle(); } });
是从实际项目中提取出来的,还是只是个例子?
发表评论
-
JavaScript内核系列 第15章 服务器端的JavaScript
2012-02-12 21:39 2325第15章已经在icodeit上发布,这一章分为上/下两篇,请朋 ... -
使用vim开发python及graphviz绘图
2011-12-23 14:49 6457基本需求 使用vim中的autocmd命令可以很容易的将正在 ... -
Java脚本技术应用实例
2011-01-22 11:24 4267前言 一直以来都很喜欢可以自由扩展的软件,这一点应该已经在很 ... -
可编程计算器(phoc)的设计与实现
2011-01-17 11:34 1982前言 借助JavaScript脚本 ... -
函数式编程(javascirpt)
2009-04-18 22:18 1263前言 Javascript,有人称 ... -
C和指针
2009-05-21 23:15 1117前言 指针是C的灵魂,正是指针使得C存在了这么多年,而且将长 ... -
C和指针(续)
2009-05-25 23:41 1359前言 上一篇《C和指针》可能对关于C和指针的有些内容没有说透 ... -
有限自动机与建模
2009-06-06 10:48 1786前言 在学校学程序设计语言的时候,能接触到的所有例子没有一个 ... -
事件和监听器
2009-06-21 22:06 1437前言 事件监听器是经 ... -
基于总线的消息服务(BBMS)的设计与实现
2009-07-25 22:19 1364前言 异步事件的通知机制在比较有规模的软件设计中必然会有涉及 ... -
JavaScript内核系列 第9章 函数式的Javascript
2010-05-13 19:20 3785第九章 函数式的Javascript 要说Ja ... -
JavaScript内核系列 第8章 面向对象的JavaScript(下)
2010-05-06 09:40 3670接上篇:JavaScript内核系列 第8章 面向对象的Jav ... -
JavaScript内核系列 第7章 闭包
2010-05-04 08:48 3874第七章 闭包 闭包向来给包括JavaScript程序 ... -
JavaScript内核系列 第6章 正则表达式
2010-04-27 19:44 4050第六章 正则表达式 正则表达式是对字符串的结构 ... -
JavaScript内核系列 第5章 数组
2010-04-24 15:17 4530第五章 数组 JavaScript的数组也是一个比较 ... -
Swing小应用(Todo-List)之三
2010-04-22 20:47 2135前言 去年9月份开发的那个小工具sTodo,只是做到了能用, ... -
JavaScript内核系列 第4章 函数
2010-04-18 17:31 5093第四章 函数 函数,在C语言之类的过程式语言中 ... -
JavaScript内核系列 第3章 对象与JSON
2010-04-12 09:12 6132第三章 对象与JSON JavaScript对象与传 ... -
JavaScript内核系列 第2章 基本概念
2010-04-03 19:44 5684第二章 基本概念 ... -
JavaScript内核系列 第1章 前言及概述
2010-04-01 23:15 9968前言 从2006年第一次接触JavaScript至今,算来也 ...
相关推荐
后来,考虑到这个脚本语言的推 广,网景采取了一种宣传策略,将LiveScript更名为JavaScript,目的是为了跟当时非常流行的面向对象语言Java发生暧昧的关系。这种 策略显然颇具成效,以至于到现在很多初学者还会为...
Delphi是一种流行的面向对象的编程语言,常常用于创建桌面应用程序。而谷歌内核,即Chromium内核,是Google Chrome浏览器的基础,它提供了一个强大的Web浏览功能的框架。 描述中提到的“直接从官网下载的”,意味着...
C#是一种广泛使用的面向对象的编程语言,它具有丰富的库支持和强大的跨平台能力。将MiniBlink与C#结合,可以让我们在.NET环境中构建原生的浏览器应用,享受C#带来的便捷性和高性能。 开发C# MiniBlink内核浏览器的...
第8章 01 上节课复习 02 软件包介绍 03 rpm软件包管理 04 yum软件包管理 05 源码安装python3.5 06 ssh服务 07 apache服务 08 samba服务 第9章 01 Python开发系列课程概要 02 Python作业要求以及博客 03 编程语言...
2. **数据库模型**:在PHP项目中,数据管理通常是通过ORM(对象关系映射)实现,如Doctrine或Eloquent,这些工具帮助开发者用面向对象的方式来操作数据库。 3. **控制器和视图**:控制器负责处理用户请求,调用业务...
开发者可以利用PHP的面向对象编程特性,实现模块化、可维护性强的代码结构。 2. **杰奇内核**:杰奇小说CMS(Content Management System)是一个专门针对小说网站设计的开源系统,它的内核提供了一套完整的后台管理...
PHP支持面向对象编程,拥有丰富的扩展库,能够方便地与各种数据库系统集成,如MySQL,这使得它成为构建动态网站的首选工具。 【压缩包子文件的文件名称列表】中的"132699553284883400"可能代表一个随机生成的文件ID...
第8章 图像处理中的即时代码生成 第9章 自顶向下的运算符优先级 9.1. JavaScript 9.2. 符号表 9.3. 语素 9.4. 优先级 9.5. 表达式 9.6. 中置运算符 9.7. 前置操作符 9.8. 赋值运算符 9.9. 常数 9.10. Scope 9.11. ...
【标签】"php"表明这个项目的核心是PHP编程,开发者可能需要具备PHP基础知识,如语法、面向对象编程、错误处理、函数库调用等。此外,由于涉及到的是网络电视直播,还需要熟悉PHP在处理HTTP请求、响应、会话管理和...
第4章ActionScript3.0面向对象编程 74 4.1面向对象编程 74 4.1.1对象的世界 74 4.1.2具体与抽象 75 4.2类 75 4.2.1类的定义 76 4.2.2类的属性 78 4.2.3类的方法 80 4.2.4对象成员与静态成员 83 4.2.5this关键字 84 ...
- 类与对象:C#是一种面向对象的语言,浏览器的每个组件,如地址栏、标签页、网页渲染等,都可以通过类来定义。 - 构造函数与析构函数:用于对象的初始化和清理工作。 - 属性和方法:用于定义对象的行为和特性。 ...
开发者需要熟悉.NET框架、类库以及面向对象编程的概念,以便有效地使用ChromiumFX。 2. **Chromium Embedded Framework (CEF)**:ChromiumFX是建立在CEF之上的,所以理解CEF的工作原理很重要。CEF允许开发者将...
第8章 定位与环境感知 133 8.1 位置,位置,位置 133 8.1.1 我在哪里 135 8.1.2 更新位置 137 8.1.3 模拟说明 138 8.2 充分利用传感器 139 8.2.1 了解传感器 139 8.2.2 解析传感器的读数 140 8.2.3 模拟说明...
- 支持面向对象编程,提高了代码可重用性。 - 类型安全性强,减少了运行时错误。 - 无缝集成.NET框架,提供大量内置功能。 #### 七、PHP - **用途**: - Web开发:动态网站和Web应用。 - 服务器端脚本:处理...
JavaScript语法与C++和Java类似,支持函数式、面向对象和命令式编程范式。它能够实时更新网页内容,实现动态效果,如响应式设计、AJAX(异步JavaScript和XML)请求,以及Websocket等。 在Linux环境中,JavaScript...
C#是一种由微软公司推出的面向对象的编程语言,它以其强大的功能、高效性和与.NET框架的紧密集成而闻名。C# Web浏览器通常基于.NET Framework或.NET Core构建,利用Windows Presentation Foundation (WPF)或Windows ...
8. **对象方法**:在面向对象编程中,对象通过发送消息来请求其他对象的服务,这是一种通信机制。 9. **数据库系统**:数据库系统的中心是数据库管理系统(DBMS),它负责管理数据的存储、检索、更新和删除。 10. ...