﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>BlogJava-小 猪 宝 贝-随笔分类-Java Programming</title><link>http://www.blogjava.net/selina/category/538.html</link><description>&lt;hr&gt;
&lt;div align="center"&gt;&lt;a href="http://www.blogjava.net/selina/"&gt;..::[Selina ★ AlleNny]::..&lt;/a&gt;&lt;/div&gt;
&lt;br&gt;
Sunny day with the rain together&lt;br&gt;
像苦与甜交织的景色&lt;br&gt;
春天的花冬天的寒冷&lt;br&gt;
都是色彩缤纷的人生&lt;br&gt;
&lt;br&gt;
Sunny day with the rain together&lt;br&gt;
时间转动着古老的缘份&lt;br&gt;
黑暗的夜明亮的早晨&lt;br&gt;
那都是我们丰盛的旅程&lt;br&gt;
&lt;br&gt;
&lt;div align="center"&gt;&lt;a href="http://www.flashempire.com/top10/top10play.php?id=1881"&gt;Turn Left Turn Right&lt;/a&gt;&lt;/div&gt;</description><language>zh-cn</language><lastBuildDate>Tue, 14 Aug 2007 16:06:17 GMT</lastBuildDate><pubDate>Tue, 14 Aug 2007 16:06:17 GMT</pubDate><ttl>60</ttl><item><title>既有鱼肉又有熊掌——浅尝ListOrderedMap</title><link>http://www.blogjava.net/selina/archive/2007/08/14/136692.html</link><dc:creator>Selina</dc:creator><author>Selina</author><pubDate>Tue, 14 Aug 2007 07:30:00 GMT</pubDate><guid>http://www.blogjava.net/selina/archive/2007/08/14/136692.html</guid><wfw:comment>http://www.blogjava.net/selina/comments/136692.html</wfw:comment><comments>http://www.blogjava.net/selina/archive/2007/08/14/136692.html#Feedback</comments><slash:comments>2</slash:comments><wfw:commentRss>http://www.blogjava.net/selina/comments/commentRss/136692.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/selina/services/trackbacks/136692.html</trackback:ping><description><![CDATA[<p><font style="BACKGROUND-COLOR: #ece9d8">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 要有序可以用List，要便于查找可以用Map，那既要有序又便于查找呢？<br></font></p>
<p><font style="BACKGROUND-COLOR: #ece9d8">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 最近我就遇到了这样一个问题，Java没有给我们提供现成的类，我们完全可以自己开发个类继承List和Map（Java原来就有不可以同时继承List和Map的Bug，因此特意去看了下这个Bug的状态——Closed，呵呵，应该是很老的版本才有的问题，用新版本的朋友不用担心会遇到这个问题），但是完全没必要白花那个力气，因为Apache的<strong>Commons Collections</strong>的Jar包里已经为我们提供了一个相当完备的类来满足我们这样的要求完全是绰绰有余。因此我们现在要做的仅仅是引入Jar包，然后使用这个现成的好东西——<strong>ListOrderedMap</strong>就可以啦。<br></font></p>
<p><font style="BACKGROUND-COLOR: #ece9d8">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;让我们来看看代码：</font><font style="BACKGROUND-COLOR: #ece9d8"></p>
<div style="BORDER-RIGHT: #cccccc 1px solid; PADDING-RIGHT: 5px; BORDER-TOP: #cccccc 1px solid; PADDING-LEFT: 4px; FONT-SIZE: 13px; PADDING-BOTTOM: 4px; BORDER-LEFT: #cccccc 1px solid; WIDTH: 98%; WORD-BREAK: break-all; PADDING-TOP: 4px; BORDER-BOTTOM: #cccccc 1px solid; BACKGROUND-COLOR: #eeeeee"><img src="http://www.blogjava.net/Images/OutliningIndicators/None.gif" align=top><span style="COLOR: #000000">ListOrderedMap&nbsp;list&nbsp;</span><span style="COLOR: #000000">=</span><span style="COLOR: #000000">&nbsp;</span><span style="COLOR: #0000ff">new</span><span style="COLOR: #000000">&nbsp;ListOrderedMap();<br><img id=Codehighlighter1_81_123_Open_Image onclick="this.style.display='none'; Codehighlighter1_81_123_Open_Text.style.display='none'; Codehighlighter1_81_123_Closed_Image.style.display='inline'; Codehighlighter1_81_123_Closed_Text.style.display='inline';" src="http://www.blogjava.net/Images/OutliningIndicators/ExpandedBlockStart.gif" align=top><img id=Codehighlighter1_81_123_Closed_Image style="DISPLAY: none" onclick="this.style.display='none'; Codehighlighter1_81_123_Closed_Text.style.display='none'; Codehighlighter1_81_123_Open_Image.style.display='inline'; Codehighlighter1_81_123_Open_Text.style.display='inline';" src="http://www.blogjava.net/Images/OutliningIndicators/ContractedBlock.gif" align=top></span><span style="COLOR: #0000ff">for</span><span style="COLOR: #000000">(</span><span style="COLOR: #0000ff">int</span><span style="COLOR: #000000">&nbsp;i&nbsp;</span><span style="COLOR: #000000">=</span><span style="COLOR: #000000">&nbsp;</span><span style="COLOR: #000000">0</span><span style="COLOR: #000000">;&nbsp;i&nbsp;</span><span style="COLOR: #000000">&lt;</span><span style="COLOR: #000000">&nbsp;objs.length;&nbsp;i</span><span style="COLOR: #000000">++</span><span style="COLOR: #000000">)&nbsp;</span><span id=Codehighlighter1_81_123_Closed_Text style="BORDER-RIGHT: #808080 1px solid; BORDER-TOP: #808080 1px solid; DISPLAY: none; BORDER-LEFT: #808080 1px solid; BORDER-BOTTOM: #808080 1px solid; BACKGROUND-COLOR: #ffffff"><img src="http://www.blogjava.net/Images/dot.gif"></span><span id=Codehighlighter1_81_123_Open_Text><span style="COLOR: #000000">{<br><img src="http://www.blogjava.net/Images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;list.put(objs[i].getId(),&nbsp;objs[i]);<br><img src="http://www.blogjava.net/Images/OutliningIndicators/ExpandedBlockEnd.gif" align=top>}</span></span></div>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 初始化很简单吧，没有一点技术难度，往里边放数据和Map没一点区别，需要注意的是Map我们可以在初始化的时候加上类型，比如Map&lt;String, String&gt;，但是ListOrderedMap不可以，就这么点差别，要记得哦。但是这个差别也是ListOrderedMap让人最不满意的地方，因为这说明他是类型不安全的。<br></p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 接下来，看看我们都用到了ListOrderedMap的哪些方法：</p>
<div style="BORDER-RIGHT: #cccccc 1px solid; PADDING-RIGHT: 5px; BORDER-TOP: #cccccc 1px solid; PADDING-LEFT: 4px; FONT-SIZE: 13px; PADDING-BOTTOM: 4px; BORDER-LEFT: #cccccc 1px solid; WIDTH: 98%; WORD-BREAK: break-all; PADDING-TOP: 4px; BORDER-BOTTOM: #cccccc 1px solid; BACKGROUND-COLOR: #eeeeee"><img src="http://www.blogjava.net/Images/OutliningIndicators/None.gif" align=top><span style="COLOR: #0000ff">int</span><span style="COLOR: #000000">&nbsp;themeId&nbsp;</span><span style="COLOR: #000000">=</span><span style="COLOR: #000000">&nbsp;((Obj)&nbsp;list.getValue(</span><span style="COLOR: #000000">0</span><span style="COLOR: #000000">)).getThemeId();<br><img src="http://www.blogjava.net/Images/OutliningIndicators/None.gif" align=top></span><span style="COLOR: #0000ff">int</span><span style="COLOR: #000000">&nbsp;index&nbsp;</span><span style="COLOR: #000000">=</span><span style="COLOR: #000000">&nbsp;list.indexOf(key);<br><img id=Codehighlighter1_113_148_Open_Image onclick="this.style.display='none'; Codehighlighter1_113_148_Open_Text.style.display='none'; Codehighlighter1_113_148_Closed_Image.style.display='inline'; Codehighlighter1_113_148_Closed_Text.style.display='inline';" src="http://www.blogjava.net/Images/OutliningIndicators/ExpandedBlockStart.gif" align=top><img id=Codehighlighter1_113_148_Closed_Image style="DISPLAY: none" onclick="this.style.display='none'; Codehighlighter1_113_148_Closed_Text.style.display='none'; Codehighlighter1_113_148_Open_Image.style.display='inline'; Codehighlighter1_113_148_Open_Text.style.display='inline';" src="http://www.blogjava.net/Images/OutliningIndicators/ContractedBlock.gif" align=top></span><span style="COLOR: #0000ff">if</span><span style="COLOR: #000000">&nbsp;(index&nbsp;</span><span style="COLOR: #000000">==</span><span style="COLOR: #000000">&nbsp;list.size()&nbsp;</span><span style="COLOR: #000000">-</span><span style="COLOR: #000000">&nbsp;</span><span style="COLOR: #000000">1</span><span style="COLOR: #000000">)&nbsp;</span><span id=Codehighlighter1_113_148_Closed_Text style="BORDER-RIGHT: #808080 1px solid; BORDER-TOP: #808080 1px solid; DISPLAY: none; BORDER-LEFT: #808080 1px solid; BORDER-BOTTOM: #808080 1px solid; BACKGROUND-COLOR: #ffffff"><img src="http://www.blogjava.net/Images/dot.gif"></span><span id=Codehighlighter1_113_148_Open_Text><span style="COLOR: #000000">{<br><img src="http://www.blogjava.net/Images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;obj</span><span style="COLOR: #000000">=</span><span style="COLOR: #000000">&nbsp;(Obj)&nbsp;list.getValue(</span><span style="COLOR: #000000">0</span><span style="COLOR: #000000">);<br><img id=Codehighlighter1_172_215_Open_Image onclick="this.style.display='none'; Codehighlighter1_172_215_Open_Text.style.display='none'; Codehighlighter1_172_215_Closed_Image.style.display='inline'; Codehighlighter1_172_215_Closed_Text.style.display='inline';" src="http://www.blogjava.net/Images/OutliningIndicators/ExpandedBlockStart.gif" align=top><img id=Codehighlighter1_172_215_Closed_Image style="DISPLAY: none" onclick="this.style.display='none'; Codehighlighter1_172_215_Closed_Text.style.display='none'; Codehighlighter1_172_215_Open_Image.style.display='inline'; Codehighlighter1_172_215_Open_Text.style.display='inline';" src="http://www.blogjava.net/Images/OutliningIndicators/ContractedBlock.gif" align=top>}</span></span><span style="COLOR: #000000">&nbsp;</span><span style="COLOR: #0000ff">else</span><span style="COLOR: #000000">&nbsp;</span><span style="COLOR: #0000ff">if</span><span style="COLOR: #000000">&nbsp;(index&nbsp;</span><span style="COLOR: #000000">!=</span><span style="COLOR: #000000">&nbsp;</span><span style="COLOR: #000000">-</span><span style="COLOR: #000000">1</span><span style="COLOR: #000000">)&nbsp;</span><span id=Codehighlighter1_172_215_Closed_Text style="BORDER-RIGHT: #808080 1px solid; BORDER-TOP: #808080 1px solid; DISPLAY: none; BORDER-LEFT: #808080 1px solid; BORDER-BOTTOM: #808080 1px solid; BACKGROUND-COLOR: #ffffff"><img src="http://www.blogjava.net/Images/dot.gif"></span><span id=Codehighlighter1_172_215_Open_Text><span style="COLOR: #000000">{<br><img src="http://www.blogjava.net/Images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;obj</span><span style="COLOR: #000000">=</span><span style="COLOR: #000000">&nbsp;(Obj)&nbsp;list.getValue(index&nbsp;</span><span style="COLOR: #000000">+</span><span style="COLOR: #000000">&nbsp;</span><span style="COLOR: #000000">1</span><span style="COLOR: #000000">);<br><img src="http://www.blogjava.net/Images/OutliningIndicators/ExpandedBlockEnd.gif" align=top>}</span></span></div>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <strong>getValue(int index)</strong>直接根据Index取得Value，当然也可以直接根据Index取得Key值，方法名可不是getKey(int index)，而是直接<strong>get(int index)</strong>就可以啦。接着我们想取到当前Key值后面一个Key值所对应的Value，首先用<strong>indexOf(Object key)</strong>取得Index，然后计算其后面的Index再根据此Index取值。如果想取得当前Key值后面一个Key值，则不必要先取Index，这么麻烦，ListOrderedMap里有直接的方法可以取得当前Key值的前一个Key值和后一Key值，分别是<strong>previousKey(Object key)</strong>方法和<strong>nextKey(Object key)</strong>方法，返回null值表示到头（或尾）了，或者没有找到和当前Key值匹配的Key值&nbsp;。个至于这边为什么要有If和Else if，原因很简单，和一般的索引一样，返回值是-1就表示没有找到。我们在这里做了一个循环，而且我的这个ListOrderedMap的数列是确保长度大于0的，所以我把index==list.size()-1的判断放在了前边，如果不能确定长度是否大于0，还是先判断返回值是否为-1为好。<br></p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 本文只简单介绍了ListOrderedMap的几种比较实用的方法，其他方法使用方法可以参考Apache网站上的相关API：<a href="http://commons.apache.org/collections/api-release/index.html">http://commons.apache.org/collections/api-release/index.html</a></p>
<p>&nbsp;</p>
</font>
<img src ="http://www.blogjava.net/selina/aggbug/136692.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/selina/" target="_blank">Selina</a> 2007-08-14 15:30 <a href="http://www.blogjava.net/selina/archive/2007/08/14/136692.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>手机上J2ME的3D编程－简单创建3D立方体</title><link>http://www.blogjava.net/selina/archive/2006/03/10/34622.html</link><dc:creator>Selina</dc:creator><author>Selina</author><pubDate>Fri, 10 Mar 2006 03:07:00 GMT</pubDate><guid>http://www.blogjava.net/selina/archive/2006/03/10/34622.html</guid><wfw:comment>http://www.blogjava.net/selina/comments/34622.html</wfw:comment><comments>http://www.blogjava.net/selina/archive/2006/03/10/34622.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/selina/comments/commentRss/34622.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/selina/services/trackbacks/34622.html</trackback:ping><description><![CDATA[&nbsp;&nbsp;&nbsp;&nbsp; 摘要: 在现实生活中，我们所看到的是一个3维系统。透过双眼，可以看到的是一个丰富多彩的世界。我们所用的照相机，能够拍出很多漂亮的图片。拍摄每张图片时，可以根据拍摄距离的远近可以调整所拍摄画面上的内容。 在虚拟的世界里，可以模拟真实世界。欲将虚拟世界展示出来，就要利用一个虚拟的照相机，将虚拟的世界拍摄出来。 在JSR-184中，虚拟的世界是由World类构造的。虚拟的照相机是Camera类。通过Camera...&nbsp;&nbsp;<a href='http://www.blogjava.net/selina/archive/2006/03/10/34622.html'>阅读全文</a><img src ="http://www.blogjava.net/selina/aggbug/34622.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/selina/" target="_blank">Selina</a> 2006-03-10 11:07 <a href="http://www.blogjava.net/selina/archive/2006/03/10/34622.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>「读书笔记」Thinking in Java 3rd Edition - 8: Interfaces &amp; Inner Classes</title><link>http://www.blogjava.net/selina/archive/2005/07/28/8600.html</link><dc:creator>Selina</dc:creator><author>Selina</author><pubDate>Thu, 28 Jul 2005 02:47:00 GMT</pubDate><guid>http://www.blogjava.net/selina/archive/2005/07/28/8600.html</guid><wfw:comment>http://www.blogjava.net/selina/comments/8600.html</wfw:comment><comments>http://www.blogjava.net/selina/archive/2005/07/28/8600.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/selina/comments/commentRss/8600.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/selina/services/trackbacks/8600.html</trackback:ping><description><![CDATA[<P><STRONG><FONT size=5>8: Interfaces &amp; Inner Classes（接口与内部类）<BR></FONT></STRONG><BR><STRONG><FONT size=4>接口（interface）</FONT></STRONG><BR>当你implements一个interface的时候，你必须把这个interface的方法定义成public的。如果你不这么做，那它就会变成package权限的，这样经过继承，这些方法的访问权限就会受到限制，而这是Java的编译器所不允许的。<BR><STRONG><EM>Java的“多重继承”<BR></EM></STRONG>interface既给了你abstract类的好处，又给了你interface的好处，因此只要基类的设计里面可以不包括妇女干法和成员变量的定义，你就应该优先使用interface。<BR><STRONG><EM>合并接口时的名字冲突<BR></EM></STRONG>在合并的接口里面放上同名方法，通常也会破坏程序的可读性。<BR><STRONG><EM>用继承扩展interface</EM></STRONG><BR>通常情况下，extends只能用于类，但是由于一个interface可以由多个接口拼接而成，因此创建新的interface的时候可以用extends来表示其多个“基接口（base interfaces）”。interface的名字要由逗号分隔。<BR><STRONG><EM>常量的分组<BR></EM></STRONG>interface是一种非常方便的，创建一组常量值的工具。<BR>这种方法通常被称为使用“神奇数字”，并且使得代码的维护变得非常困难。<BR><STRONG><EM>初始化接口中的数据成员<BR></EM></STRONG>这些数据都不算是接口的组成部分，相反它们保存在这个接口的静态存储区内。<BR><STRONG><EM>接口的嵌套</EM></STRONG><BR>实现private接口就成了一种“强制你区定义那个接口的方法，但是又不让你添加任何类型信息（也就是说不允许上传）”的手段了。<BR>接口与接口也可以嵌套，不过接口的规则仍然有效——特别是接口的所有元素都必须是public的这条，因此嵌套在接口中的接口也都自动是public的，它们不能是private的。<BR>特别要注意的是，实现接口的时候，不一定要实现嵌套在里面的接口。同样private接口只能在定义它的类里实现。<BR><BR><STRONG><FONT size=4>内部类<BR></FONT></STRONG>内部类是一种非常有价值的特性，它能让你在逻辑上将相互从属的类组织起来，并且在类的内部控制访问权限。但是切记，内部类和合成是截然不同的，这一点非常重要。<BR><STRONG><EM>内部类与上传</EM></STRONG><BR>普通类（非内部类）是不能被定义成private或protected的；它们只可能是public或package权限的。<BR><STRONG><EM>在方法和作用域里的内部类</EM></STRONG><BR>内部类可以被创建在方法内部，甚至是任何一个作用领域。这么做有两个理由：<BR>1. 就像前面所说的，你在实现某个接口，这样你才能创建并且返回这个接口的reference。<BR>2. 你正在处理一个复杂的问题，需要创建一个类，但是又不想让大家都知道还有这么一个类。<BR><STRONG><EM>匿名内部类</EM></STRONG><BR>如果你在定义匿名内部类的时候，还要用到外面的对象，那编译就会要求你把这个参数的reference声明成final的。如果你忘了，编译的时候就会报错。<BR>实际上实例初始化过程就是匿名内部类的构造函数。当然，它的功能是有限的；你不能重载实例初始化，因此你只能有一个构造函数。<BR><STRONG><EM>与宿主类的关系<BR>嵌套类</EM></STRONG><BR>如果你不需要这种“内部类对象和宿主类对象之间”的联系，那么你可以把内部类定义成static的。潜逃类的意思是：<BR>1. 无须宿主类的对象就能创建嵌套类的对象。<BR>2. 不能在嵌套类的对象里面访问非static的宿主类对象。<BR>普通内部类的成员数据和方法只能到类的外围这一层，因此普通的内部类里不能有static数据，static数据成员或嵌套类。但是，这些东西嵌套类里都可以有。<BR>普通（非static）的内部类需要使用特殊的this reference来与宿主类对象保持联系。而嵌套类不需要这个this reference，这就使得它与static方法有些相似了。<BR><STRONG><EM>引用宿主类的对象<BR>在多层嵌套的类里向外访问<BR>继承内部类</EM></STRONG><BR>等到要创建构造函数的时候，默认的构造函数玩不转了，你必须传给他宿主类对象的reference。此外，你还必须在构造函数里面使用这种语法：<BR>enclosingClassReference.super();<BR>这样才能提供那个必须的reference，而程序也才能编译通过。<BR><STRONG><EM>内部类可以被覆写吗？<BR>本地内部类（Local inner classes）<BR></EM></STRONG>选择本地内部类而不是匿名内部类的唯一原因就是，你必须创建那种类的对象。<BR><STRONG><EM>内部类的标识符（Inner class identifiers）</EM></STRONG><BR><BR><STRONG><FONT size=4>为什么要有内部类？<BR></FONT></STRONG>每个内部类都可以独立地继承某个“实现（implementation）”。因此，内部类不会受“宿主类是否已经继承了别的实现”的约束。<BR>1. 内部类可以有多个实例，而每个又都可以有它自己的，与宿主类对象无关的状态信息。<BR>2. 一个宿主类里可以放上好几个内部类，它们可以用各自不同的方式来实现同一个interface或继承同一个类。<BR>3. 内部类对象创建的时机与宿主类对象的创建没什么关系。<BR>4. 内部类不存在什么让人头晕的“是”关系；他是一个独立的实体。<BR><STRONG><EM>Closure与回调（Closures &amp; Callbacks）</EM></STRONG><BR>创建内部类的时候，别去扩展或者修改宿主类的接口。<BR><STRONG><EM>内部类与控制框架（Inner classes &amp; control frameworks）<BR></EM></STRONG>1. 在一个类里完整地实现整个控制框架，这样就把“实现”里的所有独一无二东西全部都给封装起来了。内部类则用来表示各种解决具体问题所需的action()。<BR>2. 内部类可以让这个实现看上去不至于太古怪，因为它还可以直接访问宿主类的所有成员。要不是这样的话，代码就会变得非常杂乱，这样到最后你肯定会去找一个替代方案的。<BR><BR><STRONG><FONT size=4>总结<BR></FONT></STRONG><BR><STRONG><FONT size=4>练习</FONT></STRONG></P><img src ="http://www.blogjava.net/selina/aggbug/8600.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/selina/" target="_blank">Selina</a> 2005-07-28 10:47 <a href="http://www.blogjava.net/selina/archive/2005/07/28/8600.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>「读书笔记」Thinking in Java 3rd Edition - 7: Polymorphism</title><link>http://www.blogjava.net/selina/archive/2005/07/26/8469.html</link><dc:creator>Selina</dc:creator><author>Selina</author><pubDate>Tue, 26 Jul 2005 04:58:00 GMT</pubDate><guid>http://www.blogjava.net/selina/archive/2005/07/26/8469.html</guid><wfw:comment>http://www.blogjava.net/selina/comments/8469.html</wfw:comment><comments>http://www.blogjava.net/selina/archive/2005/07/26/8469.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/selina/comments/commentRss/8469.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/selina/services/trackbacks/8469.html</trackback:ping><description><![CDATA[<P><STRONG><FONT size=5>7: Polymorphism（多态性）</FONT></STRONG><BR><BR><STRONG><FONT size=4>再访上传（upcasting）</FONT></STRONG><BR><STRONG><EM>把对象的类型忘掉<BR></EM></STRONG><BR><STRONG><FONT size=4>问题的关键<BR></FONT><EM>方法调用的绑定<BR></EM></STRONG>当绑定发生在程序运行之前时（如果有的话，就是由编译器或连接器负责）被称作“前绑定（early binding）”。<BR>“后绑定（late binding）”的意思是要在程序运行的时候，根据对象的类型来决定该绑定哪个方法。后绑定也被称为“动态绑定（dynamic）”或“运行时绑定（run-time binding）”。<BR>除了static和final方法（private方法隐含有final的意思），Java的所有的方法都采用后绑定。也就是说，通常情况下你不必考虑是不是应该采用后绑定——它是自动的。<BR><STRONG><EM>产生正确的行为<BR>可扩展性<BR>错误：“覆写”private的方法<BR></EM></STRONG>只有非private的方法才能被覆写，别用基类的private方法的名字去命名派生类的方法。<BR><BR><STRONG><FONT size=4>抽象类和抽象方法</FONT></STRONG><BR>如果类包含一个或多个抽象方法，那么这个类就必须被定义成abstract的。（否则编译器就会报错了。）<BR>创建一个不包含abstract方法的abstract类，是完全可以的。这种技巧可以用于“不必创建abstract的方法，但是又要禁止别人创建这个类的对象”的场合。<BR><BR><FONT size=4><STRONG>构造函数与多态性<BR></STRONG><FONT size=3>构造函数不是多态的（实际上他们都是static方法，只是声明的时候没有直说）。</FONT><BR></FONT><EM><STRONG>构造函数的调用顺序</STRONG></EM><BR>复杂对象的构造函数的调用顺序：<BR>1. 调用基类的构造函数。这是一个递归过程，因此会先创建继承体系的根，然后是下一级派生类，以此类推，直到最后一个继承类的构造函数。<BR>2. 成员对象按照其声明的顺序进行初始化。<BR>3. 执行继承类的构造函数的正文。<BR><STRONG><EM>继承与清理</EM></STRONG><BR>对象与对象之间有可能会有依赖关系，因此清理的顺序应该与初始化的顺序相反。对数据成员而言，这就是说它们的清理顺序应该与声明的顺序相反（因为数据的初始化是按照声明的顺序进行的）。对基类而言（它采用了C++拆构函数的形式），你应该先进行派生类的清理，再进行基类的清理。<BR><STRONG><EM>多态方法在构造函数中的行为<BR></EM></STRONG>如果你在构造函数里面调用了动态绑定的方法，那么它会使用那个覆写后的版本。<BR>一个好的构造函数应该，“用最少的工作量把对象的状态设置好，而且要尽可能地避免去调用方法。”构造函数唯一能安全调用的方法，就是基类的final方法。（这一条也适合private方法，因为它自动就是final的。）它们不会被覆写，因此也不会产生这种意外的行为。<BR><BR><STRONG><FONT size=4>用继承来进行设计<BR></FONT></STRONG>使用继承来表示行为的不同，而用成员数据来表示不同的状态。<BR><STRONG><EM>纯继承与扩展<BR>下传与运行时的类型鉴别<BR></EM></STRONG><BR><STRONG><FONT size=4>总结</FONT></STRONG><BR><BR><STRONG><FONT size=4>练习</FONT></STRONG></P>
<P align=right><STRONG><A id=Editor_Edit_hlEntryLink title="view: 「读书笔记」Thinking in Java 3rd Edition - 8: Interfaces & Inner Classes" HREF="/selina/archive/2005/07/28/8600.html" target=_self><STRONG><FONT color=#002c99>「读书笔记」Thinking in Java 3rd Edition - 8: Interfaces & Inner Classes</FONT></STRONG></A></STRONG></P><img src ="http://www.blogjava.net/selina/aggbug/8469.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/selina/" target="_blank">Selina</a> 2005-07-26 12:58 <a href="http://www.blogjava.net/selina/archive/2005/07/26/8469.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>「读书笔记」Thinking in Java 3rd Edition - 6: Reusing Classes</title><link>http://www.blogjava.net/selina/archive/2005/07/20/8024.html</link><dc:creator>Selina</dc:creator><author>Selina</author><pubDate>Wed, 20 Jul 2005 01:49:00 GMT</pubDate><guid>http://www.blogjava.net/selina/archive/2005/07/20/8024.html</guid><wfw:comment>http://www.blogjava.net/selina/comments/8024.html</wfw:comment><comments>http://www.blogjava.net/selina/archive/2005/07/20/8024.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/selina/comments/commentRss/8024.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/selina/services/trackbacks/8024.html</trackback:ping><description><![CDATA[<P><FONT size=5><STRONG>6: Reusing Classes（复用类）<BR></STRONG></FONT><BR>第一种非常简单：在新的类里直接创建旧的类的对象。这被称为合成（compostion）。<BR>第二种方法更为精妙。它会创建一个新的，与原来那个类同属一种类型的类。你全盘接受了就类的形式，在没有对它做修改的情况下往里面添加了新的代码。这种神奇的做法被称为继承（inheritance）。<BR><BR><STRONG><FONT size=4>合成所使用的语法</FONT><BR></STRONG>如果你想对reference进行初始化，那么可以在以下几个时间进行：<BR>1. 在定义对象的时候。这就意味着在构造函数调用之前，它们已经初始化完毕了。<BR>2. 在这个类的构造函数里。<BR>3. 在即将使用那个对象之前。这种做法通常被称为“偷懒初始化（lazy initalization）”。如果碰到创建对象的代价很高，或者不是每次都需要创建对象的时候，这种做法就能降低程序的开销了。<BR><BR><STRONG><FONT size=4>继承所使用的语法<BR></FONT></STRONG>继承设计方面有一条通用准则，那就是把数据都设成private的，把方法都设成public的。当然碰到特殊情况还要进行调整，但是这还是一条非常有用的准则。<BR><STRONG><EM>基类的初始化</EM></STRONG><BR>构造行为是从基类“向外”发展的，所以基类会在派生类的构造函数访问它之前先进行初始化。<BR><EM><STRONG>带参数的构造函数<BR></STRONG></EM>如果类没有默认的构造函数（也就是无参数的构造函数），或者你要调用的基类构造函数是带参数的，你就必须用super关键词以及合适的参数明确地调用基类的构造函数。<BR>对派生类构造函数而言，调用基类的构造函数应该是它做的第一件事。<BR><STRONG><EM>捕获基类构造函数抛出的异常</EM></STRONG><BR>编译器会强制你将基类构造函数的调用放在派生类的构造函数的最前面。<BR><BR><STRONG><FONT size=4>把合成和继承结合起来<BR></FONT></STRONG>虽然编译器会强制你对基类进行初始化，并且会要求你在构造函数的开始部分完成初始化，但是它不会检查你是不是进行了成员对象的初始化，因此你只能自己留神了。<BR><STRONG><EM>确保进行妥善地清理<BR></EM></STRONG>先按照创建对象的相反顺序进行类的清理。（一般来说，这要求留着基类对象以供访问。）然后调用基类的清理方法。<BR>最好不要依赖垃圾回收器去做任何与内存回收无关的事情。如果你要进行清理，一定要自己写清理方法，别去用finalize()。<BR><STRONG><EM>名字的遮盖<BR></EM></STRONG><BR><STRONG><FONT size=4>用合成还是继承</FONT></STRONG><BR>合成与继承都能让你将子对象植入新的类（合成是显式的，继承是隐含的）。<BR>合成用于新类要使用旧类的功能，而不是其接口的场合。也就是说，把对象嵌进去，用它来实现新类的功能，但是用户看到的是新类的接口，而不是嵌进去的对象的接口。因此，你得在新类里嵌入private得就类对象。<BR>有时，让用户直接访问新类的各个组成部分也是合乎情理的；这就是说，将成员对象定义成public。<BR>继承要表达的是一种“是（is-a）”关系，而合成表达的是“有（has-a）”关系。<BR><BR><STRONG><FONT size=4>protected</FONT></STRONG><BR>对用户而言，它是private的，但是如果你想继承这个类，或者开发一个也属于这个package的类的话，就可以访问它了。（Java的protected也提供package的权限。）<BR>最好的做法是，将数据成员设成private的；你应该永远保留修改底层实现的权利，然后用protected权限的方法来控制继承类的访问权限。<BR><BR><STRONG><FONT size=4>渐进式的开发</FONT><BR></STRONG><BR><STRONG><FONT size=4>上传</FONT><BR><EM>为什么叫“上传”？</EM></STRONG><BR>把派生类传给基类就是沿着继承图往上送，因此被称为“上传（upcasting）”。上传总是安全的，因为你是把一个较具体的类型转换成较为一般的类型。也就是说派生类是基类的超集（superset）。它可能会有一些基类所没有的方法，但是它最少要有基类的方法。在上传过程中，类的接口只会减小，不会增大。<BR><STRONG><EM>合成还是继承，再深讨</EM></STRONG><BR>运用继承的时候，你应该尽可能的保守，只有在它能带来很明显的好处的时候，你才能用。在判断该使用合成还是继承的时候，有一个简单的办法，就是问一下你是不是会把新类上传给基类。如果你必须上传，那么继承就是必须的，如果不需要上传，那么就该再看看是不是应该用继承了。<BR><BR><STRONG><FONT size=4>final关键词</FONT></STRONG><BR>设计和效率<BR>final的三种用途：数据（data），方法（method）和类（class）<BR><STRONG><EM>final的数据<BR></EM></STRONG>常量能用于下列两个情况：<BR>1. 可以是“编译时的常量（compile-time constant）”，这样就再也不能改了。<BR>2. 也可以是运行时初始化的值，这个值你以后就不想再改了。<BR>如果是编译时的常量，编译器会把常量放到算式里面；这样编译的时候就能进行计算，因此也就降低了运行时的开销。在Java中这种常量必须是primitive型的，而且要用final关键词表示。这种常量的赋值必须在定义的时候进行。<BR>一个既是static又是final的数据成员会只占据一段内存，并且不可修改。<BR>对primitive来说，final会将这个值定义成常量，但是对于对象的reference而言，final的意思则是这个reference是常量。初始化的时候，一旦将reference连到了某个对象，那么它就再也不能指别的对象了。但是这个对象本身是可以修改的；Java没有提供将某个对象作成常量的方法。（但是你可以自己写一个类，这样就可以把类当作常量了。）这种局限性也体现在数组上，因为它也是一个对象。<BR><STRONG><EM>空白的final的数据（Blank finals）</EM></STRONG><BR>Java能让你创建“空白的final数据（blank finals）”，也就是说把数据成员声明成final的，但却没给初始化的值。碰到这种情况，你必须先进行初始化，在世用空白的final数据成员，而且编译器会强制你这么做。不过，空白的final数据也提供了一种更为灵活的运用final关键词方法，比方说，现在对象里的final数据就能在保持不变性的同时又有所不同了。<BR>你一定得为final数据赋值，要么是在定义数据的时候用一个表达式赋值，要么是在构造函数里面进行赋值。为了确保final数据在使用之前已经进行了初始化，这一要求是强制的。<BR><STRONG><EM>Final的参数<BR></EM></STRONG>Java允许你在参数表中声明参数是final的，这样参数也变成final了。也就是说，你不能在方法里让参数 reference指向另一个对象了。<BR><STRONG><EM>Final方法</EM></STRONG><BR>使用final方法的目的有二。第一，为方法上“锁”，进制派生类进行修改。第二个原因就是效率。<BR><STRONG><EM>final和private</EM></STRONG><BR>如果方法是private的，那它就不属于基类的接口。它只能算是被类隐藏起来的，正好有着相同的名字的代码。如果你在派生类里创建了同名的public或protected，或package权限的方法，那么它们同基类中可能同名的方法，没有任何联系。你并没有覆写那个方法，你只是创建了一个新的方法。<BR><STRONG><EM>Final类</EM></STRONG><BR>把整个类都定义成final的（把final关键词放到类的定义部分的前面）就等于在宣布，你不会去继承这个类，你也不允许别人去继承这个类。<BR>final类的数据可以是final的，也可以不是final的，这要由你来决定。无论类是不是final的，这一条都适用于“将final用于数据的”场合。但是，由于final类精致了继承，覆写方法已经不可能了，因此所有的方法都隐含地变成final了。<BR><STRONG><EM>小心使用final</EM></STRONG><BR><BR><FONT size=4><STRONG>初始化与类地装载</STRONG><BR></FONT>第一次使用static数据的时候也是进行初始化的时候。装载的时候，static对象和static代码段会按照它们字面的顺序（也就是在程序中出现的顺序）进行初始化。当然static数据只会初始化一次。<BR><STRONG><EM>继承情况下的初始化</EM></STRONG><BR>1. 装载程序。先装载派生类，然后装载基类。<BR>2. 执行“根基类（root base class）”。先是基类的static初始化，然后是派生类的static初始化。<BR>3. 创建对象。首先，primitive都会被设成它们的缺省值，而reference也会被设成null。然后，调用基类的构造函数，再调用派生类的构造函数。<BR><BR><STRONG><FONT size=4>总结<BR></FONT></STRONG><BR><STRONG><FONT size=4>练习</FONT></STRONG></P>
<P align=right><STRONG><A id=Editor_Edit_hlEntryLink title="view: 「读书笔记」Thinking in Java 3rd Edition - 7: Polymorphism" HREF="/selina/archive/2005/07/26/8469.html" target=_self><STRONG><FONT color=#002c99>「读书笔记」Thinking in Java 3rd Edition - 7: Polymorphism</FONT></STRONG></A></STRONG></P><img src ="http://www.blogjava.net/selina/aggbug/8024.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/selina/" target="_blank">Selina</a> 2005-07-20 09:49 <a href="http://www.blogjava.net/selina/archive/2005/07/20/8024.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>「读书笔记」Thinking in Java 3rd Edition - 5: Hiding the Implementation</title><link>http://www.blogjava.net/selina/archive/2005/07/12/7553.html</link><dc:creator>Selina</dc:creator><author>Selina</author><pubDate>Tue, 12 Jul 2005 09:38:00 GMT</pubDate><guid>http://www.blogjava.net/selina/archive/2005/07/12/7553.html</guid><wfw:comment>http://www.blogjava.net/selina/comments/7553.html</wfw:comment><comments>http://www.blogjava.net/selina/archive/2005/07/12/7553.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/selina/comments/commentRss/7553.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/selina/services/trackbacks/7553.html</trackback:ping><description><![CDATA[<P><FONT size=5><STRONG>5: Hiding the Implementation（隐藏实现）<BR></STRONG></FONT><BR><FONT size=4><STRONG>package：类库的单元<BR></STRONG></FONT><STRONG><EM>创建独一无二的package名字<BR></EM></STRONG>Java的约定是package名字的第一部分应该是类的创建者的Internet域名的反写。<BR>使用JAR文件的时候会有一点变化。除了要告诉它该到哪里去找这个JAR文件，你必须将文件名放到CLASSPATH里面。<BR><STRONG><EM>冲突<BR>一个自定义的工具类库<BR>使用import来改变程序的行为方式<BR>使用package的忠告<BR></EM></STRONG><BR><FONT size=4><STRONG>Java的访问控制符</STRONG></FONT><BR><STRONG><EM>package访问权限</EM></STRONG><BR>如果你想让别人能访问到这个成员，那唯一办法就是：<BR>1. 把这个成员做成public的。这样任何人，任何地方就都能访问到它了。<BR>2. 不放任何访问控制符，赋予这个成员package权限，然后往package里面放其它类。这样，这个package的其它类就能访问这个成员了。<BR>3. 继承类除了能访问父类的public成员之外，还可以访问其protected成员（但是不能访问private成员）。只有当两个类都同属一个package的时候，它才能访问package成员。<BR>4. 提供“访问器/修改器”方法（accessor/mutator方法，也被称为“get/set”方法）。以OOP的观点衡量，这是最合理的做法，而且也是JavaBean的基础。<BR><STRONG><EM>public：访问接口的权限<BR>默认的package<BR></EM></STRONG>Java会认为这类文件是属于这个目录的“默认”的，因此对这个目录里边的其它文件来说，它们就都是package权限的了。<BR><STRONG><EM>private：你碰都碰不到！<BR></EM></STRONG>始终如一地使用private还是很重要的，特别是遇到多线程的时候。<BR><STRONG><EM>protect：继承的访问权限</EM></STRONG><BR><BR><STRONG><FONT size=4>接口（Interface）与实现（implementation）<BR><BR>类的访问权限<BR></FONT></STRONG>1. 每个编译单元（文件）只能有一个public类。这么做的意思是，每个编译单元只能有一个公开的接口，而这个接口就由其public类来表示。你可以根据需要，往这个文件里面添加任意多个提供辅助功能的package权限的类。但是如果这个编译单元里面有两个或两个以上的public类的话，编译器就会报错。<BR>2. public类的名字必须和这个编译单元的文件名完全相同，包括大小写。如果你不遵守，编译器又要报错了。<BR>3. 编译单元里面可以没有public类，虽然这种情况不常见，但却是可以的。这是，你就能随意为文件起名字了。<BR><BR><STRONG><FONT size=4>总结</FONT></STRONG><BR><BR><FONT size=4><STRONG>练习<BR></STRONG></FONT></P>
<P align=right><STRONG><A id=Editor_Edit_hlEntryLink title="view: 「读书笔记」Thinking in Java 3rd Edition - 6: Reusing Classes" href="/selina/archive/2005/07/20/8024.html" target=_self><STRONG><FONT color=#002c99>「读书笔记」Thinking in Java 3rd Edition - 6: Reusing Classes</FONT></STRONG></A></STRONG></P><img src ="http://www.blogjava.net/selina/aggbug/7553.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/selina/" target="_blank">Selina</a> 2005-07-12 17:38 <a href="http://www.blogjava.net/selina/archive/2005/07/12/7553.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>「读书笔记」Thinking in Java 3rd Edition - 4: Initialization &amp; Cleanup</title><link>http://www.blogjava.net/selina/archive/2005/07/11/7493.html</link><dc:creator>Selina</dc:creator><author>Selina</author><pubDate>Mon, 11 Jul 2005 03:52:00 GMT</pubDate><guid>http://www.blogjava.net/selina/archive/2005/07/11/7493.html</guid><wfw:comment>http://www.blogjava.net/selina/comments/7493.html</wfw:comment><comments>http://www.blogjava.net/selina/archive/2005/07/11/7493.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/selina/comments/commentRss/7493.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/selina/services/trackbacks/7493.html</trackback:ping><description><![CDATA[<P><STRONG><FONT size=5>4: Initialization &amp; Cleanup（初始化与清理）<BR></FONT></STRONG><BR><FONT size=4><STRONG>用构造函数确保初始化<BR></STRONG></FONT>注意，编程风格要求的方法的首字母要小写的要求不适用于构造函数，因为构造函数的名字必须与类的名字完全相同。<BR>构造函数是一种特殊的方法，它没有返回值。这一点同void型的方法有着本质上的区别，void型的方法什么都不返回，但这是你决定的，你也可以让它返回些什么。而构造函数则什么都不返回，而且你别无选择（new表达式确实会返会返回这个新创建的对象的reference，但是构造函数本身不返回任何值）。如果构造函数能有返回值，而且你还可以选择这个值，那么编译器就要问了，它应该怎样处置这个返回值。<BR><BR><FONT size=4><STRONG>方法的重载</STRONG></FONT><BR><STRONG><EM>区分经过重载的方法</EM></STRONG><BR>即使是参数顺序的颠倒也足以将两个方法区分开来。（不过，通常情况下别用这种办法，因为这会产生难以维护的代码。）<BR><STRONG><EM>对primitive进行重载<BR></EM></STRONG>如果实参（真正调用方法的那个参数）的类型比形参（方法的定义中所声明的参数）的类型小，那么数据会先提升。<BR>如果你传的参数比它大，那么你就只能把它转换成这个类型的值。把类型的名字放在括号里就行了。不这么做，编译器就会报错。<BR><STRONG><EM>用返回值重载</EM></STRONG><BR>调用方法的时候是可以忽略返回值的。由于你并不关心方法调用所返回的值，而只想利用其副作用，因此这通常被称为“为利用其副方法而调用方法（calling a method for its side effect）”。因此，不能用返回值来区分重载的方法。<BR><STRONG><EM>默认的构造函数<BR></EM></STRONG>如果你写了一个没有构造函数的类，那么编译器会自动为你创建一个默认的构造函数。但是，只要定义了构造函数（不管带不带参数），编译器就不会再自动合成默认的构造函数了。<BR>this关键词<BR>this关键词只能用于方法内部，它负责返回调用这个方法的对象的reference。记住，如果你想在别的类的方法里调这个类的方法，那么无须使用this，直接调用就是了。当前对象的this会自动地用于其它方法。this只应用于那些，你明确指明要使用对象的reference的特殊情况。<BR><STRONG><EM>在构造函数里调用构造函数<BR></EM></STRONG>可以用this调用一个构造函数，但是不能调用两个。此外，你还得在程序的最前面调用构造函数，否则编译器就会报错。<BR>参数s的名字和类的数据成员s的名字相同，于是就产生了二义性。你可以用this.s来解决这个问题。它表示你要用类的数据成员。<BR>编译器不会让你在方法里调用构造函数，除非它自己就是构造函数。<BR><EM><STRONG>static的含义<BR></STRONG></EM>类的static方法只能访问其它static方法和static数据成员。<BR>static方法有全局函数的意思，因此它不是面向对象的；你不能用static方法向对象发消息，因为它没有this。如果你发现用了很多static方法，那么你大概得重新思考一下你的设计策略了。<BR><BR><FONT size=4><STRONG>清理：finalization和垃圾回收<BR></STRONG></FONT>1. 对象不一定会被垃圾回收器回收。<BR>2. 垃圾回收不是拆构（destruction）。<BR><STRONG><EM>为什么要有finalize()?</EM></STRONG><BR>3. 垃圾回收只与内存有关。<BR>不论对象是以什么方式创建的，内存释放都是由垃圾回收器负责的。只有在一些非常特殊的场合才会需要用到finalize()，这种场合就是内存是以创建对象以外的形式被分配给对象时。<BR><STRONG><EM>你必须亲自进行清理<BR></EM></STRONG>记住，垃圾回收和finalize()都是靠不住的。只要JVM还没到快要耗尽内存的地步，它是不会浪费时间来回收垃圾以恢复内存的。<BR><STRONG><EM>中止条件<BR>垃圾回收器是如何工作的</EM></STRONG><BR>自适应的，分代的，停止和拷贝，标识和清扫。<BR><BR><STRONG><FONT size=4>成员的初始化<BR></FONT></STRONG>如果变量是在方法内部定义的局部变量，这种保障就表现为编译时的错误信息。<BR><STRONG><EM>指定初始化<BR>用构造函数进行初始化<BR></EM></STRONG>你并没有排除自动的初始化，它在构造函数运行之前就已经完成了。<BR><STRONG><EM>初始化的顺序</EM></STRONG><BR>变量的定义可能分散在类定义的各个地方，并且与方法的定义相互交错，但是变量的初始化会先于任何方法，甚至是构造函数的调用。<BR><STRONG><EM>静态数据的初始化</EM></STRONG><BR>只有创建了第一个对象之后（或者第一次访问static成员的时候），它们才会被初始化。此后，static对象就不会再作初始化了。如果先前没有创建过这种对象，因而其static的成员尚未初始化的话，初始化会先处理其static成员，再处理非static的对象。<BR>1. 第一次创建Dog类的对象（构造函数实际上是static方法），或者第一次，访问Dog类的static的方法或字段的时候，Java解释器会要搜寻classpath，找到Dog.class。<BR>2. 装载了Dog.class之后（创建了Class对象之后），会对所有的static数据进行初始化。这样第一个装载 Class对象的时候，会先进行static成员的初始化。<BR>3. 用new Dog()创建新对象的时候，Dog对象的构建进程会先在堆里为对象分配足够的内存。<BR>4. 这块内存先被清零，这样就自动地把Dog对象的primitive类型的成员赋上缺省的值（对于数字就是零，或者是相应的boolean和char），将reference设成null。<BR>5. 执行定义成员数据时所作的初始化。<BR>6. 执行构造函数。这可能会牵涉到相当多的活动，特别时有继承的时候。<BR><STRONG><EM>显式的静态初始化<BR>非静态的实例初始化</EM></STRONG><BR>这种语法为匿名内部类（anonymous inner class）的初始化提供了必不可少的支持。<BR><BR><FONT size=4><STRONG>数组的初始化</STRONG></FONT><BR><STRONG><EM>多维数据</EM></STRONG><BR><FONT size=4><BR><STRONG>总结<BR><BR>练习<BR></STRONG></FONT></P>
<P align=right><STRONG><A id=Editor_Edit_hlEntryLink title="view: 「读书笔记」Thinking in Java 3rd Edition - 5: Hiding the Implementation" HREF="/selina/archive/2005/07/12/7553.html" target=_self><STRONG><FONT color=#002c99>「读书笔记」Thinking in Java 3rd Edition - 5: Hiding the Implementation</FONT></STRONG></A></STRONG></P><img src ="http://www.blogjava.net/selina/aggbug/7493.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/selina/" target="_blank">Selina</a> 2005-07-11 11:52 <a href="http://www.blogjava.net/selina/archive/2005/07/11/7493.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>「读书笔记」Thinking in Java 3rd Edition - 3: Controlling Program Flow</title><link>http://www.blogjava.net/selina/archive/2005/07/08/7337.html</link><dc:creator>Selina</dc:creator><author>Selina</author><pubDate>Fri, 08 Jul 2005 02:35:00 GMT</pubDate><guid>http://www.blogjava.net/selina/archive/2005/07/08/7337.html</guid><wfw:comment>http://www.blogjava.net/selina/comments/7337.html</wfw:comment><comments>http://www.blogjava.net/selina/archive/2005/07/08/7337.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/selina/comments/commentRss/7337.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/selina/services/trackbacks/7337.html</trackback:ping><description><![CDATA[<P><FONT size=5><STRONG>3: Controlling Program Flow（控制程序流程）<BR><BR></STRONG></FONT><FONT size=4><STRONG>使用Java运算符<BR></STRONG></FONT>几乎所有的运算符都只能作用于primitive。但是‘=’，‘==’，以及‘!=’是例外，它们可以作用于任何对象（由此也是对象方面一个很让人头晕的问题。）此外，String类也支持‘+’和‘+=’。<BR><STRONG><EM>优先级<BR>赋值</EM></STRONG><BR>primitive赋值的时候，是将内容从一个地方直接拷贝到另一个地方。<BR>操控对象就得通过reference来进行操作。当你“在对象之间”进行赋值得时候，实际上你是在拷贝它得reference。<BR><STRONG><EM>方法调用期间的aliasing<BR>数学运算符<BR>正则表达式（Regular expressions）<BR>单元的加号和减号运算符<BR>自动递增与递减<BR></EM></STRONG>对于前置递增和前置递减，（也就是++a和--a），操作过程是会先计算再返回。对于后置递增和后置递减，（也就是a++和a--），操作步骤是先返回再计算。<BR><STRONG><EM>关系运算符<BR>测试对象的相等性</EM></STRONG><BR>==和!=比较的是对象的reference。要想比较这两个对象的实际内容，必须使用每个类都有的，专门的equals()方法（primitives没有，因为==和!=就用得很好）。<BR>equals()的缺省行为是比较reference。<BR><STRONG><EM>逻辑运算符<BR>短接<BR>位运算符</EM></STRONG><BR>位运算符可以与=连起来用，以表示同时进行计算和赋值：&amp;=，|=和^=都是合法的。（至于~，它既然是一个单元运算符，也就不需要同=绑在一起了。）<BR>Boolean类型会被当作只有一位的值，所以它多少有点不同。你可以进行与，或，以及异或运算，但是不能进行非运算（可能是为了防止同逻辑非相混淆）。对于boolean，位运算用逻辑运算的在功能上是相同的，只是它没有短接。此外boolean的位运算里有一个逻辑运算所没有的异或。<BR><STRONG><EM>移位运算符</EM></STRONG><BR>它只能用于整数型的primitive数据。<BR><STRONG><EM>三元if-else运算符<BR>逗号运算符<BR></EM></STRONG>Java里面，唯一一个把逗号当运算符用的地方是for循环。<BR><STRONG><EM>String的+运算符<BR>常见的使用运算符方面的错误<BR>类型转换运算符</EM></STRONG><BR>碰到所谓的narrowing conversion的时候（也就是说，当你将一个能保存较多信息的数据类型，转换成一个保存不了这么多信息的数据类型时），它会产生一个异常。编译器会强制你明确地进行转换，实际上它的潜台词是“这么做可能很危险——如果你一定要做，那么请明确地告诉我”。<BR>对于widening conversion，就不必进行显式转换了，因为新类型可以存储比旧类型更多的信息，所以什么都丢不了。<BR>Java允许你对除boolean之外的其它primitive类型的数据进行任意的转换，而boolean则根本不能转换。<BR>类是不允许转换的。要让他们相互转换，必须要有特殊的方法。（String是一个特例。此外，所有对象都可以在它的类系（family of types）里面上下传递。）<BR><STRONG><EM>常量（Literals）<BR></EM></STRONG>C，C++或者Java里面都没有两进制常量值的表示方法。<BR>跟在常量值后面的那个数字表明了它的类型。大写或者小写的L表示long，大写或者小写的F表示float，而大写或者小写的D表示double。<BR>编译器通常会把用指数表示的数字当成double，所以在给float赋值如果没有后缀的f的话，它就会给你一个错误信息，告诉你你必须将double转换成float。<BR><STRONG><EM>提升<BR>Java没有“sizeof”<BR>重访优先级<BR></EM></STRONG>Ulcer Addicts Really Like C A lot.<BR>
<TABLE style="BORDER-RIGHT: medium none; BORDER-TOP: medium none; BORDER-LEFT: medium none; BORDER-BOTTOM: medium none; BORDER-COLLAPSE: collapse; mso-border-alt: solid windowtext 1.5pt; mso-yfti-tbllook: 480; mso-padding-alt: 0cm 5.4pt 0cm 5.4pt; mso-border-insideh: .5pt solid windowtext; mso-border-insidev: .5pt solid windowtext" cellSpacing=0 cellPadding=0 border=1>
<TBODY>
<TR style="mso-yfti-irow: 0; mso-yfti-firstrow: yes">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1.5pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 70.9pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-top-alt: 1.5pt; mso-border-left-alt: 1.5pt; mso-border-bottom-alt: .5pt; mso-border-right-alt: .5pt; mso-border-style-alt: solid; mso-border-color-alt: windowtext" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Mnemonic</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1.5pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 127.6pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext 1.5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=170>
<P style="MARGIN: 0cm 0cm 0pt 11.05pt; TEXT-INDENT: -11.05pt; TEXT-ALIGN: left; mso-layout-grid-align: none; mso-char-indent-count: -1.0" align=left><B>Operator type</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1.5pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 198pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-top-alt: 1.5pt; mso-border-left-alt: .5pt; mso-border-bottom-alt: .5pt; mso-border-right-alt: 1.5pt; mso-border-style-alt: solid; mso-border-color-alt: windowtext" vAlign=top width=264>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Operators</B></P></TD></TR>
<TR style="mso-yfti-irow: 1">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 70.9pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">Ulcer</P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 127.6pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=170>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">Unary</P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 198pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=264>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>+ - ++--</B></P></TD></TR>
<TR style="mso-yfti-irow: 2">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 70.9pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">Addicts</P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 127.6pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=170>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">Arithmetic(and shift)</P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 198pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=264>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>* / % + - &lt;&lt; &gt;&gt;</B><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia"></P></SPAN></TD></TR>
<TR style="mso-yfti-irow: 3">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 70.9pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">Really</P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 127.6pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=170>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">Relational</P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 198pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=264>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>&gt; &lt; &gt;= &lt;= == !=</B></P></TD></TR>
<TR style="mso-yfti-irow: 4">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 70.9pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">Like</P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 127.6pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=170>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">Logical(and bitwise)</P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 198pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=264>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>&amp;&amp; || &amp; | ^</B><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia"></P></SPAN></TD></TR>
<TR style="mso-yfti-irow: 5">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 70.9pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">C</P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 127.6pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=170>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">Conditional(ternary)</P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 198pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=264>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>A &gt; B? X: Y</B><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia"></P></SPAN></TD></TR>
<TR style="mso-yfti-irow: 6; mso-yfti-lastrow: yes">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 70.9pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1.5pt solid; mso-border-top-alt: .5pt; mso-border-left-alt: 1.5pt; mso-border-bottom-alt: 1.5pt; mso-border-right-alt: .5pt; mso-border-style-alt: solid; mso-border-color-alt: windowtext" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">A <?xml:namespace prefix = st1 ns = "urn:schemas-microsoft-com:office:smarttags" /><st1:place w:st="on">Lot</st1:place></P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 127.6pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1.5pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-bottom-alt: solid windowtext 1.5pt" vAlign=top width=170>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">Assignment</P></SPAN></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 198pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1.5pt solid; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=264>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>=</B><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">(and compound assignment like <B>*=</B><SPAN lang=EN-US style="FONT-SIZE: 11pt; FONT-FAMILY: Georgia; mso-font-kerning: 0pt; mso-bidi-font-family: Georgia">)</P></SPAN></SPAN></TD></TR></TBODY></TABLE><EM><STRONG>运算符的总结<BR></STRONG></EM>boolean的限制性是很强的。你只能赋给它true和false这两个值，而且只能测试它的真或假，你不能把boolean值加起来，或者进行其它什么操作。<BR>进行数学运算的时候，char，byte，以及short，都会先进行提升，而运算结果也是int，因此如果想把它赋还给原先那个变量的话，旧必须明确地进行类型转换（属于会丢失信息的narrowing conversion）。<BR><BR><STRONG><FONT size=4>执行控制</FONT></STRONG><BR><STRONG><EM>true和false<BR>if-else<BR>return<BR>循环语句<BR>do-while<BR></EM></STRONG>while与do-while的唯一区别就是，即使第一次判断的结果是false，do-while的statement也会至少运行一次。<BR><STRONG><EM>for</EM></STRONG><BR>for循环通常被用于“计数”的任务。<BR>你可以在for语句里定义多个变量，但必须是相同类型的。<BR>只有for语句才有在“控制表达式”里定义变量的能力。千万别在其它选择语句或循环语句里这么做。<BR><STRONG><EM>逗号运算符<BR>break和continue</EM></STRONG><BR>break会忽略尚未执行的循环代码，并且退出循环。<BR>continue会跳过尚未执行的代码，中断本次循环，再进入下一周期的循环。<BR><STRONG><EM>臭名昭著的“goto”</EM></STRONG><BR>在Java里，唯一能放标签的地方，就是在循环语句的外面。而且必须直接放——循环语句和标签之间不能有任何东西。而这么做的唯一理由就是，你会嵌套多层循环或选择。因为通常情况下break和continue关键词只会中断当前循环，而用了标签之后，它就会退到label所在的地方。<BR>1. 普通的continue会退到内部循环的最开始，然后继续执行内部循环。<BR>2. 带标签的continue会跳转到标签，并且重新进入直接跟在标签后面的循环。<BR>3. break会从循环的“底部溜出去”。<BR>4. 带标签的break会从由这个标签标识的循环的“底部溜出去”。<BR>在Java里，能让你使用标签的唯一理由就是，在嵌套循环的同时还要用break和continue退出多层循环。<BR><STRONG><EM>switch<BR></EM></STRONG>在case语句里，单引号括起来的字符在用于比较的时候，会返回整数值。<BR><STRONG><EM>计算细节</EM></STRONG><BR>将float或double转换成整数的时候，它总是将其后面的小数截去。<BR>Math.random()会生成0.0，或者用数学术语，它的值域是[0,1)。<BR><BR><STRONG><FONT size=4>总结<BR><BR>练习</FONT></STRONG></P>
<P align=right><STRONG><A id=Editor_Edit_hlEntryLink title="view: 「读书笔记」Thinking in Java 3rd Edition - 4: Initialization &amp; Cleanup" href="/selina/archive/2005/07/11/7493.html " target=_self><STRONG><FONT color=#002c99>「读书笔记」Thinking in Java 3rd Edition - 4: Initialization &amp; Cleanup</FONT></STRONG></A></STRONG></P><img src ="http://www.blogjava.net/selina/aggbug/7337.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/selina/" target="_blank">Selina</a> 2005-07-08 10:35 <a href="http://www.blogjava.net/selina/archive/2005/07/08/7337.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>「读书笔记」Thinking in Java 3rd Edition - 2: Everything is an Object</title><link>http://www.blogjava.net/selina/archive/2005/07/07/7255.html</link><dc:creator>Selina</dc:creator><author>Selina</author><pubDate>Thu, 07 Jul 2005 03:32:00 GMT</pubDate><guid>http://www.blogjava.net/selina/archive/2005/07/07/7255.html</guid><wfw:comment>http://www.blogjava.net/selina/comments/7255.html</wfw:comment><comments>http://www.blogjava.net/selina/archive/2005/07/07/7255.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/selina/comments/commentRss/7255.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/selina/services/trackbacks/7255.html</trackback:ping><description><![CDATA[<STRONG><FONT size=5>2: Everything is an Object（万物皆对象）<BR></FONT><BR><FONT size=4>用reference操控对象</FONT><BR><EM>数据存在哪里<BR></EM></STRONG>1. 寄存器（registers）。<BR>2. 栈（stack）。<BR>3. 堆（heap）。<BR>4. 静态存储（static storage）。<BR>5. 固定存储（constant storage）。<BR>6. 非内存的存储（Non-RAM storage）。<BR><STRONG><EM>特例：primitive类型<BR></EM></STRONG><STRONG><EM>
<TABLE style="BORDER-RIGHT: medium none; BORDER-TOP: medium none; BORDER-LEFT: medium none; BORDER-BOTTOM: medium none; BORDER-COLLAPSE: collapse; mso-border-alt: solid windowtext 1.5pt; mso-yfti-tbllook: 480; mso-padding-alt: 0cm 5.4pt 0cm 5.4pt; mso-border-insideh: .5pt solid windowtext; mso-border-insidev: .5pt solid windowtext" cellSpacing=0 cellPadding=0 border=1>
<TBODY>
<TR style="mso-yfti-irow: 0; mso-yfti-firstrow: yes">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1.5pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 2cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-top-alt: 1.5pt; mso-border-left-alt: 1.5pt; mso-border-bottom-alt: .5pt; mso-border-right-alt: .5pt; mso-border-style-alt: solid" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Primitive</B></P>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>type</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1.5pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext 1.5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Size</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1.5pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext 1.5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Minimum</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1.5pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext 1.5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Maximum</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1.5pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-top-alt: 1.5pt; mso-border-left-alt: .5pt; mso-border-bottom-alt: .5pt; mso-border-right-alt: 1.5pt; mso-border-style-alt: solid" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Wrapper</B></P>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>type</B></P></TD></TR>
<TR style="mso-yfti-irow: 1">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 2cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>boolean</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>—</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>—</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>—</P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Boolean</B></P></TD></TR>
<TR style="mso-yfti-irow: 2">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 2cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>char</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>16-bit</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>Unicode 0</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>Unicode 2<SUP>16</SUP>-1</P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Character</B></P></TD></TR>
<TR style="mso-yfti-irow: 3">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 2cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>byte</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>8-bit</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>-128</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>+127</P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Byte</B></P></TD></TR>
<TR style="mso-yfti-irow: 4">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 2cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>short</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>16-bit</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>-2<SUP>15</SUP></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>+2<SUP>15</SUP>—1</P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Short</B></P></TD></TR>
<TR style="mso-yfti-irow: 5">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 2cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>int</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>32-bit</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>-2<SUP>31</SUP></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>+2<SUP>31</SUP>—1</P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Integer</B></P></TD></TR>
<TR style="mso-yfti-irow: 6">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 2cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>long</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>64-bit</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>-2<SUP>63</SUP></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>+2<SUP>63</SUP>—1</P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Long</B></P></TD></TR>
<TR style="mso-yfti-irow: 7">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 2cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>float</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>32-bit</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>IEEE754</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>IEEE754</P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Float</B></P></TD></TR>
<TR style="mso-yfti-irow: 8">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 2cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>double</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>64-bit</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>IEEE754</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>IEEE754</P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Double</B></P></TD></TR>
<TR style="mso-yfti-irow: 9; mso-yfti-lastrow: yes">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 2cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1.5pt solid; mso-border-top-alt: .5pt; mso-border-left-alt: 1.5pt; mso-border-bottom-alt: 1.5pt; mso-border-right-alt: .5pt; mso-border-style-alt: solid" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>void</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1.5pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-bottom-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>—</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1.5pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-bottom-alt: solid windowtext 1.5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>—</P></TD>
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1.5pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-bottom-alt: solid windowtext 1.5pt" vAlign=top width=95>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>—</P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1.5pt solid; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=76>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Void</B></P></TD></TR></TBODY></TABLE>高精度的数值</EM></STRONG><BR>BigInteger支持任意精度的整数。<BR>BigDecimal能表示任意精度的浮点数。<BR><STRONG><EM>Java中的数组<BR></EM></STRONG><BR><STRONG><FONT size=4>你永远不需要清理对象</FONT><BR><EM>作用域</EM></STRONG><BR><STRONG><EM>对象的作用域<BR><BR></EM><FONT size=4>创建新的数据类型：类</FONT><BR><EM>数据成员与方法<BR>primitive成员的缺省值<BR></EM></STRONG>
<TABLE style="BORDER-RIGHT: medium none; BORDER-TOP: medium none; BORDER-LEFT: medium none; BORDER-BOTTOM: medium none; BORDER-COLLAPSE: collapse; mso-border-alt: solid windowtext 1.5pt; mso-yfti-tbllook: 480; mso-padding-alt: 0cm 5.4pt 0cm 5.4pt; mso-border-insideh: .5pt solid windowtext; mso-border-insidev: .5pt solid windowtext" cellSpacing=0 cellPadding=0 border=1>
<TBODY>
<TR style="mso-yfti-irow: 0; mso-yfti-firstrow: yes">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1.5pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 3cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-top-alt: 1.5pt; mso-border-left-alt: 1.5pt; mso-border-bottom-alt: .5pt; mso-border-right-alt: .5pt; mso-border-style-alt: solid" vAlign=top width=113>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Primitive type</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1.5pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 99.25pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-top-alt: 1.5pt; mso-border-left-alt: .5pt; mso-border-bottom-alt: .5pt; mso-border-right-alt: 1.5pt; mso-border-style-alt: solid" vAlign=top width=132>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>Default</B></P></TD></TR>
<TR style="mso-yfti-irow: 1">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 3cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=113>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>boolean</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 99.25pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=132>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>false</P></TD></TR>
<TR style="mso-yfti-irow: 2">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 3cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=113>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>char</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 99.25pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=132>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>‘\u<?xml:namespace prefix = st1 ns = "urn:schemas-microsoft-com:office:smarttags" /><st1:chmetcnv w:st="on" TCSC="0" NumberType="1" Negative="False" HasSpace="False" SourceValue="0" UnitName="’">0000’</st1:chmetcnv> (null)</P></TD></TR>
<TR style="mso-yfti-irow: 3">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 3cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=113>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>byte</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 99.25pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=132>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>(byte)0</P></TD></TR>
<TR style="mso-yfti-irow: 4">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 3cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=113>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>short</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 99.25pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=132>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>(short)0</P></TD></TR>
<TR style="mso-yfti-irow: 5">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 3cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=113>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>int</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 99.25pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=132>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>0</P></TD></TR>
<TR style="mso-yfti-irow: 6">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 3cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=113>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>long</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 99.25pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=132>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><st1:chmetcnv w:st="on" TCSC="0" NumberType="1" Negative="False" HasSpace="False" SourceValue="0" UnitName="l">0L</st1:chmetcnv></P></TD></TR>
<TR style="mso-yfti-irow: 7">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 3cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext 1.5pt" vAlign=top width=113>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>float</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 99.25pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt; mso-border-right-alt: solid windowtext 1.5pt" vAlign=top width=132>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><st1:chmetcnv w:st="on" TCSC="0" NumberType="1" Negative="False" HasSpace="False" SourceValue="0" UnitName="F">0.0f</st1:chmetcnv></P></TD></TR>
<TR style="mso-yfti-irow: 8; mso-yfti-lastrow: yes">
<TD style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1.5pt solid; WIDTH: 3cm; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1.5pt solid; mso-border-top-alt: .5pt; mso-border-left-alt: 1.5pt; mso-border-bottom-alt: 1.5pt; mso-border-right-alt: .5pt; mso-border-style-alt: solid" vAlign=top width=113>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left><B>double</B></P></TD>
<TD style="BORDER-RIGHT: windowtext 1.5pt solid; PADDING-RIGHT: 5.4pt; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; WIDTH: 99.25pt; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1.5pt solid; mso-border-top-alt: solid windowtext .5pt; mso-border-left-alt: solid windowtext .5pt" vAlign=top width=132>
<P style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-layout-grid-align: none" align=left>0.0d</P></TD></TR></TBODY></TABLE><STRONG><FONT size=4><BR>方法、参数和返回值</FONT></STRONG><BR>方法的名字再配合其参数列表，可以唯一地标识一个方法。<BR><EM><STRONG>参数列表<BR><BR></STRONG></EM><FONT size=4><STRONG>构建Java程序<BR></STRONG></FONT><STRONG><EM>名字的可见性<BR>使用其它组件<BR>static关键词<BR></EM></STRONG>对于非static的数据来说，每个对象都会有一份，static的数据则变成乐每个类只有一个。<BR>同其它方法一样，static方法夜可以创建或使用它本身这个类型的对象，所以static方法常常被用来管理本类型的对象，它就像是这些对象的“牧羊人”。<BR><STRONG><FONT size=4><BR>第一个Java程序</FONT></STRONG><BR><EM><STRONG>编译和运行<BR></STRONG></EM><FONT size=4><STRONG><BR>注释和嵌入式的文档<BR></STRONG></FONT><STRONG><EM>注释文档<BR>语法<BR></EM></STRONG>Javadoc有两种主要的用法：嵌入式的HTML和用“文档标记（doc tags）”。<BR>“独立的文档标记（Standalone doc tags）”是一些由‘@’打头的命令，它们会被放在注释行的开头。（但是打头的个‘*’则被忽略了。）<BR>“内嵌式的文档标记（inline doc tags）”则可以出现在任何地方，它也是由‘@’开始的，但是要用花括号括起来。<BR><STRONG><EM>嵌入的HTML<BR></EM></STRONG>所有类型的注释文档——类，变量，以及方法——都支持嵌入的HTML。<BR><STRONG><EM>标记举例</EM></STRONG><BR>@see：引用其它类<BR>{@link package.class#member label}<BR>{@docRoot}<BR>{@inheritDoc}<BR>@version<BR>@author<BR>你可以放多个作者标记，但是必须连续放。在HTML文件里，所有作者信息都放在一起。<BR>@since<BR>@param<BR>@param标记可以有好几个，每个标记表示一个参数。<BR>@return<BR>@throws<BR>@deorecated<BR>Deprecate标记建议用户不再使用这个特性，因为未来这个特性可能会从程序里面取出。客户程序使用了@deprecated标记的方法会导致编译器报一个警告消息。<BR><STRONG><EM>文档举例<BR></EM><FONT size=4><BR>编程风格</FONT></STRONG><BR>Code Conventions for the Java Programming Language所推荐的风格是，用第一个字母大写来表示这是类的名字。如果类名由多个单词组成，那么它们应该连在一起（也就是说，名字里面不要有下划线），并且其中的每个单词的第一个字母要大写，这种风格有时被称为“camel-casting”。其它东西：方法，数据成员（成员变量），对象的reference，其推荐的风格是，除了首字母小写，其它部分与类名完全相同。<BR><STRONG><FONT size=4><BR>总结<BR><BR>练习<BR></FONT></STRONG>
<P align=right><STRONG><A id=Editor_Edit_hlEntryLink title="view: 「读书笔记」Thinking in Java 3rd Edition - 3: Controlling Program Flow" href="/selina/archive/2005/07/08/7337.html " target=_self><STRONG><FONT color=#002c99>「读书笔记」Thinking in Java 3rd Edition - 3: Controlling Program Flow</FONT></STRONG></A></STRONG></P><img src ="http://www.blogjava.net/selina/aggbug/7255.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/selina/" target="_blank">Selina</a> 2005-07-07 11:32 <a href="http://www.blogjava.net/selina/archive/2005/07/07/7255.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>「读书笔记」Thinking in Java 3rd Edition - 1: Introduction to Objects</title><link>http://www.blogjava.net/selina/archive/2005/07/05/7149.html</link><dc:creator>Selina</dc:creator><author>Selina</author><pubDate>Tue, 05 Jul 2005 08:30:00 GMT</pubDate><guid>http://www.blogjava.net/selina/archive/2005/07/05/7149.html</guid><wfw:comment>http://www.blogjava.net/selina/comments/7149.html</wfw:comment><comments>http://www.blogjava.net/selina/archive/2005/07/05/7149.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/selina/comments/commentRss/7149.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/selina/services/trackbacks/7149.html</trackback:ping><description><![CDATA[<P><STRONG><FONT size=4><FONT size=5>1: Introduction to Objects（对象简介）<BR><BR></FONT>抽象的过程<BR></FONT></STRONG>问题空间的元素同它在解决空间的表述称为“对象”。（此外还需要一些在问题空间并无对照的对象。）<BR>面向对象的编程（Object-oriented programming，缩写是OOP）方法：<BR>1. 万物皆对象。<BR>2. 程序就是一组相互之间传递消息，告诉对方干些什么的对象。<BR>3. 每个对象都利用别的对象来组建它自己的记忆。<BR>4. 对象都有类型。<BR>5. 所有属于同一类型的对象都能接受相同的消息。<BR>对象有状态、行为和标识。<BR><BR><STRONG><FONT size=4>对象有接口<BR></FONT></STRONG>类是一组具有相同特征（数据元素）和行为（功能）的对象，所以实际上类是一种数据类型。<BR>区别：类是程序员为解决特定问题而定做的，而数据类型是为了表示机器的存储单元而设计的，它是现成的，是程序员无可奈何时的选择。<BR><BR><STRONG><FONT size=4>对象会提供服务</FONT></STRONG><BR>优点：能提高对象的内聚性（cohesion）。内聚性高是高质量的软件设计的一个基本要求：就是说软件的各种组件（比如对象，也可以是方法或类库）应该能很好的“组装在一起”。<BR><BR><STRONG><FONT size=4>隐藏实现</FONT></STRONG><BR>public表示后面跟着的东西谁都能用。<BR>而private关键词则表示，除非是类的创建者用这个类的方法进行访问，否则没人能访问到这个元素。private是竖在你与客户程序员之间的一堵墙。那些要访问private成员的人，会在编译的时候得到一个错误。<BR>protected关键词很像private，它们的区别在于，继承类能够访问protected成员，但是不能访问private成员。<BR>Java还有个“缺省”的访问权限，如果你没用上面三个的话，那就是指它了。通常把它成为package访问权限。因为同属这个package的类可以访问这个package中其它类的“缺省权限”的成员，但是出了这个package，它们就都是private的了。<BR><BR><FONT size=4><STRONG>复用实现</STRONG><BR></FONT>由于是用已有的类来合成新的类，因此这一概念被成为合成（composition，如果这个对象是动态的，通常把它成为聚合aggregation）。通常将合成称为“有（has-a）”关系，就像“轿车有引擎”。<BR>合成具有极大的灵活性。<BR><BR><STRONG><FONT size=4>继承：复用接口</FONT></STRONG><BR>你有两种办法来区分新的派生出来的类和那个原来的基类。<BR>1. 直接往派生类里加新的方法。<BR>2. 也是更重要的区分方法是在新的类中修改基类方法的行为。这被称为覆写（override）那个方法。<BR><STRONG><EM>“是”与“像”的关系</EM></STRONG><BR>1. 结果是能用派生类的对象直接替换基类的对象。可以把这种情况想成完全替换（pure substitution），通常被称为替换原则（substitution principle）。从某种意义上讲，这是使用继承的理想方法。通常我们把基类同派生类的这种关系称作是（is-a）关系。<BR>2. 基类还是可以被新的类所替代，但是这种替换是不完全的，因为的方法无法通过基类的接口访问。这可以被称为“像（is-like-a）”关系。<BR><BR><STRONG><FONT size=4>可凭借多态性相互替换的对象</FONT><BR></STRONG>非OOP的编译器的做法被称为前绑定（early binding）。在OOP中，不到运行的时候，程序没法确定代码的地址，所以向泛型对象发送一个消息的时候，就要用到一些特别的手段。为了解决这个问题，OOP语言是用了后绑定（late binding）的概念。<BR>将派生类当作它的基类来用的过程称为上传（upcast）。<BR><STRONG><EM>abstract基类和interface</EM></STRONG><BR>abstract方法只能存在于abstract类里。如果有个类继承了abstract类，那么它要么实现这个方法，要么也是一个abstract类。abstract方法能让你将方法放到接口而不必为它写一些无意义的代码。<BR>interface关键词更是对abstract类的概念的深化，它不允许你实现任何方法。interface是个很趁手也很常用的工具，因为它能彻底地将接口与实现分离开来。此外如果你愿意，还可以继承多个接口，因为要继承多个常规或是抽象类是不允许的。<BR><BR><FONT size=4><STRONG>对象的创建，使用和生命周期</STRONG><BR></FONT>1. 在写代码的时候决定将对象放到栈里（有时会被称为automatic或scoped的变量）或是静态的存储区域。（C++，速度快）<BR>2. 在一个被称为堆的内存池里动态地创建对象。（Java，灵活性高）<BR>（在栈中分配存储空间通常只需一个汇编指令，把栈指针向下移就行了，想把指针指回来也只要一条指令。而堆的存储分配则取决于存储机制的设计。）<BR><STRONG><EM>Collection和迭代器</EM><BR></STRONG>List类（以持有线性序列）<BR>Map类（也称为关联性数组associative arrays，将一个对象同另一个对象关联起来）<BR>Set类（不持有两个相同的对象）<BR><STRONG><EM>单根继承体系</EM></STRONG><BR>Java（实际上除了C++所有其它OOP语言）的回答是，是的，而这个最终的基类就叫Object.<BR><STRONG><EM>下传与模板/泛型</EM></STRONG><BR>沿着继承图向下传给一个更为具体的类型，这种方式称为下传（downcast）。<BR>上传很安全，下传十有八九是不安全的。<BR>参数化类型（parameterized type）是一种能够根据需要由编译器自动指派类型的类。（C++：template/Java：generics）<BR><STRONG><EM>确保正确地清除</EM></STRONG><BR>Java设计了一个垃圾回收器来处理释放内存的问题（仅此而已，不包括清除对象的其它方面）。<BR><STRONG><EM>垃圾回收器的效率与灵活性</EM></STRONG><BR>C++：编程复杂性较高<BR>Java：效率和适用性较差<BR><BR><STRONG><FONT size=4>异常处理：与错误打交道</FONT></STRONG><BR>尽管在面向对象的语言中异常通常以对象的形式出现，但异常处理并不是一种面向对象的特性。异常处理在面向对象的语言问世之前就已经有了。<BR><BR><STRONG><FONT size=4>并发<BR></FONT></STRONG>Java能锁定任何对象的内存（毕竟这也是一种共享资源），这样同一时刻就只有一个线程能够访问这些内存。这是由synchronized关键词来做的。其它资源就得靠程序员自己来锁定了。通常可以创建一个表示这项资源的对象，然后让线程在访问资源之前先检查一下。<BR><BR><FONT size=4><STRONG>Persistence</STRONG><BR></FONT>轻量级的presistence既可以通过对象的序列化（object serialization），也可以通过数据对象（Java Data Object，简称JDO）来实现。<BR><BR><STRONG><FONT size=4>Java和Internat</FONT></STRONG><BR><STRONG><EM>Web是什么？<BR>客户/服务器系统<BR>把Web当作巨型的服务器<BR>客户端编程<BR>插件<BR>脚本语言<BR>Java<BR>.NET和C#<BR>安全性<BR>Internet和Intranet<BR>服务器端编程<BR>应用程序<BR></EM></STRONG><BR><STRONG><FONT size=4>Java为什么能成功<BR></FONT><EM>系统能更易于表述和理解<BR>最大程度上利用类库<BR>错误处理<BR>编写大项目<BR></EM>Java还是C++？<BR><BR><FONT size=4>总结</FONT></STRONG></P>
<P align=right><STRONG><A id=Editor_Edit_hlEntryLink title="view: 「读书笔记」Thinking in Java 3rd Edition - 2: Everything is an Object" href="/selina/archive/2005/07/07/7255.html" target=_self><STRONG><FONT color=#002c99>「读书笔记」Thinking in Java 3rd Edition - 2: Everything is an Object</FONT></STRONG></A></STRONG></P><img src ="http://www.blogjava.net/selina/aggbug/7149.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/selina/" target="_blank">Selina</a> 2005-07-05 16:30 <a href="http://www.blogjava.net/selina/archive/2005/07/05/7149.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>