图2：图片因素对F型浏览的影响

    
• 网站结构
    
• 页面内容

当然，这样归可以有点笼统，简单说一下。蜘蛛捉网页要么深度优先，要么广度优先，衡量链接结构适合两种方式能跑遍网站结构就行，该用robots去挡的就去挡，过多的堆积不一定是最好的。

Google说：设计网页时该考虑的是用户，而不是搜索引擎。，以人为本的设计就不一定能照顾到搜索引擎，当然，搜索引擎也努力在模拟人。可以在网站结构定完后进行一定量地调整链接结构，对于搜索引擎是怎样搜索，我也不知道，我相信很多专业从业SEO的朋友也不一定清楚。不过我倒是知道有好几搜索引擎会去看一下sitemaps。

最近看到的SEO多数也是讲到页面内容，说到页面内容，自然就是关键词，关于关键词的选择：有资本就去抢热词，没资本就捡冷词。关于一个页面要多少关键词，这个是高技术含量的东东，我不懂。不过据说有的编辑能拿月薪上W，关键词是基于内容生成滴，一个优秀的编辑在写一篇文章时，就可能有意识或者无意识埋了无数的关键词，虽然他们有时只是想写出更多人阅读的文章，可是他们的用词用字都已经对应了相应的行业。又据说现在的引擎都是全页索引，呵呵，当然精选细选的关键词是理想滴。

说到页面，自然也要讲到Web Standard，有人说有关系，有人说没。说于说没的朋友，建议去看一下下WCAG，一般人我是不告诉他们滴。Web标准不是简单的DIV+CSS或者XHTML+CSS，理想是让各种User agent都可以访问，当然，由于一些终端的局限，相应的M版出来，比如m.flickr.com等。一个页面可以通用访问，不代表适合访问。

虽然大家都用XHTML，但用法不同，大家研究语义化的网页也不假的，什么时候用h1，什么时候用h2，也不是说因为h1搜索引擎比较喜欢就选择用的，大家正努力充分发挥(X)HTML各标签的作用，减少大量font之类的东东，虽然不能说很利于搜索引擎，但也帮搜索引擎过滤了一回，html5还“开发”了几个新标签出来给大家玩。 当然，CSS Layout是优秀的，但也不是说table布局就没用，电视有了，收音机就扔了-_-b， 现在收音机还是播着了大堆有价值的东东。呈现方式不同，有着“利于”和“更利于”的区别。

当然，影响页面还有另一个重要的因素，站外链接，要是你的Blog每天都有无数个垃圾留言的话，这也是SEO的副作用之一，搜索引擎不少用站与站之间的link来评估页面的重要性，比如PR，不过据说现在不更新鸟。虽然说有nofollow这样高科技的东东，但也有挡不住的激情，就是不知道引擎们会不会喜欢nofollow的东东，不过可以确定的是WP的插件也能实现区别spam，相信那样聪明的搜索引擎也会区分一下下吧。

好像没说到SEO最最核心的东东。。嗯。我是不会。会也不讲出来^^。要是我能懂得引擎们的算法，我就不在这废话了。给个新手学习的地方: 网站管理员支持中心 – 网站管理员指南。里面有句话特别喜欢：请不要为了提高搜索引擎排名而弄虚作假。不是说SEO不能做，要做就要注意个量（数量/质量）。

传统切图讲究精细，图片规格越小越好，重量越小越好，其实规格大小无所谓，计算机统一都按Byte计算。客户端每显示一张图片都会向服务器发送请求，所以，图片越多请求次数越多，造成延迟的可能性也就越大。因为一张图片的传输时间，通常远小于请求等待的时间。

减少图片的三个技巧(CSS Sprite)：

1. 图片限制(Image Slicing)

典型如文本编辑器，小图标特别多，打开时一张张跑出来，给用户的感觉很不好。如果用一张图解决，则不会有这个问题，比如百度空间、163博客、Gmail都是这么做的。

Image Slicing’s Kiss of Death
http://www.alistapart.com/articles/sprites

2. 单图转滚(Single-image Rollovers)

触发切换图片的需求，传统方案得重新请求新图片，因为网络问题经常造成停留或等待。如果把多种状态合并成一张图，就能完美解决，然后再使用背景图技术模拟动态效果。

ColorScheme Ratings
http://demo.rexsong.com/200608/colorscheme_ratings/

3. 延长背景(Extend Background Image)

如果图片的某边可以背景平铺无限延长，则不需要每个角、每条边单独搞出来，图片能少一个就少一个。其实，这个理论还可以扩展到四角容器里，好处是能大大简化HTML Structure。

Extend Background Image
http://demo.rexsong.com/200705/extend_background_image/

综合案例

Google Korea（1和2技巧）
http://demo.rexsong.com/200705/google_korea/

CSS Menus（2和3技巧）
http://demo.rexsong.com/200705/css_background_menus/

一.我们需达解决的麻烦

    
• 减少HTTP请求数. 减少HTTP请求数有什么好处    
          
  • 降低服务器跟客户端的建立和消除HTTP请求和响应Header的开销
          
  • 减少服务器为HTTP连接的进程和线程的开销,如果可能,还会包括GZIP压缩的CPU开销.
      
      
    
• 减小被请求文件大小, 减少请求数据占用的网络带宽.
    
• 让用户更快的看到想要的结果.
    
• 提高客户端渲染速度.
    
• 让浏览器同时能请求更多的数据.
    
• 提高服务器相应速度.
    
• 通过版本化控制客户端Cache.

二.如何解决我们的麻烦

A.如何减少HTTP请求数

    
1. 合并JS文件跟CSS文件。
    
2. 合并框架图片以及相对变动较少的图片成一张，通过CSS背景切割来完成渲染，比如：加速图片显示。
    
3. 合理使用本地Cache来缓存JS/CSS/IMAGE。
    
4. 合理使用UserData缓存JS文件，对于FF用户可以单独请求服务器,这样能解决80%用户的问题。
    
5. 把JS跟CSS合并成一个文件。

B.减小被请求文件大小,减少请求数据占用的网络带宽

    
1. 压缩JS体积：删除JS中空白换行,注释,混淆把长变量换成短变量；
    
2. 压缩CSS体积：删除CSS注释、写法尽量用简写；
    
3. 使用(X)HTML+CSS方式搭建网站结构,提高CSS重用性,来减少(X)HTML文件大小；
    
4. 使用服务器端GZIP压缩JS/ CSS文件,缩小传输文件大小。附注:Apache1跟Apache2的GZIP的效率跟方式不一样的，根据需要自行选择。

嗷嗷补充说明：压缩、合并JS和CSS都由程序处理。而不是自己手动去缩删，不然不利于后期维护。

C.让用户更快的看到想要的结果

用户对于一个站点的白页的忍受时间根据统计是8-12秒。白页的产生可能由于各种原因引起,我们能做的就是怎么让用户能变的稍微能等待更久。

    
• 方案1.多做一个引导页,让用户体会其中的变化
      案例:mail.aol.com中的loading引导页
    
• 方案2.优先载入页面结构以及结构图片,后一步载入当前页面数据,再后一步载入Iframe,Flash等数据.让用户尽早的看到被打开页面的希望.

D.提高客户端渲染速度

这个问题就比较泛泛了,影响客户端的渲染速度有多方面的,主要目的都是提高程序方面的效率.

    
1. 对于大索引的结构,尽可能的少用索引访问,能用访问兄弟节点的方式尽可能用访问兄弟节点的方式.
    
2. 字符串拼接尽可能用数组方式
    
3. 大规模添加节点数据,请不要使用appendChild方式,尽量使用类似innerHTML的insertAdjacentHTML方式,FF下需修正¹

E.让浏览器同时能请求更多的数据.

浏览器默认只是支持单域名同时有两个HTTP请求,使用多域名将能把请求数提高,在网络条件优良的情况下,能更快的下载数据,呈现结果.

F.提高服务器相应速度

对于需快速响应的文件,把其放入快速响应的服务器,应该是不错的方案,优化方案请系统储备组提供.

G.通过版本化控制客户端Cache.

通常js/css这类文件改动比较频繁,但是为了加载速度变快,我们有可能需要设定这类文件的过期时间为几天后,这样我们碰到的问题就是,如何及时更新这些在cache的文件?
通过一个简单的配置,通过修改JS的版本来及时告诉浏览器,这些文件必须重新请求了,不要继续使用浏览器cache中的数据. 方案有好几个:

    
1. 手动改这些js的文件名
    
2. 手动改这些js的路径
    
3. 通过URL Rewrite方式来改重定位js路径
    
4. 通过一个在高响应服务器上的一个js配置告知页面,这个页面该链接哪些JS文件
    
5. 大版本不变,小版本不断追加,等一定时间后,统一更新,高效利用cache

标注

    
1. Firefox修正方式
   [codes=JS]function addHTML(oParentNode, sHTML) {
       if(window.addEventListener) {
           // for MOZ
           var oRange = oParentNode.ownerDocument.createRange();
           oRange.setStartBefore(oParentNode);
           var oFrag = oRange.createContextualFragment(sHTML);
           oParentNode.appendChild(oFrag);
       } else {
           // for IE5+
           oParentNode.insertAdjacentHTML("BeforeEnd", sHTML);
       }
   }[/codes]

浏览器问题，有各自的浏览器处理内存问题会影响到，但几乎没办法控制得了，Windows上的：

    
• IE系列，刷新回收的量不大，但最小化会释放内存，。
    
• Firefox2据说也会在最小化回收，可我从没见过最垃圾，用多少是多少，基本不回收。据说prototype的ajax还会引起内存一直增加。
    
• Opera最好。一直控制得很好。不存在什么问题。。

Linux的内存分配机制与Win的不一样，有多少用多少，如果浏览器占光时说不定会干掉系统。

页面问题，浏览器渲染页面会消耗内存和CPU，能减少一点就减少点。

结构上

    
• 使用DocType，告诉浏览器你在用什么，html4也有DTD。也许Transitional更适合你
    
• 如果使用的是XHTML并能保持良好结构的话，记得输出相应的MIME跟XML头¹，可以减少浏览器的代码检查，
    
• 保持结构的完整，不要让浏览器帮你补全代码。
    
• 控制页面的文件大小，可以通过程序把为了看代码比较舒服的缩进去掉。2~3K也是大小。
    
• iframe会产生新的页面，其实有很多方式可以代替iframe
    
• 引入的JS与CSS可以适当合并，同样背景图片也可以合并，甚至有人连Flash都合并
    
• 给已知宽高的内容图片/Object加上宽度的属性可以减少页面的局部重渲染

表现上

    
• 质量99跟70的jpg在大多数情况下只有文件有大小不一样。gif的也一样，特别是小图标，256色跟128色的差别是文件大小．
    
• flash动得太快吃CPU很大，控制每秒的帧数及动画的效果可以减少一些，如果把品质用中低显示会省很多资源，但这样却牺牲了效果。。quality属性 有时选择Autolow² 或者Autohigh会更适合，没必要一直low 或者best，
    
• flash使用矢量图会节省文件大小，但计算复杂的图形跟动画时花的是CPU。复杂的太多滤镜，则会占用大量内存，模糊滤镜有减少些³。
    
• IE的滤镜也是比较占用内存，同时也有兼容性问题。全屏的半透明很吃资源的。
    
• 2*2的图片跟8*8的图片大小差不多，但是平铺背景2*2却占用大很多。
    
• gif动画同样有帧的概念，别把gif当成flash来玩就行。

行为上

    
• 别为了使用一个$()引入整个prototype或jQuery，它们有更多的作用。
    
• AJAX很帅。但是用xml会用上XML解析器，有人推荐用JSON，可是这样要eval数据，其实可以直接import已经是对象的script来用。只是要多传个对象名，或者把对象名写死，或者像flickr那样jsonFlickrApi({"xxx":"xxx"})，直接当函数用，挖哈哈。
    
• 实现某些效果时能用visibility:hidden解决时就别用display:none来玩。
    
• 在这里强调js变量要注全局跟局部等等的意义并不大，JS复杂的地方也不是一两句能说得清的，关注大家关注月影的正在出版的新书吧。^^

其实这里有的内容有不少跟如何快速的呈现我们的网页相近，不过那篇是以处理服务端为主，但在很多时候，节省服务端资源消耗的同时也会节省客户端的资源消耗。

再其实，这篇已经蹲在草稿箱里好久了，一直没有时间去整理。现在给的也不是完整的，因为没有完整，慢慢补充吧。

    
1. 产生问题：虽然会引起浏览器的模式问题，但问题是可以解决滴。参考Serving up XHTML with the correct MIME type，派送XML头浏览器不会容错显示，出现错误结构会导致整个页面无法显法。
    
2. Autolow: 优先考虑速度，但是也会尽可能改善外观。 回放开始时，消除锯齿功能处于关闭状态。 如果 Flash Player 检测到处理器可以处理消除锯齿功能，就会打开该功能。
       Autohigh:开始时回放速度和外观两者并重，必要时会牺牲外观来保证回放速度。 回放开始时，消除锯齿功能处于打开状态。如果实际帧频降到指定帧频之下，就会关闭消除锯齿功能以提高回放速度。使用此设置可模拟“消除锯齿”命令（“视图”>“预览模式”>“消除锯齿”）。
    
3. 模糊滤镜:使用模糊滤镜时，如果用于 blurX 和 blurY 的值是 2 的整数次幂（例如 2、4、8、16 和 32），则可以加快计算速度，并且可以使性能提高 20% 到 30%（flash的帮助是介样说滴）。

1. 把业内一些零碎和模糊的东西进行分析、整理并加以亲身实践，制定成使用说明或者标准化的设计工具。现在国内的交互从业者对一些概念和工具的理解基本上只停留在老外创造的美好词汇和自己的臆想之中，融入到工作实践时总有这样那样的不靠谱，这并不是东西本身不实用，而是师夷长技的时候并没有结合自身情况。

2. 抛块砖，引堆玉。希望童鞋们把UED的相关方法、工具和经验成果都规范总结起来，提高自己工作效率和作品质量的同时，也为整个UED行业的发展壮大贡献力量。在这条方兴未艾的行业道路上，我们需要交换思想，互相启发，彼此搀扶，共同进步。

以下提供一份阿里巴巴的纸上原型设计方法说明及使用规范（PDF文档），大家有兴趣可以看看！

这个文件只能在登入之后下载。请先 注册 或 登入

“布局”是指页面内容的尺寸、间距及位置。有效的布局对于帮助用户快速找到他们想要的内容至关重要，并可以在结构外观上令用户感到舒服。

如何设计有效的布局？

1. 具有清晰的视觉层次。布局应当让页面各元素之间的关系和重要性一目了然。你可以通过适当使用下列属性来实现视觉层次：

• 焦点：指用户首先关注的区域。形式上被赋予焦点属性的UI元素一定要表达重要的内容。
• 视觉流：指用户关注区域的顺序。可以根据任务逻辑和用户的浏览习惯来设计恰当的视觉流。好的视觉流应该清晰、合理、顺畅、自然。

• 关联：在逻辑上相关的UI元素应具有清晰的视觉关系。

错误：逻辑上相关的UI元素在空间上被分隔，且没有明显的视觉关联。

• 对齐：使页面工整，信息呈现有序，便于用户扫视。

错误：没有对齐影响了页面效果且不便于用户扫视。不要因为功能需要和对极限情况的顾虑而轻易牺牲掉页面的视觉展现。

• 强调：可以根据UI元素间的相对重要程度进行强调。

2.针对用户的阅读模式来设计布局。

• 大部分人的阅读习惯是从左向右，至上而下。
• 阅读分为沉浸式阅读（immersive reading）和扫视（scanning），前者的目的在于理解，后者在于定位。

• 浏览网站时，用户不会沉浸在UI本身，而是沉浸在他们的目标任务中，因此扫视是最常使用的阅读模式。用户只在确信必要时才仔细阅读大量文本。
• 针对扫视的布局设计可以适当强调主要的UI元素，弱化次要的。包括：
1) 将主UI元素放在扫视路径上。
2) 避免将重要信息放在左下角或者页面底端或者需要滚动很多的控件上。
3) 考虑使用渐进展开方式来隐藏次要的UI元素。
4) 将任务相关的重要信息要直接表现在控件上。用户更倾向于关注交互控件上的标签，而不是辅助型的静态文本。

错误：用户必须阅读辅助型文本后才能明确“确定”按钮的作用。

正确：直接将按钮的作用描述作为控件标签，便于用户理解。

3.合理利用页面空间。

• 保持页面的视觉平衡。避免拥挤和对空间的浪费。
• 确保关键数据没有被截断，除非数据特别长。

错误：有效空间没有被充分利用，从而导致多条关键数据被截断。

• 控件的尺寸和间距恰当，没有不必要的滚动。一个任务尽量在一屏内完成。
• 实际情况中，我们用户的页面空间要小于屏幕分辨率，它会因各种因素而压缩，如：非全屏操作（弹出窗口和对比浏览），浏览器本身及各种辅助栏对屏幕的占用等，设计中要考虑这些情况。

4.不要让布局本身成为突出的UI元素，保持视觉简洁（visual simplicity）。

• 减少内容和展现上的嵌套层级。
• 减少控件不同尺寸的数量，例如，在界面上只使用一两种按钮宽度。
• 采用轻量级的分组和分割方式，可以用布局本身和分隔符代替分组框。
• 使用尽量少的对齐线。

5.选择与页面类型相匹配的版式。在设计之初，应充分考虑页面承载的内容、功能和属性，继而选择适合该页面的版式。不合适的版式会造成用户的阅读困扰，降低任务的完成效率。

标准和规范：

1.栅格化：

• 我们所说的栅格化是指在网页设计工作中对栅格系统的建立和应用。网页栅格系统来源于平面栅格系统，它以规则的网格阵列来指导和规范网页中的版面布局以及信息分布。
• 栅格化可以使信息呈现工整简洁、美观易读，降低页面开发和运维成本。它结构变化相对灵活，扩展性强。

2.以8px为横向栅格单位：

• 以8px为横向栅格单位，页面所有元素宽度都可以是2的倍数，包括图片和版块宽度，这样可以在一定程度上加快页面（特别是对于J-PEG图片）的渲染速度（基于计算机内部二进制的运算机制）。其在扩展和兼容性上也有一定优势。
• 在阿里巴巴中文站中，布局间距的最小单位为8px，布局区块采用32px（8px*4）和24（8px*3）两种粒度单位，分别组成以下两种可实现的栅格系统：

32px：适用于市场、社区等相关页面

24px：适用于旺铺相关页面

3.页面定宽：

• 自适应可以根据浏览器显示情况自动调整页面宽度，但是因为用户水平方向的聚焦范围有限，所以当页面过宽时，用户的浏览和操作成本会增加；而当页面过窄时（如用户同时开启两个浏览器对比查看商品搜索结果），自适应则会导致布局变形和内容错乱。给页面规定宽度可以避免这些问题。
• 在综合考虑当下主流分辨率情况、浏览器外观对显示空间的占用、人机工程学中对水平视角和聚焦范围的规定以及8px单位等多种因素后，我们认为960px是一个相对更加合理的页面宽度。在阿里巴巴中文网站中，推荐使用定宽960px的页面，去除左右各4px的边距，中间的可视宽度为952px。

Primitive Types
boolean
byte
char
short, int, long
float, double

Reference Types
Object   (superclass of all other classes)
String
arrays, classes, interfaces

Conversions

// int to String
int x = 123;
String y = Integer.toString(x);  // y is "123"

// String to int
y = "456";
x = Integer.parseInt(y);   // x is 456

// double to int
double z = 3.5;
x = (int) z;   // x is 3  (truncates decimal)

Value Types
bool
byte, sbyte
char
short, ushort, int, uint, long, ulong
float, double, decimal
structures, enumerations

Reference Types
object    (superclass of all other classes)
string
arrays, classes, interfaces, delegates

Convertions

// int to string
int x = 123;
String y = x.ToString();  // y is "123"

// string to int
y = "456";
x = int.Parse(y);   // or x = Convert.ToInt32(y);

// double to int
double z = 3.5;
x = (int) z;   // x is 3  (truncates decimal)

// Can be set to a const or a variable. May be initialized in a constructor.
readonly int MAX_HEIGHT = 9;

enum Action {Start, Stop, Rewind, Forward};

// Special type of class
enum Status {
  Flunk(50), Pass(70), Excel(90);
  private final int value;
  Status(int value) { this.value = value; }
  public int value() { return value; }
};

Action a = Action.Stop;
if (a != Action.Start)
  System.out.println(a);               // Prints "Stop"

Status s = Status.Pass;
System.out.println(s.value());      // Prints "70"

enum Action {Start, Stop, Rewind, Forward};

enum Status {Flunk = 50, Pass = 70, Excel = 90};

No equivalent.





Action a = Action.Stop;
if (a != Action.Start)
  Console.WriteLine(a);             // Prints "Stop"

Status s = Status.Pass;
Console.WriteLine((int) s);       // Prints "70"

Comparison
==  <  >  <=  >=  !=

Arithmetic
+  -  *  /
%  (mod)
/   (integer division if both operands are ints)
Math.Pow(x, y)

Assignment
=  +=  -=  *=  /=   %=   &=  |=  ^=  <<=  >>=  >>>=  ++  --

Bitwise
&  |  ^   ~  <<  >>  >>>

Logical
&&  ||  &  |   ^   !

Note: && and || perform short-circuit logical evaluations

String Concatenation
+

Comparison
==  <  >  <=  >=  !=

Arithmetic
+  -  *  /
%  (mod)
/   (integer division if both operands are ints)
Math.Pow(x, y)

Assignment
=  +=  -=  *=  /=   %=  &=  |=  ^=  <<=  >>=  ++  --

Bitwise
&  |  ^   ~  <<  >>

Logical
&&  ||  &  |   ^   !

Note: && and || perform short-circuit logical evaluations

String Concatenation
+

greeting = age < 20 ? "What's up?" : "Hello";

if (x < y)
  System.out.println("greater");

if (x != 100) {    
  x *= 5;
  y *= 2;
}
else
  z *= 6;

int selection = 2;
switch (selection) {     // Must be byte, short, int, char, or enum
  case 1: x++;            // Falls through to next case if no break
  case 2: y++;   break;
  case 3: z++;   break;
  default: other++;
}

greeting = age < 20 ? "What's up?" : "Hello";

if (x < y)  
  Console.WriteLine("greater");

if (x != 100) {    
  x *= 5;
  y *= 2;
}
else
  z *= 6;

string color = "red";
switch (color) {                          // Can be any predefined type
  case "red":    r++;    break;       // break is mandatory; no fall-through
  case "blue":   b++;   break;
  case "green": g++;   break;
  default: other++;     break;       // break necessary on default
}

while (i < 10)
  i++;

for (i = 2; i <= 10; i += 2)
  System.out.println(i);

do
  i++;
while (i < 10);

for (int i : numArray)  // foreach construct  
  sum += i;

// for loop can be used to iterate through any Collection
import java.util.ArrayList;
ArrayList<Object> list = new ArrayList<Object>();
list.add(10);    // boxing converts to instance of Integer
list.add("Bisons");
list.add(2.3);    // boxing converts to instance of Double

for (Object o : list)
  System.out.println(o);

while (i < 10)
  i++;

for (i = 2; i <= 10; i += 2)
  Console.WriteLine(i);

do
  i++;
while (i < 10);

foreach (int i in numArray)  
  sum += i;

// foreach can be used to iterate through any collection
using System.Collections;
ArrayList list = new ArrayList();
list.Add(10);
list.Add("Bisons");
list.Add(2.3);

foreach (Object o in list)
  Console.WriteLine(o);

int[][] jagged = new int[5][];
jagged[0] = new int[5];
jagged[1] = new int[2];
jagged[2] = new int[3];
jagged[0][4] = 5;

int[][] jagged = new int[3][] {
    new int[5], new int[2], new int[3] };
jagged[0][4] = 5;

// Primitive types and references are always passed by value
void TestFunc(int x, Point p) {
   x++;
   p.x++;       // Modifying property of the object
   p = null;    // Remove local reference to object
}

class Point {
   public int x, y;
}

Point p = new Point();
p.x = 2;
int a = 1;
TestFunc(a, p);
System.out.println(a + " " + p.x + " " + (p == null) );  // 1 3 false

// Accept variable number of arguments
int Sum(int ... nums) {
  int sum = 0;
  for (int i : nums)
    sum += i;
  return sum;
}

int total = Sum(4, 3, 2, 1);   // returns 10

// Pass by value (default), in/out-reference (ref), and out-reference (out)
void TestFunc(int x, ref int y, out int z, Point p1, ref Point p2) {
   x++;  y++;  z = 5;
   p1.x++;       // Modifying property of the object      
   p1 = null;    // Remove local reference to object
   p2 = null;   // Free the object
}

class Point {
   public int x, y;
}

Point p1 = new Point();
Point p2 = new Point();
p1.x = 2;
int a = 1, b = 1, c;   // Output param doesn't need initializing
TestFunc(a, ref b, out c, p1, ref p2);
Console.WriteLine("{0} {1} {2} {3} {4}",
   a, b, c, p1.x, p2 == null);   // 1 2 5 3 True

// Accept variable number of arguments
int Sum(params int[] nums) {
  int sum = 0;
  foreach (int i in nums)
    sum += i;
  return sum;
}

int total = Sum(4, 3, 2, 1);   // returns 10

// String concatenation
String school = "Harding ";
school = school + "University";   // school is "Harding University"

// String comparison
String mascot = "Bisons";
if (mascot == "Bisons")    // Not the correct way to do string comparisons
if (mascot.equals("Bisons"))   // true
if (mascot.equalsIgnoreCase("BISONS"))   // true
if (mascot.compareTo("Bisons") == 0)   // true

System.out.println(mascot.substring(2, 5));   // Prints "son"

// My birthday: Oct 12, 1973
java.util.Calendar c = new java.util.GregorianCalendar(1973, 10, 12);
String s = String.format("My birthday: %1$tb %1$te, %1$tY", c);

// Mutable string
StringBuffer buffer = new StringBuffer("two ");
buffer.append("three ");
buffer.insert(0, "one ");
buffer.replace(4, 7, "TWO");
System.out.println(buffer);     // Prints "one TWO three"

// String concatenation
string school = "Harding ";
school = school + "University";   // school is "Harding University"

// String comparison
string mascot = "Bisons";
if (mascot == "Bisons")    // true
if (mascot.Equals("Bisons"))   // true
if (mascot.ToUpper().Equals("BISONS"))   // true
if (mascot.CompareTo("Bisons") == 0)    // true

Console.WriteLine(mascot.Substring(2, 3));    // Prints "son"

// My birthday: Oct 12, 1973
DateTime dt = new DateTime(1973, 10, 12);
string s = "My birthday: " + dt.ToString("MMM dd, yyyy");

// Mutable string
System.Text.StringBuilder buffer = new System.Text.StringBuilder("two ");
buffer.Append("three ");
buffer.Insert(0, "one ");
buffer.Replace("two", "TWO");
Console.WriteLine(buffer);     // Prints "one TWO three"

// Must be in a method that is declared to throw this exception
Exception ex = new Exception("Something is really wrong.");
throw ex;  

try {
  y = 0;
  x = 10 / y;
} catch (Exception ex) {
  System.out.println(ex.getMessage());
} finally {
  // Code that always gets executed
}

Exception up = new Exception("Something is really wrong.");
throw up;  // ha ha

try {
  y = 0;
  x = 10 / y;
} catch (Exception ex) {      // Variable "ex" is optional
  Console.WriteLine(ex.Message);
} finally {
  // Code that always gets executed
}

package harding.compsci.graphics;

import harding.compsci.graphics.Rectangle;  // Import single class

import harding.compsci.graphics.*;   // Import all classes

namespace Harding.Compsci.Graphics {
  ...
}

or

namespace Harding {
  namespace Compsci {
    namespace Graphics {
      ...
    }
  }
}

// Import all class. Can't import single class.
using Harding.Compsci.Graphics;

Accessibility keywords
public
private
protected
static

// Inheritance
class FootballGame extends Competition {
  ...
}

// Interface definition
interface IAlarmClock {
  ...
}

// Extending an interface
interface IAlarmClock extends IClock {
  ...
}

// Interface implementation
class WristWatch implements IAlarmClock, ITimer {
   ...
}

Accessibility keywords
public
private
internal
protected
protected internal
static

// Inheritance
class FootballGame : Competition {
  ...
}

// Interface definition
interface IAlarmClock {
  ...
}

// Extending an interface
interface IAlarmClock : IClock {
  ...
}

// Interface implementation
class WristWatch : IAlarmClock, ITimer {
   ...
}

class SuperHero {
  private int mPowerLevel;

  public SuperHero() {
    mPowerLevel = 0;
  }

  public SuperHero(int powerLevel) {
    this.mPowerLevel= powerLevel;
  }

  // No destructors, just override the finalize method
  protected void finalize() throws Throwable {
    super.finalize();   // Always call parent's finalizer  
  }
}

class SuperHero {
  private int mPowerLevel;

  public SuperHero() {
     mPowerLevel = 0;
  }

  public SuperHero(int powerLevel) {
    this.mPowerLevel= powerLevel;
  }

  ~SuperHero() {
    // Destructor code to free unmanaged resources.
    // Implicitly creates a Finalize method.
  }
}

SuperHero hero = new SuperHero();

hero.setName("SpamMan");
hero.setPowerLevel(3);

hero.Defend("Laura Jones");
SuperHero.Rest();  // Calling static method

SuperHero hero2 = hero;   // Both refer to same object
hero2.setName("WormWoman");
System.out.println(hero.getName());  // Prints WormWoman

hero = null;   // Free the object

if (hero == null)
  hero = new SuperHero();

Object obj = new SuperHero();
System.out.println("object's type: " + obj.getClass().toString());
if (obj instanceof SuperHero)
  System.out.println("Is a SuperHero object.");

SuperHero hero = new SuperHero();

hero.Name = "SpamMan";
hero.PowerLevel = 3;

hero.Defend("Laura Jones");
SuperHero.Rest();   // Calling static method

SuperHero hero2 = hero;   // Both refer to same object
hero2.Name = "WormWoman";
Console.WriteLine(hero.Name);   // Prints WormWoman

hero = null ;   // Free the object

if (hero == null)
  hero = new SuperHero();

Object obj = new SuperHero();
Console.WriteLine("object's type: " + obj.GetType().ToString());
if (obj is SuperHero)
  Console.WriteLine("Is a SuperHero object.");

private int mSize;

public int getSize() { return mSize; }
public void setSize(int value) {
  if (value < 0)
    mSize = 0;
  else
    mSize = value;
}

int s = shoe.getSize();
shoe.setSize(s+1);

private int mSize;

public int Size {
  get { return mSize; }
  set {
    if (value < 0)
      mSize = 0;
    else
      mSize = value;
  }
}

shoe.Size++;

No structs in Java.

int c = System.in.read();   // Read single char
System.out.println(c);      // Prints 65 if user enters "A"

// The studio costs $499.00 for 3 months.
System.out.printf("The %s costs $%.2f for %d months.%n", "studio", 499.0, 3);

// Today is 06/25/04
System.out.printf("Today is %tD\n", new java.util.Date());

int c = Console.Read();  // Read single char
Console.WriteLine(c);    // Prints 65 if user enters "A"

// The studio costs $499.00 for 3 months.
Console.WriteLine("The {0} costs {1:C} for {2} months.\n", "studio", 499.0, 3);

// Today is 06/25/2004
Console.WriteLine("Today is " + DateTime.Now.ToShortDateString());

import java.io.*;

// Character stream writing
FileWriter writer = new FileWriter("c:\\myfile.txt");
writer.write("Out to file.\n");
writer.close();

// Character stream reading
FileReader reader = new FileReader("c:\\myfile.txt");
BufferedReader br = new BufferedReader(reader);
String line = br.readLine();
while (line != null) {
  System.out.println(line);
  line = br.readLine();
}
reader.close();

// Binary stream writing
FileOutputStream out = new FileOutputStream("c:\\myfile.dat");
out.write("Text data".getBytes());
out.write(123);
out.close();

// Binary stream reading
FileInputStream in = new FileInputStream("c:\\myfile.dat");
byte buff[] = new byte[9];
in.read(buff, 0, 9);   // Read first 9 bytes into buff
String s = new String(buff);
int num = in.read();   // Next is 123
in.close();

using System.IO;

// Character stream writing
StreamWriter writer = File.CreateText("c:\\myfile.txt");
writer.WriteLine("Out to file.");
writer.Close();

// Character stream reading
StreamReader reader = File.OpenText("c:\\myfile.txt");
string line = reader.ReadLine();
while (line != null) {
  Console.WriteLine(line);
  line = reader.ReadLine();
}
reader.Close();

// Binary stream writing
BinaryWriter out = new BinaryWriter(File.OpenWrite("c:\\myfile.dat"));
out.Write("Text data");
out.Write(123);
out.Close();

// Binary stream reading
BinaryReader in = new BinaryReader(File.OpenRead("c:\\myfile.dat"));
string s = in.ReadString();
int num = in.ReadInt32();
in.Close();