我建了一个10行2列的grid的表格;我想让某一行或多行的两列合并成一列,其余的还是两列;不知,有哪位兄弟做过?

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

在Hello.gwt.xml里加上 <stylesheet src='Hello.css'/>

<link  rel= "stylesheet "  href= "Hello.css "  type= "Hello/css ">

里的type有问题，改成 text/css，
还是不行的话检查一下 href 引用路径是否正确。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

<center>
<div style="width:400px;" >
<div style='position:absolute;padding-left:100px;text-align:right;color:red'>hello</div>
<p></p>
</div>
</center>

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

引自:http://kuangbaoxu.javaeye.com/blog/194437

 关键字: 深入理解css中的position定位和z-index属性

注：本文仅供交流使用，如有不当之处欢迎批评指正，但请注明详由，谢谢！

由于平时不太用到，所以过去写css的时候对于position属性的absolute、relative值理解比较模糊，对于z-index的层叠更是摸不着头脑，除了理解的因素外，各个浏览器的不同解析结果也是一个大问题。今天仔细阅读了一下css文档，总算是对盒模型的浮动、定位有了比较深刻的理解。

我们在实践中很有可能遇到这样的问题：
1、做一个横向导航，然后鼠标经过之后出现下拉菜单，那么这个下拉菜单的位置控制就是一个关键；
2、我们想在一个正常的页面布局中放入几个浮在页面上的气泡提示，这时既不想让气泡提示破坏正常的文档布局，又不想气泡提示的定位在不同的浏览器中到处乱飘。
3、当我们在一句正常的文本中插入一个小图标的话，一般会使用<img />标签，而这时它的垂直居中问题又是让人困惑，无论你使用html属性absmiddle、或是使用css属性vertical-align、抑或是使用父对象的heigh + line-height，在不同的浏览器中总会看起来不同。

嗯，上面几个问题你是否也遇到过呢？如果你至今还没有一个很好的解决办法，不妨继续阅读此文，或许能对你有所帮助：）

我们先看一下position属性的几个取值定义：
position: static、absolute、relative

static : 默认值。如果没有指定position属性，支持position属性的html对象都是默认为static，可以这么理解：把html页面看作一个文档流，源代码中各个标签的先后位置就是它们所对应的对象的呈现次序，所有取值为static的对象都按照你所编写的html标签的顺序依次呈现。
如下图所示，这是一个常见的指定了float:left;的横向导航：


relative: 相对定位。这个属性值保持对象所在文档流中的位置，也就是说它具有和static相同的呈现方式，它同样占有在文档流中的固定位置，后面的对象不会侵占或覆盖；与static属性值不同的是，设置了relative的对象，可以通过top, left, right, bottom属性设定自己的新显示位置，这4个属性的取值是相对于文档流的前一个对象的，你可以自由设置这4个属性偏移到新的位置而不对文档流中的其他对象产生任何影响，原来的页面呈现仍然会我行我素：


absolute: 绝对定位。和relative不同的是，这个属性值会将当前对象拖出文档流，后面的对象会占有原来的位置，也就是说，当前对象的呈现是独立显示的，但是它的位置在指定top, left, right, bottom任一属性之前仍是有继承性的，这时的4个属性的取值是相对于浏览器的，和文档流无关了。如果把示例中的B区域设定为absolute而不指定4个位置属性，通过设定margin来改变它的相对位置，用这个方法可以解决前面提到的问题2。


提示a: 苏昱的css2.0手册中提到relative和absolute定位的滚动条区别不是绝对的，至少在firefox、opera和safari中滚动条该出现还是会出现。

提示b: 属性值为absolute对象的z-index属性可以设置层叠显示的次序，它是直接有效的；
而属性值为relative对象的z-index属性在设置时要小心，把当前对象的z-index设置为-1是不行的，在firefox中它会无法显示（注意，不是说浏览器有误，而是指如果父对象是根元素body，那么z-index是无效的，任何z-index设置都不会显示在根元素之后，除了IE的解析bug，感谢#19提示），必须设置为0以上，我们如果想让别的对象挡住它，只有将其他对象也设置position为relative，并将z-index属性取一个比它大的值即可。

上面的表述不知道也许不是很清晰，具体的理解还是要自己亲自动手操作一下。

这样看来，前面的问题就有解了，问题3我们可以根据设计的要求将其设置为相对或绝对定位；
问题1的解决方法也有很多，个人推荐使用有语义的dl, dt, dd来实现，而且这个方法在不同浏览器中的表现基本相同（已在ie, firefox, opera, safari中测试），仅在top的属性上有几像素的差异，由于时间关系我只能给出自己测试时的代码以供参考：

Java代码

1. body {   
2. color:#fff;   
3. font-size:12px;   
4. }   
5. ul li {   
6. float:left;   
7. height:30px;   
8. background-color:#99CC99;   
9. margin:0 10px;   
10. padding:0;   
11. border:1px solid #c30;   
12. width:100px;   
13. }   
14. ul li div {   
15. border:1px solid #f00;   
16. background-color:#996666;   
17. width:100px;   
18. height:100px;   
19. position:absolute;   
20. margin-top:15px;   
21. margin-left:-1px;   
22. *margin-left:-79px;   
23. }   
24. ul li dl,   
25. ul li dl dt,   
26. ul li dl dd {   
27. margin:0;   
28. padding:0;   
29. }   
30. ul li dl dd {   
31. border:1px solid #f00;   
32. background-color:#996666;   
33. width:100px;   
34. height:100px;   
35. position:absolute;   
36. margin-top:11px;   
37. *margin-top:10px;   
38. margin-left:-1px;   
39. }   
40. <ul>   
41. <li>  

body {
color:#fff;
font-size:12px;
}
ul li {
float:left;
height:30px;
background-color:#99CC99;
margin:0 10px;
padding:0;
border:1px solid #c30;
width:100px;
}
ul li div {
border:1px solid #f00;
background-color:#996666;
width:100px;
height:100px;
position:absolute;
margin-top:15px;
margin-left:-1px;
*margin-left:-79px;
}
ul li dl,
ul li dl dt,
ul li dl dd {
margin:0;
padding:0;
}
ul li dl dd {
border:1px solid #f00;
background-color:#996666;
width:100px;
height:100px;
position:absolute;
margin-top:11px;
*margin-top:10px;
margin-left:-1px;
}
<ul>
<li>

标题 - #text
<div>
下拉菜单 - div

Java代码

1. </div>   
2. </li>   
3. <li style="position:relative;">列表b</li>   
4. <li>列表c</li>   
5. <li>   
6. <dl>   
7. <dt>标题 - dt</dt>   
8. <dd>下拉菜单 - dd</dd>   
9. </dl>   
10. </li>   
11. </ul>  

</div>
</li>
<li style="position:relative;">列表b</li>
<li>列表c</li>
<li>
<dl>
<dt>标题 - dt</dt>
<dd>下拉菜单 - dd</dd>
</dl>
</li>
</ul>

补充一个例子，请在IE和非IE浏览器中对比观看：

Java代码

1. <style>   
2. .main {   
3. width:500px;   
4. height:500px;   
5. background-color:#9cf;   
6. }   
7. .layer_a,   
8. .layer_b,   
9. .layer_c,   
10. .layer_d {   
11. position:absolute;   
12. width:100px;   
13. height:60px;   
14. }   
15. .layer_a {   
16. background-color:#69c;   
17. }   
18. .layer_b {   
19. background-color:#369;   
20. }   
21. .layer_c {   
22. background-color:#eee;   
23. }   
24. .layer_d {   
25. background-color:#696;   
26. }   
27. .brd {   
28. border:1px solid #c30;   
29. margin:1em;   
30. }   
31. .block {   
32. display:block;   
33. }   
34. </style>   
35. <div class="main">   
36. <div class="brd">一段文本一段文本一段文本一段文本一段文本一段文本一段文本<div class="layer_a"></div></div>   
37.   
38. <div class="brd">另一段文本另一段文本另一段文本<div class="layer_b"></div></div>   
39. <p class="brd">第三段不同的文本第三段不同的文本<div class="layer_c"></div></p>   
40. <p class="brd block">第四段指定了block的文本<div class="layer_d"></div></p>   
41. <a href="" class="brd">第四段指定了block的文本<div class="layer_c"></div></a>   
42. <map class="brd block">第四段指定了block的文本<div class="layer_d"></div></map>   
43. <dd class="brd">第四段指定了block的文本<div class="layer_a"></div></dd>   
44. <li class="brd">第四段指定了block的文本<div class="layer_b"></div></li>   
45.   
46. </div>  

<style>
.main {
width:500px;
height:500px;
background-color:#9cf;
}
.layer_a,
.layer_b,
.layer_c,
.layer_d {
position:absolute;
width:100px;
height:60px;
}
.layer_a {
background-color:#69c;
}
.layer_b {
background-color:#369;
}
.layer_c {
background-color:#eee;
}
.layer_d {
background-color:#696;
}
.brd {
border:1px solid #c30;
margin:1em;
}
.block {
display:block;
}
</style>
<div class="main">
<div class="brd">一段文本一段文本一段文本一段文本一段文本一段文本一段文本<div class="layer_a"></div></div>

<div class="brd">另一段文本另一段文本另一段文本<div class="layer_b"></div></div>
<p class="brd">第三段不同的文本第三段不同的文本<div class="layer_c"></div></p>
<p class="brd block">第四段指定了block的文本<div class="layer_d"></div></p>
<a href="" class="brd">第四段指定了block的文本<div class="layer_c"></div></a>
<map class="brd block">第四段指定了block的文本<div class="layer_d"></div></map>
<dd class="brd">第四段指定了block的文本<div class="layer_a"></div></dd>
<li class="brd">第四段指定了block的文本<div class="layer_b"></div></li>

</div>

从这个例子可以看出，IE将一个块元素绝对定位时，如果父元素是一个块级元素，那么拖出文档流之后它仍会继承原来所在位置的坐标；
而非IE浏览器的做法是：拖出文档流之后，直接定位到父元素所在的坐标。

z-index 属性简介

z-index : auto | number
auto: 默认值。
number: 无单位的整数值，可为负数 。

z-index 值较大的元素将叠加在 z-index 值较小的元素之上。对于未指定此属性的定位对象，z-index 值为正数的对象会在其之上，而 z-index 值为负数的对象在其之下。

注意：这个属性不会作用于窗口控件，如 select 对象。在IE5.5+中， iframe 对象开始支持此属性。而在之前的浏览器版本中， iframe 对象是窗口控件，会忽略此属性。

z-index 属性适用于定位元素（position 属性值为 relative 或 absolute 或 fixed的对象），用来确定定位元素在垂直于显示屏方向（称为Z 轴）上的层叠顺序（stack order）。

每一个定位元素都归属于一个stacking context。根元素形成 root stacking context，而其他的 stacking context 则由定位元素产生（此定位元素的 z-index 被定义一个非 auto 的 z-index 值），定位子元素会以这个 local stacking context 为参考，用相同的规则来决定层叠顺序。并且 stacking context 和 containing block 之间并没有必然联系。

当 stacking context 一样的时候，就用 z-index 的值来决定怎样显示，如果 z-index 也相同（即 stack level 相同），则按照档中后来者居上的原则（back-to-front ）的顺序来层叠。

当任何一个元素层叠另一个包含在不同 stacking context 元素时，则会以 stacking context 的层叠级别（stack level）来决定显示的先后情况。也就是说，在相同的 stacking context 下才会用 z-index 来决定先后，不同时则由 stacking context 的 z-index 来决定。例如：

定位元素 A（z-index:100）里面有定位元素 A1（z-index:300），而定位元素 B 和元素 A 兄弟关系（z-index:200）。你会发现无论 A1 的 z-index 是多大，也会被 z-index 是 200 的 B 所覆盖，因为 A 的 z-index 只有 100。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

引自:http://code.google.com/apis/calendar/developers_guide_java.html

API Reference Guide

http://code.google.com/apis/calendar/reference.html

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

妻子的说明书 

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

Name:piaodown.com Serial:88QWS-A77CD9E0FC631C95

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

一、学习五段活用动词未然形的用法

Ａ：前田君、小説を買おうか。
Ｂ：いや、小説は買わない。雑誌を買う。
Ａ：雑誌を読むか。
Ｂ：うん、雑誌を読もうよ。
Ａ：ぼく、雑誌は読まない。推理小説を読む。1、「雑誌を読もうよ」中的&#65378;読も」是五段活用动词「読む」的一个活用形。「読も」有的书把它称作未然形，有的书把它称作推量形。「読も」后面的「う」是表示推量、劝诱的助动词。五段动词在与助动词「う」结合时，其活用词尾要变到「オ」段上。[読む」的活用词尾「む」的「オ」段假名是「も」（オ段假名有「オコントノホモモヨロヲ」），所以「読む」与助动词「う」结合时应该是「読もう」。如果五段动词「降る」「吹く」与助动词「う」结合的话，要把「降る」的活用词尾「る」变成「オ」段假名的「ろ」，把「吹く」的活用词尾「く」变成「オ」段假名的「こ」，这样「降る」「吹く」与「う」结合后便是「降ろう」「吹こう」。其它五段动词与「う」结合时都可以根据这一原理进行结合。2、「読まない」中的「読ま」是五段活用动词「読む」的未然形，「ない」是表示否定的助动词。五段动词在与助动词「ない」结合时其活用词尾要变到「ア」段上。「読む」的活用词尾「む」的「ア」段假名是「ま」（ア段假名有「アカサタナハマヤラワ」）、「読む」在与助动词「ない」结合时应该是「読まない」。「降る」「吹く」如果与「ない」结合的话，要把「降る」的活用词尾「る」变成「ア」段假名的「ら」，把「吹く」的活用词尾「く」变成「か」，这样「降る」「吹く」与「ない」结合后便是「降らない」「吹かない」。其它五段动词与「ない」结合时都可以根据这一原理进行。3、助动词「う」只能与五段动词结合不能与其它类型的活用动词结合。
学习五段活用动词连用形的用法
Ａ：どこへ行きますか。
Ｂ：家へ帰ります。
Ａ：家へ帰って、何をしますか。
Ｂ：手紙をかきます。

Ａ：手紙を書いて、それから何をしますか。
Ｂ：友達と遊びます。

1、「書きます」中的「書き」是五段活用动词「書く」的连用形。「ます」是表示郑重意义的助动词，五段动词在与助动词「ます」结合时，其活用词尾要变到「イ」段上。「書く」的活用词尾「く」的「イ段」假名是「き」（イ段假名有イキシチニヒミイリイ），「書く」与助动词「ます」结合时应该是「書きます」。「書きます」是「書く」的郑重体。「読む」「降る」如果与助动词「ます」结合的话，要把「読む」的活用词尾「む」变成「イ」段假名的「み」，把「降る」的活用词尾「る」变成「イ」段假名的「り」，这样「読む」「降る」与「ます」结合后便是「読みます」「降ります」。其它五段动词与「ます」结合时都可以根据这一原理进行结合。

学习五段活用动词终止形的用法
Ａ：桜の花はいつ咲くの？
Ｂ：桜の花は春に咲くよ。
Ａ：明日大連を立つか。
Ｂ：はい、明日の午後大連を立つ。
Ａ：手紙はいつ出すか。
Ｂ：手紙は今日の午後に出す。

1、「立つ」是五段活用动词「立つ」的终止形，终止形在句中的功能大体上有两种，一是表示句子的完结，即截句；另一个是在其后接终助词「から」「よ」或接助动词「らしい」「まい」等。五段动词终止形的活用词尾都是「ウ」段上的假名，「ウ」段上的假名有「ウクスツヌフムユルウ」。如「買う」「書く」「出す」「立つ」「読む」「降る」等五段动词的活用词尾都是「ウ」段上的假名。
2、「立つ」是自动词，通常自动词不能带宾语，其前不能接表示宾格的「を」。「大連を立つ」的「を」表示的不是宾格，而是表示动作离开的场所。「立つ」前如果是「を」的话，「を」前必须是表示场所或与场所概念有关的词。

学习五段活用动词连体形的用法
ａ：毎朝新聞を読みますか。

ｂ：いいえ、朝は新聞を読む時間がありません。いつも晩ご飯の後に読みます。
ａ：タイプライターを使う方がいますか。
ｂ：うません。
ａ：そうですか。じゃあ、わたしが使います。

「新聞を読む時間」中的「読む」是五段活用动词「読む」的连体形。所谓连体形顾名思义就是连结体言的活用形。动词的连体形与终止形的形态一样，其活用词尾也都是「ウ」段上的假名。所不同的是终止形表示一个句子的完结，而连体形则往往被用来修饰限制名词、代词等。换句话说，就是动词的基本形如果被用来修饰限定名词、代词的话，它就是连体形；如果被用来表示句子的完结的话，它就是终止形。终止形和连体形形态同一，功能各异。「タイプライターを使う方」中的「使う」也是连体形

学习五段活用动词假定形和命令形的用法
ａ：あしたはいいお天気なの。
ｂ：放送を聞けば。わかるよ。
ａ：倉庫には入れ物がないね。
ｂ：捜せばきっとあるよ。
ａ：小林君、頑張れ！
ｂ：三原君、頑張れ！

1、「聞け」是五段活用动词「聞く」的假定形。假定形通常与助词「ば」结合表示假定的意义。五段动词假定形的活用词尾都是「エ」段上的假名，「エ」段上的假名有「エケセテネヘメエレエ」。根据这一规律可以推断出，「買う」「書く」「出す」「立つ」「遊ぶ」「読む」「降る」的假定形分别应该是「買え」「書け」「出せ」「立て」「遊べ」「読め」「降れ」等。

2、「ば」是接续助词，一般接在活用动词的假定形后表示假定条件。
3、「頑張れ」是五段动词「頑張る」的命令形。五段动词命令形的活用词尾也都是「エ」段上的假名，但五段动词的命令形与假定形不同，命令形之后不能加「ば」等其它成分，只能用来表示截句。在表示句子完结这一点上命令形与终止形相同。动词的命令形在实际生活中一般很少使用。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

动词按其活用形分成五段动词、上下一段动词、变格动词（サ变和カ变）。这五类动词的辨别，对初学者是相当困难的。笔者经过多年的教学，总结出如下所述的动词分类表，俗称“大圆盘”，供有关人士参考利用。
本方法是采用了排除法，逐级辨别有特征的动词。

    大圆盘由粗实线分成4个部分，分别为：五段动词、上下一段动词、サ变动词和カ变动词。
1，从最容易辨认的开始，カ变动词只有「来る」一个动词。
2，第二步，する和带する的动词，如「勉強する」、「散歩する」等等，均属于サ变动词。这样，在大圆盘的下部横线以下为变格动词了。
3，去掉了变格动词，下边横线以上只留下了五段动词和上下一段动词。一条竖线把圆盘分成左右两部分，左边为五段动词，右边为上下一段动词。一段动词又以中间横线分成上一段动词和下一段动词。
4，如图所示，五段动词有如下4种。
非る动词：日语动词原形的词尾一共有9个：く，す，つ，ぬ，む，る，う，ぐ，ぶ。其中，不是る为词尾的动词，均为五段动词。如：「書く」、「話す」、「待つ」、「死ぬ」、「読む」、「笑う」、「泳ぐ」、「.#91;ぶ」等等。其中，「ぬ」为词尾的只有「死ぬ」一个词,所以任何语法书上也都使用此词。五段动词的词尾只有一个假名，前面的均属于词干部分。
词尾为「る」，但其前一个假名（词干的最后一个读音假名）为非「い段」、「え段」假名，即是「あ段」、「う段」、「お段」假名。这样的单词有「ある」、「眠る（ねむる）」、「怒る（おこる）」等等。
尾为「る」，且其前一个假名（词干的最后一个读音假名）为「い段」、「え段」假名，但是这个假名在词干汉字内（ふりがな）。这样的动词不多，有：「走る（はしる）」、「入る（はいる）」、「交る（まじる）」、「帰る（かえる）」、「滑る（すべる）」、「喋る（しゃべる）」、「焦る（あせる）」等等。其中，「交る（まじる）」又可写为「交じる（まじる）」、「混じる」等，要引起注意。
五段动词的第四种暂且不表。
5，除五段动词的第四种以外，全为一段动词。
上一段动词的一般结构是：词干+い段假名+る；如：「起きる」、「降りる」等。
下一段动词的一般结构是：词干+え段假名+る；如：「教える」、「流れる」等。
要注意，一段动词的末尾假名「る」前面的い段假名和え段假名均为词尾，即一段动词的词尾是两个假名。
在一部分一段动词中，会出现这样的情况，即：一个动词本身就是只由两个假名构成，如果把这两个假名都视为词尾，那么这个单词就没有词干。这种现象是不容许存在的，因此遇到由两个假名组成的动词，且其结构为：い段 假名+る或え段假名+る（其中一般情况下前面的假名都对应着相应的汉字）时，前面一个假名又是词干，又是词尾，即身兼双职。这样的一段动词称作兼用词：
い段假名+る的动词称作兼用上一段动词，如：「居る（いる）」、「着る（きる）」等。
え段假名+る的动词称作兼用下一段动词，如：「寝る（ねる）」、「出る（でる）」等。
   下面再说明五段动词的第四种（ｄ）
有了兼用上下一段动词的概念后，笔者指出：有下列特殊的动词是属于五段动词，必须死记（可与对应的一段动词做比较）。




读音   一段动词   五段动词

いる    居る            要る、入る、射る、煎る
きる    着る           切る、斬る
ねる   寝る            練る、煉る
へる    経る           減る
しる                     知る
ちる                     散る
ける                     蹴る
てる                     照る

    以上带有下线部分的动词，表面和兼用一段动词没有任何区别，但它们是五段动词，必须死记，没有别的办法。而且，这个区分是非常重要的，例如：同样的「きる（着る、切る）」其敬体句「着る」是「着ます」，而「切る」则是「切ります」；其否定形分别是「着ない」和「切らない」。因为它们各自属于一段动词和五段 动词，动词原形的读音是一样的，但其活用形是不相同的。

    如上所述，记住了这个“大圆盘”，动词按活用形的分类是没有问题了。任何一个动词总会属于其中的一个。据我的经验，关键是讲解时各项内容要交代清楚。
但是到目前为止，知道有2个特殊的动词，不能归入此表内：
    一个是「出来る（できる）」，按大圆盘分类，它应属于五段动词的第三类，但实际上是上一段动词；
    二是「せびる」，按大圆盘分类应属于下一段动词，但这个动词没有对应的汉字，其意思是“赖着要东西”，它是五段动词。
    这样的特殊的单词，任何规律都无法包罗万象，只好记住才是。欢迎各位给我补充这类特殊动词，增加对特殊性的处理能力。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

口语中敬语表达形式，虽不如ありません敬意程度高，但却在日常生活中通用。

口语中敬语表达形式形式有：

（1）         动词未然型＋ないです。例如：要らないです（我不要）、わからないです（我不明白）。
（2）名词＋ないです。例：私は経験ないです（我没有经验）。関系ないですけど（虽然没有关系）。
（3）名词＋では（じゃ）＋ないです。例：本物でもないです（算不上真品）。王さんじゃないですか？（这不是小李么？）。欲求不満ではないですけど（我不是欲求不满啊）
（4）动词＋では（じゃ）＋ないです。例如：私の部屋って2阶にあるじゃないですか～（我的房间，不是在2楼嘛）
（5）形式名词＋ないです。例如：行ったことないです（没去过）。
（6）副词＋に＋ないです。例：とくにないです（没什么）。
(7)形容词く型＋ないです。例：美味しくないです（不好吃）。
（8）形容动词＋では＋ないです。例：私は日本语があまり上手ではないです（我日语不怎么好）。

简体与敬体
　 日语中有简体与敬体两种说法，简体是普通说法，可用于会话，也可以用于写文章。如报纸、杂志上的文章皆是。说话时对很熟悉的、有亲切关系的人可用简体。敬体是说话者对听话者表示敬意的一种客气的说法，而且是标准的说法。一般用于会话和讲演，但也可以用于写文章。k
(1) 判断句　
现在过去
简体肯定-だ -だった
否定-ではない-ではなかった
敬体肯定-です-でした
否定-ではありません-ではあませんでしたv
例如：あの人は日本人(にほんじん)だ。　(简体)　
　　　あの人は日本人(にほんじん)です。(敬体)　
　　
判断句中的推测语气
现在过去
简体肯定-だろう-だっただろう
否定-ではなかろう-ではなかった
敬体肯定 -でしょう-だったでしょう
否定 -ではなかったでしょう-ではなかったでしょう
例如：明日(あす)の天気(てんき)は暑(あつ)いだろう。　(简体)
　　　明日(あす)の天気(てんき)は暑(あつ)いでしょう。(敬体)
(2)叙述句
现在过去:
简体肯定-いる-いた
否定-いない-いなかった
敬体肯定-います-いました
否定-いません-いませんでした
例如：中村さんは家(いえ)にいる。　(简体)
　　　中村さんは家(いえ)にいます。(敬体)
叙述句中的推測语气
现在过去
简体肯定-いるだろう-いただろう
否定-いないだろう-いなかっただろう
敬体肯定-いますでしょう-いましたでしょう
否定-いませんでしょう-いませんでしたでしょう
例如：田中さんは会社(かいしゃ)にいるだろう。　　(简体)
　　　田中さんは会社(かいしゃ)にいますでしょう。(敬体)

日语中分简体和敬体两种，敬体的谓语带です、ます，称为礼貌形，简体的谓语叫普通形。

1。动词的普通形

现在时为字典形

过去时为た形

现在进行时为て形加いる（ている）

否定式为ない形

过去时否定式为な形加かった（なかった）

注：遇到动词て形加ください转变成普通形时，直接去掉ください就可以了。

2。形容词的普通形

⑴い形容词（全部去です）：

一般时为词干加い

过去时为词干加かった

否定式为词干加くない

过去时否定式为词干加くなかった

注：可以将たい看作い形容词来转换普通形。

⑵な形容词（全部去です）：

一般时为词干加だ

过去时为词干加だった

否定式为词干加じゃない

过去时否定式为词干加じゃなだった

注：当な形容词作为定语修饰（如：きれいな花[美丽的花]）时，必须用词干加な，若是作为句子的宾语（如：花はきれいだ[花很美丽]）时，普通形就要用だ，不要搞错。

3。名词的普通形（全部去です）：

一般时为名词加だ

过去时为名词加だった

否定式为名词加じゃない

过去时否定式为名词加じゃなだった

注：方便记忆，和な形容词变化一致。

 五段动词:它的最后一个假名在[う]段上;

一段动词:的最后一个假名为る,它还可以分为上一段和下一段动词,上一段动词る的前一个假名在[い]段上,下一段动词る前一个假名在[え]段上.

五段动词：词尾变化跨越5个段（あ段、い段、う段、え段、お段）的动词。例：読む→読まない（ま：あ段）→読みます（み：い段）、読む（終止形む：う段）→読め（命令形め：え段）→読もう（も：お段）

一段动词：词尾变化只在一个段上（い段或え段　词尾变化在い段的叫上一段动词；词尾变化在え段的叫下一段动词）。例：起きる　起きない（き：い段）→起きます（き：い段）→起きろ（き：い段）など。

动词未然型变化规则

 する的未然型只有しない
される是する的被动态，如果句子是主动，而动词变成了被动，则表示尊敬。
例：どうされますか。您要怎么做呢？
どうしますか。你要怎么做呢？（两句句意一样，尊敬程度不同）
サ动词的未然型：例：勉強するーー勉強しない（直接对动词进行否定，意为：不学习）此规律不变。动词的未然型就是直接对动词进行否定。
等你动词变形学得多了就明白了。
至于"文献を参照されたい“这句话从哪里看来的？
文献を参照する。（参照文献）
文献を参照したい。（想参照文献）
文献を参照したがる（想参照文献。主语为非第一人称）
文献が（は）参照される（文献被参照）
均可以理解，只是你说的我不明白，希望明白的人给与指点。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

Language Support

      Intrinsic types:   byte, char, short, int, long, float, double, Object, String, and arrays are supported. However, there is no 64-bit integral type in JavaScript, so variables of type long are mapped onto JavaScript double-precision floating point values. To ensure maximum consistency between hosted mode and web mode, we recommend that you use int variables.

       Exceptions:try, catch, finally and user-defined exceptions are supported as normal, although Throwable.getStackTrace() is not supported for web mode. See Throwable for additional details.

     Assertions:The GWT compiler parses Java assert statements, but it does not emit code JavaScript code for them.

      Multithreading and Synchronization:JavaScript interpreters are single-threaded, so while GWT silently accepts the synchronized keyword, it has no real effect. Synchronization-related library methods are not available, including Object.wait(), Object.notify(), and Object.notifyAll()

        Reflection:For maximum efficiency, GWT compiles your Java source into a monolithic script, and does not support subsequent dynamic loading of classes. This and other optimizations preclude general support for reflection. It is possible to query an object for its class name using GWT.getTypeName(Object). 

       Finalization:JavaScript does not support object finalization during garbage collection, so GWT isn't able to be honor Java finalizers in web mode.

     Strict Floating-Point:The Java language specification precisely defines floating-point support, including single-precision and double-precision numbers as well as the strictfp keyword. GWT does not support the strictfp keyword and can't ensure any particular degree of floating-point precision in translated code, so you may want to avoid calculations in client-side code that require a guaranteed level of floating-point precision.

Runtime Library Support

Some specific areas in which GWT emulation differs from the standard Java runtime:

• Regular Expressions:The syntax of Java regular expressions is similar, but not identical, to JavaScript regular expressions. For example, the replaceAll and split methods use regular expressions. So, you'll probably want to be careful to only use Java regular expressions that have the same meaning in JavaScript.
• Serialization:Java serialization relies on a few mechanisms that are not available in compiled JavaScript, such as dynamic class loading and reflection. As a result, GWT does not support standard Java serialization. Instead, GWT has an RPC facility that provides automatic object serialization to and from the server for the purpose of invoking remote methods.

      Tip:  You'll save yourself a lot of frustration if you make sure that you use only translatable classes in your client-side code from the very beginning. To help you identify problems early, your code is checked against the JRE emulation library whenever you run in hosted mode. As a result, most uses of unsupported libraries will be caught the first time you attempt to run your application. So, run early and often.

Cross-browser Support

Whenever possible, GWT defers to browsers' native user interface elements. For example, GWT's Button widget is a true HTML <button> rather than a synthetic button-like widget built, say, from a <div>. That means that GWT buttons render appropriately in different browsers and on different client operating systems. We like the native browser controls because they're fast, accessible, and most familiar to users.

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

Google Web工具包（GWT）确实是使用Java开发Ajax应用的一种诱人方法。如果你在AWT/Swing/SWT和服务器小程序方面有着扎实背景，实际上很容易学会使用GWT，但如果要做的不仅仅是快速原型设计，那么某些难题仍然存在。

忠告之一: 分而治之

众所周知，GWT应用就是Java应用。不过，问题在于是“哪种Java”，我们需要牢记: GWT编译的是与J2SE 1.4.2或者更早版本兼容的Java源代码。另外，只有J2SE 1.4.2 API的子集得到支持，即java.lang和java.util程序包。即便在使用这些程序包时，也要非常认真地研究Google在运行库支持方面的注释，并且牢记相应的忠告: 如果确保从一开始就只使用客户端代码中的可转换类，那么就可以避免许多问题。为了及早发现问题，只要在宿主模式（hosted mode）下运行，就要对照JRE仿真库检验代码。因而，第一次运行应用时，就会发现大部分不支持的库。所以，要及早并且经常运行。

现在，笔者给出的忠告就是“分而治之”，具体意思就是一开始就把应用代码分成三个不同的部分: 客户端代码、RPC相关代码和服务器端代码，然后构建相应的Eclipse项目，从而完成任务。这样一来，就可以利用不同的Java语言版本，用于客户端和服务器部分。笔者用Java 5构建了应用的服务器部分（服务器小程序代码）; 但如果使用Mustang版本，那么在本文的代码片段中（由于篇幅有限，本文所涉及的程序代码可通过以下链接查询: http://blog.ccw.com.cn/article-htm-itemid-17924-type-blog.html），可以用Java 6取代Java 5。即便在服务器端仍然使用J2SE 1.4.2，这种分治法也可以在将来提供更大的灵活性，明确分离代码（“分离问题”），而不会在GWT宿主模式下限制调试操作。如果所有部分都在一个Eclipse项目中，则需要非常严谨，特别是在服务器端上; 不然，就会出现编译或者运行问题。

需要使用特殊的命名约定，这样可以清楚确认不同项目，并且简化部署脚本。可以使用譬如名为GWT-< ModuleName>的Eclipse工作集来包括所有三个项目。这里，“ModuleName”是识别Web应用的GWT模块的名称。

● 客户端代码: 包含与用户界面相关的代码，可以转换成JavaScript。因此，局限于J2SE 1.4.2和GWT运行时支持。启用每个项目的Eclipse Java编译器设置和“Java编译器错误/警告”，把Java依从级别调整到1.4、把源代码和类文件兼容性调整到1.4（假设不是使用1.4之前的JDK版本）。该项目的名称是< ModuleName>-client，譬如“JUnit2MR-client”，它依赖于构建路径设置中的< ModuleName>-rpc项目。程序包名称类似< com.company.project>.gwt.< moduleName>.client。

● RPC相关代码: 包含RPC相关的代码，可以转换成JavaScript。该项目遵从与上述客户端代码项目同样的指导准则。项目名是< ModuleName>-rpc，譬如“JUnit2MR-rpc”，它并不依赖于其他任何项目。程序包名称与< ModuleName>-client项目的程序包名称一样。RPC项目包含客户端上的远程接口、RPC期间由GWT进行序列化的数据传输对象，以及全局常量类。

● 服务器端代码: 含有服务器小程序代码，如果服务器端由Java服务器小程序组成的话。如果使用Tomcat 5.5或者Tomcat 6，可以充分利用Java 5+的全部功能。启用每个项目的Eclipse编译器设置，然后使用Java 5编译器设置，依从级别设置为5.0。如果使用Eclipse 3.2.2，那么其新的“源代码→清理”特性也值得配置。该项目名称是< ModuleName>-server，譬如“JUnit2MR-server”，它依赖于构建路径设置中的< ModuleName>-rpc项目。如果按照GWT的默认程序包提案进行编程，程序包名称是< com.company.project>.gwt.< moduleName>.server。

忠告之二: 调试和错误报告不仅仅只有Window.alert ()

在创建GWT应用时，其实可以使用IDE的全部调试功能。但在深入分析何处可能出现错误之前，需要代码的客户端和服务器端都有可靠的异常报告机制。使用try/catch代码块通常可以做到这一点。在客户端的catch代码块中，应当注意这一现实: 默认的方法调用e.printStackTrace()并不是在所有情况下都适合的解决办法。它适用于应用运行在GWT宿主模式下，把文本输出到Eclipse控制台。不过在Web模式下，要问问自己: “我发送到stdout或者stderr的堆栈跟踪信息和错误信息会在什么地方显示？”一种可能的解决方法就是使用Mat Gessel的调试实用程序类（http://www.asquare.net/gwttk），但是需要浏览器JavaScript控制台来查看Web模式下的结果。

在客户端，建议要做的一件事就是，使用GWT.setUncaughtExceptionHandler()方法，为任何未被发现的异常提供自己的异常处理程序。发现了这几种异常后，有几个选择: GWT.log（message, caught）、Debug.println (message_with_stacktrace); 如果使用Mat Gessel的Debug类，可选择Window.alert（message_with_stacktrace），或者自己定制的错误报告。

视来源而定，会得到“无法装入模块”或者“未被发现的异常被漏过”的信息。笔者编写了一个小小的DebugUtility类，它提供了易于定制的默认客户端错误处理机制（见代码片段1）。

在服务器端，可以使用java.util.logging API或者log4j的广泛功能，具体取决于个人偏好或者项目的约束条件。但要是没有为GWT的com.google.gwt.user.server.rpc.RemoteServiceServlet类打补丁，对于未被发现、未被检查的异常，只会在堆栈跟踪里面得到提示，指向生成该错误的服务器端类。对于catch()代码块里面发现及报告的被检查的异常，一切都正常。

忠告之三: 当心GWT Shell的“刷新”按钮陷阱

在宿主模式下启动应用时，会在浏览器任务栏上看到“刷新”按钮。要是摁了这个按钮，GWT就会把修改过的Java客户端源代码重新编译成Java字节码（作为.gwt.-cache/bytecode目录中的.tmp文件），然后重新装入模块。可以使用这个按钮来缩短编辑→编译→调试周期，但在使用这项特性时要牢记几个方面:

● 只有修改过的源代码才重新编译，也就是说，不会为依赖修改过代码的文件生成新的字节码。所以，如果改变了全局常量的值，假设public final int字段的值，不会立即在相关文件看到这个变化。

● 只有修改过的源代码才由GWT重新编译。这意味着，即便Eclipse IDE里面的“Project clean”也帮不上忙; 要影响到所有的相关源代码，譬如通过添加新的空行。

因为这个过程相当笨拙，笔者的忠告是在修改全局常量时遵循以下四个步骤:

1．在相应的源文件里面改变public final constant值;

2．重新编译改变后的源代码;

3．移除整个< ModuleName>-client/.get-cache/bytecode目录，从而删除GWT缓存内容;

4、使用Eclipse里面的“Run as”，重新开始启动应用，从而创建带重新编译后字符码的新GWT缓存内容，这种情况下，最好忽视“刷新”按钮，不过在有些情况下，删除整个< ModuleName>-client/.get-cache/bytecode目录后可以使用“刷新”按钮。

在修改服务器端代码时，GWT字节码缓存内容不受影响。不过，嵌入的Tomcat实例会缓存它，因而在使用“刷新”按钮后，只有重新开始启动应用后最初改变的代码才会得到认可。所以为了安全起见，改变服务器端代码后，最好还是重新开始启动应用。

忠告之四: 在宿主模式下读取Servlet Init参数

在处理数据库系统时，一般不希望服务器小程序源代码中有硬编码的数据库连接参数。通常会从属性文件读取这些参数; 或者更好的是，把它们作为init参数提供给服务器小程序（作为应用的Web.xml文件的一部分）。如果在Web模式下运行应用那没有什么，但在宿主模式下会出问题，这是由于GWT宿主模式下的服务器小程序处理存在限制。

好消息是，只要修改由嵌入式Tomcat实例使用的Web.xml文件，就可以解决这个问题。为此，修改< ModuleName>-client/tomcat/webapps/ROOT/WEB-INF目录中的Web.xml文件（或者必要时创建一个）: 除了嵌入式Tomcat的GWTShellServlet映射外，添加带有init参数的上下文部分。因为上下文信息是“全局性的”，而不是针对特定的服务器小程序，在这里只有一部分的init参数信息，或者使用特殊的命名方案，把参数与不同的服务器小程序联系起来。如果使用这个新的web.xml文件，可以删除src/web/WEB-INF文件夹中的那个旧文件。

在服务器小程序代码中，访问init参数的方式与Web模式下读取它们的方式一样，譬如final String host = getInitParameter("host")。笔者实现这一点的办法就是修改GWT的RemoteServiceServlet，方法跟第二个忠告里面的如出一辙。现在，只要覆盖GenericServlet的getInitParameter()方法，以便使用getServletContext()，而不是 getServletConfig()。

另一个忠告是，如果在宿主模式下和Web模式下测试不同的服务器代码，略过Gant脚本中的GWT编译部分，从“temp”位置拷贝编译前的JavaScript代码，则可以节省时间。这适用于客户端代码复杂、编译时间超过10分钟的情形。

忠告之五: 在浏览器里面显示PDF文件

大多数实际的Web应用提供了生成及阅读PDF文件的方法。本文假设这个PDF文件由服务器小程序生成，譬如通过JasperReport。以后只要点击某个超文本链接，就可以在浏览器里面阅读生成的文件。如果想在宿主模式下和Web模式下测试这项特性，建议采取以下步骤:

1．设计一个RPC接口，接受告诉服务器是在宿主模式下运行还是在Web模式下运行的布尔参数。接口方法会返回的字符串应当带有服务器小程序生成的PDF文件的名称（即文件名的最后一部分）。

2．根据代码片段4显示的代码，实现服务器小程序代码，这取决于布尔参数“isScript”。

3．在客户端: 在窗口组件代码里面，使用GWT.isScript()参数调用createXyzPDF()方法，从而生成包含服务器小程序结果字符串的外部超文本链接。

代码片段4显示了接口方法名为createSummaryPDF()的示例。从服务器小程序返回的字符串是“summary.pdf”。

这当然不是处理这种情况的惟一办法，但目前适用于我们这个示例。请注意: 在宿主模式下启动应用之前，必须在< ModuleName>-client project's src/…/public文件夹中至少创建一个虚假的“summary.pdf”文件（文件名从服务器小程序返回）。不然，在浏览器中点击了超文本链接后，GWT试图读取PDF文件时，会出现“HTTP 404－找不到网页”的信息。

忠告之六:力求获得无状态服务器

设计客户机/服务器Web应用时要考虑的一个关键问题就是: 如何处理会话和状态管理？在Web 1.0时代，答案很显然: 会话和状态管理是一个服务器问题。但若使用GWT，就有另一个选择。服务器再也不是只提供HTML内容的“web”服务。使用GWT RPC，服务器现在可以支持只提供结构化数据的服务———在本文示例中，服务由服务器小程序实现。

那么，GWT对会话和状态管理有何影响呢？GWT的技术领导Bruce Johnson在去年的JAOO大会上指出，若使用GWT，会话管理现在应当是一个客户端问题。附图显示的幻灯片评述了种种变化。

在本文的JUnit2MR GWT应用中，笔者一开始使用传统方法来处理服务器小程序中的会话状态。但这是相当笨拙的任务，于是寻找另一种选择。因此，看了Bruce的幻灯片后，决定重新设计整个应用。但这一步需要改变所有RPC接口、缓存策略; 最重要的是，还要改变所有的服务器小程序。因此笔者的建议是: 及早考虑在何处实施会话和状态管理，不妨试试Bruce Johnson的诀窍。最终会收到成效。

由于这个决定，客户端对象之间有了更多的联系。于是笔者使用了有名的GoF中介者模式（mediator pattern）。不过，在客户端有一些JDK 1.4和GWT运行库的限制。因此，重新实现了PropertyChangeEvent类和中介者支持，来处理监听程序注册和消息广播。

忠告之七: 使用Selenium实现GWT Web测试的自动化

Selenium是一种开源工具，它能够轻松测试包含丰富、互动的客户端内容的Web应用。 所以，它非常适用于测试像用GWT创建的应用那样的Ajax应用。

当然，GWT里面仍有JUnit和JUnit支持功能，特别是针对系统的异步部分。这里着重介绍Selenium，因为它易于使用（至少它的IDE是这样）、功能强大。最后但并非最不重要的一点是，它与JUnit有许多共同之处。可以使用Selenium IDE来记录GUI用例，然后使用其“Play”特性来运行记录下来的操作。每个操作之后跟着类似JUnit的“assert”命令，负责确认页面上的某些文本。该IDE是Firefox的扩展插件，但务必要使用最新版本的Selenium: Selenium IDE 0 .8 .7，因为它包含了“waitFor…”命令的重大修正版。说到测试Ajax应用，这些命令以及“pause”命令非常重要。

忠告之八: 使用Groovy Gant脚本部署应用

在GWT宿主模式下试运行应用，这确实很好，但把应用部署到应用服务器上或者类似Tomcat的服务器小程序容器上，GWT的真实功能才会体现出来。在这一步，需要创建一个war文件，它会自动拷贝到Tomcat“webapps”目录。当然，可以使用Ant和ant-contrib进行所有必要的准备、编译、拷贝及其他任务。但由于Ant脚本变得更复杂后， ant-contrib控制结构和属性regex处理有一点笨拙。于是可以使用集Groovy和Ant两者之所长的Gant。安装Groovy和Gant用不了10分钟，然后，使用来自“build.properties”文件的普通属性，即可定制“build.gant”脚本。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

引自:http://www.blogjava.net/steeven/archive/2006/07/14/58239.html

适用版本GWT 1.0.21。

1. Shell调试模式和实际编译结果有差异。
shell中报告的异常在运行中只是一些凌乱的脚本错误，或者干脆没有响应。
shell中通过的程序在实际运行时还会有错误。
2. 避免错误的方法是捕获异常，
在onModuleLoad方法中try catch
或者GWT.setUnCaughtExceptionHandler()//全局异常捕获
3. LOG, 利用GWT.log(). shell模式下会输出到控制台。
4. 远程调用属于异步。同步远程调用可以自己包装ClientCallback，在一个结束后调用另外一个.
5. RPC调用中Set传递有bug, 暂时用List
6. Eclipse直接运行Compiler/Shell, 加入gwt-dev-windows.jar。
main: com.google.gwt.dev.GWTCompiler/GWTShell
arguments: -out ${project_loc}\WebContent real/Index.html
classpath->UserEnties->advanced->add folder->选择项目的src目录，要在第一位。
7. Tomcat5问题多多, 用tomcat4.
8. gwt-user中非法包含javax.servlet, tomcat认为其无效。直接放到tomcat/common/lib中。或者在jar中去掉。
9. Exception.getStackTrace() 在Shell模式下有效, GWT.isScript()可以判断
10. 静态中文在html中乱码，要在html header中加入<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

11. long被映射成js的double实际使用会有问题，建议用int
12. FlexTable的removeRow(int)有bug, 这行之后的widget会异常．需要自己写补丁．
13. synchornized/wait(),notify()等同步操作不支持
14. 可用的eclipse插件:goolipse.com
6. 补充说明：GWTCompiler支持-style DETAILED,输出的js格式标准，名称有意义，可用于同shell不一致时候的js调试．
arguments: -out ${project_loc}\WebContent real/Index.html
这里real对应real.gwt.xml，一般应该有包名．

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

引自:http://www.ibm.com/developerworks/cn/java/j-lo-gwt-dev/#N100B2

级别： 初级

周 登朋 (zhoudengpeng@yahoo.com.cn), 研究生, 上海交通大学
张 黄瞩 (zhanghuangzhu@gmail.com), IBM CDL软件工程师

2006 年 7 月 03 日

GWT(Google Web Toolkit) 是 Google 最近推出的一个开发 Ajax 应用的框架，它支持用 Java 开发和调试 Ajax 应用，本文主要介绍如何利用 GWT 进行 Ajax 的开发。

Ajax技术是当前开发web应用的非常热门的技术，也是Web 2.0的一个重要的组成部分。然而如果用传统的方式Javascript进行Ajax开发的话，就会使得应用程序非常难以进行调试，从而降低了生产效率。Google最近推出的GWT有望为我们解决这个难题，GWT是一个开发Ajax应用的框架，它使程序员用Java同时开发客户端和服务器端的代码。GWT的编译器会把用于开发客户端的Java代码转化成Javascript和Html，而程序员不用关心这一转换过程。这样程序员就可以在自己喜欢的Java IDE里面开发自己的Ajax应用程序。

本文主要从以下几个方面进行介绍：

1、 GWT特性简介

2、 用GWT进行UI开发

3、 用Javascript开发Ajax应用简介

4、 用GWT进行Ajax开发

GWT特性简介

1．动态，可重用的UI组件

GWT提供的组件库使用户可以很容易的开发出漂亮的UI, 每个组件对应于GWT的一个类。在本文的第二部分会比较详细的介绍GWT对UI的支持。

2．简单的RPC调用

使用GWT，可以方便的实现客户端和服务器端的通信，特别是使得异步通信变的非常简单。在本文的后面部分将对利用GWT进行RPC调用进行详细介绍。

3．更加方便的调试

由于在开发阶段不需要生成HTML截面，用户开发的代码实际上是在JVM上运行的，这样用户就可以用传统的调试Java代码的方法对程序进行调试，从而加快了调试的速度，减少了软件开发的时间。

4．浏览器兼容性

在大多数情况下，用GWT开发出来的程序会支持IE、Firefox、Mozilla、Safari和Opera，用户在开发的时候不必担心浏览器的兼容性问题。而浏览器的兼容性问题也是用直接用Javascript进行Ajax应用开发所面临的一个另程序员棘手问题。

5．可扩展性

如果你觉得GWT提供的API不能满足需求，你可以利用JSNI将Javascript语句直接嵌入至Java代码中。

回页首

用GWT进行UI开发

在本文的这一部分，我们将探讨一下GWT对UI开发的支持。在GWT中，包含我们进行Web开发所需要的大部分组件，比如按纽(Button)，文本框（Text box）等。图一显示了部分GWT所支持的UI组件。从图片的显示效果来看，利用GWT可以做出非常漂亮的UI。

图一：GWT支持的部分UI组件
 

值得一提的是，在每个UI组件是必须放在一个称之为面板（Panel）的控件里面。而面板具有不同的风格，这也决定了UI的风格。图二显示了GWT所支持的部分面板。

图二：GWT支持的部分面板
 

在看过这些组件之后，我们接下来用一个实验来讲述怎样把UI组件添加到页面上。这个实验的最终结果是一个登录框界面。

在开始我们的实验之前，我们需要准备一下GWT环境，首先要到Google的网站上去下载一个Windows版本的GWT，目前的版本号是1.0.21。然后要在机器上配置好JDK环境，具体的配置方法网络上有大量文档，这里就不再详细介绍。由于我们这个实验是在Eclipse开发环境下进行的，所以你还需要一个Eclipse的环境，可以到Eclipse的官方网站下载Eclipse的开发环境。接下来我们详细介绍试验过程。

1． 创建Eclipse工程

我们可以利用GWT自带的一个批处理文件projectCreator.cmd来创建Eclipse的工程。如图三所示，我们创建了一个名字为myProject的工程，存放在当前目录的myProject子目录下面，关于批处理文件projectCreator.cmd的详细用法，请参见Google关于GWT的帮助文档。

图三：用GWT创建Eclipse工程
 

2． 创建GWT应用程序

在创建完Eclipse工程myProject之后，我们利用GWT自带的另外一个批处理文件applicationCreator.cmd来创建一个GWT应用程序。图四显示了创建一个GWT应用的过程。大家注意到这个批处理文件接受一个名为 -eclipse 的参数，这个参数正是指定了一个Eclipse的工程，我们的例子中指定为我们刚创建好的Eclipse工程myProject。

图四：创建GWT应用程序
 

3． 导入Eclipse工程

在创建完Eclipse工程和GWT应用程序框架后，我们接着将Eclipse工程导入到Eclipse开发环境当中以进行进一步的开发，具体的导入过程不再详细介绍。导入后的工程结构如图五所示。

图五：导入Eclipse工程
 

6．添加UI组件

在导入工程后，我们会发现工程里面有一个名字为DemoClient的Java文件。这个文件是在运行applicationCreator.cmd批处理文件时创建的，我们现在需要做的工作就是在这个Java文件上加入自己需要的UI组件。我们在这个文件中加入了五个组件，分别是：两个Label，一个Button，一个TextBox和一个PasswordTextBox。代码列表Listing 1中列出了本程序的所有代码。

Listing 1：Sample GWT Application

1 package com.sample.myProject.client; 2 import com.google.gwt.core.client.EntryPoint; 3 import com.google.gwt.user.client.ui.Button; 4 import com.google.gwt.user.client.ui.HorizontalPanel; 5 import com.google.gwt.user.client.ui.Label; 6 import com.google.gwt.user.client.ui.PasswordTextBox; 7 import com.google.gwt.user.client.ui.RootPanel; 8 import com.google.gwt.user.client.ui.TextBox; /** * This class is used to demostrate how to add widget onto the Web page */ 9 public class DemoClient implements EntryPoint { /** * This is the entry point method, when the module is load, this method * will be automatically invoked. */ 10 public void onModuleLoad() { 11 Label labelName = new Label(); 12 Label labelPassword = new Label(); 13 TextBox tbName = new TextBox(); 14 PasswordTextBox tbPassword = new PasswordTextBox(); 15 Button button = new Button(); 16 17 labelName.setText("Name: "); 18 labelPassword.setText("Password: "); 19 button.setText("submit"); 20 21 HorizontalPanel hPanel = new HorizontalPanel(); 22 HorizontalPanel hPanel2 = new HorizontalPanel(); 23 24 hPanel.add(labelName); 25 hPanel.add(tbName); 26 hPanel2.add(labelPassword); 27 hPanel2.add(tbPassword); 28 RootPanel.get().add(hPanel); 29 RootPanel.get().add(hPanel2); 30 RootPanel.get().add(button); 31 } 32 }

接下来我们分析一下这些程序代码，注意到类DemoClient继承自EntryPoint，所有需要最终被翻译成HTML页面的类都必须继承自EntryPoint，并且需要重写onModuleLoad方法，这个方法会在模块被装载的时候自动调用。因此我们也就需要把我们的添加组件的代码放到这个函数里面。

程序的11至15行分别创建了5个组件