<?xml version="1.0" encoding="UTF-8"?><!-- generator="WordPress/2.8.1" -->
<rss version="0.92">
<channel>
	<title>流浪的北洋人 ~_~</title>
	<link>http://thechampionheart.blog.ubuntu.org.cn</link>
	<description>Lord, I'm doing all I can to be a better man.</description>
	<lastBuildDate>Sun, 28 Dec 2008 12:04:21 +0000</lastBuildDate>
	<docs>http://backend.userland.com/rss092</docs>
	<language>en</language>
	
	<item>
		<title>I&#8217;m still fighting for a good future</title>
		<description>
这些天感觉很疲惫，真的。身体疲惫？No，是心里的疲惫。

从九月下旬开始找工作到现在一个月了，才只有一次面试，两次笔试。当然中途从十月一号到十月十四号，一直在忙比赛的事儿，也没太在工作上花功夫。反正不管怎么说，我还是没有找到我想要的，求职的路还有多远？不得而知。

经过这么多天的折腾，心里的那一点点儿锐气和傲气已经消失殆尽了。现在有时想起自己曾经去tencent，去baidu的想法还是有点不现实，反映 了自己心理的幼稚。江总书记说：“too simple, sometimes naive” 就是现在我对一个月前的自己的概括。进入这些所谓的名企，所谓的巨头真是太难了，除去研究生大军的竞争，客观的说自己的实力也是没有达名企的标。百度笔试 即遭鄙视，腾讯根本没有得到笔试的机会，网易没有去，联发博动错过了，校内错过了......终于熬到今天，现在正在准备天津的天地伟业的二面。过去不代 表将来，继续努力，毕竟日子还要一天一天的过嘛！

好友小龙已经签了，还不错。国企“北方重工”，销售，实习期间一个月3000＋，转正式之后一个月4000＋。对于他这个机械专业的已经是非常好了 （估计他的很多同学都会去工厂做蓝领呢），签了之后把他兴奋的马上给我打了电话聊了十多分钟。这小子rp真是没的说，而且听说他是连着忽悠面试官和hr经 理两个半天才感动了上天的，忽悠＋实力＋运气＝很好的工作！

小侯姐也好几次面试了（都被鄙视了），相比之下我的面试经验就显得太少了，昨天晚上在QQ上她还特意给我上了一堂应对面试的培训课。她投的多不是技 术类的！看来非技术类的面试机会要比技术类的大很多呀。有时候真的怀疑自己的选择，技术真的适合自己吗？说不定把方向定为销售或其它早都已经面试了或者签 了。老爸、老妈很少帮我做决定，但还是给了我很多意见参考，听大姨的话“工作之后，什么都不参和，踏踏实实的搞技术，稳稳当当的积累人脉”，这样以后转行 腰杆儿也硬，而且可以避免很多不必要的事情。既然选择了就义无反顾了。

算了，想这么多太累了，估计这也是最近为什么这么累的原因吧！虽然不能说是“世上本无事”，但有时我也是有点“庸人自扰之”了。把心放宽，继续努力。相信上帝对每个人都是公平。

老妈，我爱你。谢谢这么长时间里您给我的支持。谢谢所有我爱的人。 </description>
		<link>http://thechampionheart.blog.ubuntu.org.cn/2008/10/28/im-still-fighting-for-a-good-future/</link>
			</item>
	<item>
		<title>C++内存分配方式（转载）</title>
		<description>内存分配方式有三种：
（1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的
整个运行期间都存在。例如全局变量，static 变量。
（2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函
数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集
中，效率很高，但是分配的内存容量有限。
（3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意
多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存
期由我们决定，使用非常灵活，但问题也最多。
内存分配方法:C++内存分配的五种不同的方法


　　在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
　　栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是
局部变量、函数参数等。
　　堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个
new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
　　自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生
命的。
　　全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始
化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
　　常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当
手段也可以修改，而且方法很多，在《const的思考》一文中，我给出了6种方法）
　　明确区分堆与栈
　　在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以
我决定拿他第一个开刀。
　　首先，我们举一个例子：
void f() { int* p=new int[5]; }
　　这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针
p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。在程
序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中
，他在VC6下的汇编代码如下：

00401028 push 14h 
0040102A call operator new (00401060)
0040102F add esp,4
00401032 mov dword ptr [ebp-8],eax
00401035 mov eax,dword ptr [ebp-8]
00401038 mov dword ptr [ebp-4],eax

　　这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete
[]p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。
　　好了，我们回到我们的主题：堆和栈究竟有什么区别？
　　主要的区别由以下几点：
　　1、管理方式不同；
　　2、空间大小不同；
　　3、能否产生碎片不同；
　　4、生长方向不同；
　　5、分配方式不同；
　　6、分配效率不同；
　　管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制
，容易产生memory leak。
　　空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限
制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是
，记不清楚了）。当然，我们可以修改：
　　打开工程，依次操作菜单如下：Project-&#62;Setting-&#62;Link，在Category 中选中Output，然后在
Reserve中设定堆栈的最大值和commit。
　　注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大
的值，可能增加内存的开销和启动时间。
　　碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序
效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永
远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参
考数据结构，这里我们就不再一一讨论了。
　　生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方
向是向下的，是向着内存地址减小的方向增长。
　　分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是
编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他
的动态分配是由编译器进行释放，无需我们手工实现。
　　分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地
址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很
复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内
存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统
功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈
要低得多。
　　从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专
门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在
程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部
变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。
　　虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一
些。
　　无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃
，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题
，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的。 2008-9-25 0:53:57
 </description>
		<link>http://thechampionheart.blog.ubuntu.org.cn/2008/10/28/c%e5%86%85%e5%ad%98%e5%88%86%e9%85%8d%e6%96%b9%e5%bc%8f%ef%bc%88%e8%bd%ac%e8%bd%bd%ef%bc%89/</link>
			</item>
	<item>
		<title>详解Java里的堆和栈（转载，exellent！）</title>
		<description>在C语言里堆(heap)和栈(stack)里的区别

简单的可以理解为：
heap：是由malloc之类函数分配的空间所在地。地址是由低向高增长的。
stack：是自动分配变量，以及函数调用的时候所使用的一些空间。地址是由高向低减少的。

一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表



在Java语言里堆(heap)和栈(stack)里的区别


1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共 享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要 在运行时动态分配内存，存取速度较慢。

3. Java中的数据类型有两种。
一种是基本类型(primitive types), 共有8种，即int, short, long, byte, float, double, boolean, char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a = 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出 后，字段值就消失了)，出于追求速度的原因，就存在于栈中。
另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义

int a = 3;
int b = 3；

编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处 理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。
特别注意的是，这种字面值的引用与类对象的引用不同。假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状 态，那么另一个对象引用变量也即刻反映出这个变化。相反，通过字面值的引用来修改其值，不会导致另一个指向此字面值的引用的值也跟着改变的情况。如上例， 我们定义完a与 b的值后，再令a=4；那么，b不会等于4，还是等于3。在编译器内部，遇到a=4；时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存 放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。
另一种是包装类数据，如Integer, ...</description>
		<link>http://thechampionheart.blog.ubuntu.org.cn/2008/09/24/%e8%af%a6%e8%a7%a3java%e9%87%8c%e7%9a%84%e5%a0%86%e5%92%8c%e6%a0%88%ef%bc%88%e8%bd%ac%e8%bd%bd%ef%bc%8cexellent%ef%bc%81%ef%bc%89/</link>
			</item>
	<item>
		<title>A Skeleton in the Cupboard.</title>
		<description>A Skeleton in the Cupboard.（橱中骷髅）是国外的谚语，我们经常在小说里读到，一个外表看起来很受人尊敬的人或家庭，多年来一直隐藏着一些不为人知的可怕的秘密。 在故事的某个戏剧性时刻，这种骇人听闻的秘密－－即“橱中骷髅”让人识破了，于是便名誉扫地。
现常常指每个人或每个家庭都有不可告人的秘密。 </description>
		<link>http://thechampionheart.blog.ubuntu.org.cn/2008/09/15/a-skeleton-in-the-cupboard/</link>
			</item>
	<item>
		<title>Be thankful for what you have</title>
		<description>Be thankful for what you have and you will have more.
If you always concentrate on what you do not have you will never ever have enough.
by Oprah Winfrey

何必总是对自己得不到的耿耿于怀，其实现在身边的一切更值得珍惜。

人在大四，发现自己比以前更成熟了，也更懂得珍惜了。

有 时候自己努力回想大学以前的生活，其实和现在一样，也是一点一点的从眼皮底下、从指缝中间流走的，可是在我的脑海里留下的记忆却很少，感觉自己的从前就像 是空白一片。以前自己对一切都过于苛求，总是想着前面的事情，希望有个好的前景，却从没有回头看看走过的路，没有珍惜身边的人。

有句广告 词说得好“人生就像一场旅行，不必在乎目的，要在乎的沿途的风景和看风景的心情。” 一个人即使取得再大的成功，登到不胜寒的高处，但是如果他回首这一路行程心里却没有一点儿情感的积淀和沿途风景的轮廓，可以说这趟旅行是不成功的。人生的 确就像一趟旅行，A one way trip，没有回头的路，失去的就是失去了，永远的失去了。

前天晚上，给妈妈打了个电话。这种主动 给家里打电话的行为平时是很少在我身上发生的，以前每次要往家里打电话的时候总是感觉还有其它事情要做而最终搁浅了，甚至老妈打电话过来的时候我也总是想 早点结束，感觉“就那点儿事儿，也没什么说的”。现在的感觉不一样了，我总是想给家里打电话，想对他们说“我爱你”，记得补英语口语的时候，Sandy说 过“Say it before it's too late”。这就是人生，Any chance could be the last chance.

对拥有的一切心存感恩，对想要拥有的好好准备、努力争取。希望能在品味成功之余，品味生活的精彩！ </description>
		<link>http://thechampionheart.blog.ubuntu.org.cn/2008/09/10/be-thankful-for-what-you-have/</link>
			</item>
	<item>
		<title>A great day（2008-0827）</title>
		<description>会永远记住今天的！不仅在游泳上有了很大的进步(呵呵，I‘m a rookie @_@，两位师傅走了之后，自己又游了一个来回，哈哈，对"rebuild my upper body"非常有信心了)，而且了却了一桩心事。挺不错的！哈哈。

人与人之间有很多误会，我认为没有人真正了解其他人。一个人可能在某些人眼里就是个纯粹的人渣，但是谁又真正了解这个人渣呢？就连和他最亲近的人，我想，也不敢打百分之百的保票，说“我非常了解这个人”。

所以，我对自己说：“不管自己在别人眼里什么形象，做好真正的自己！为自己活着，为真正爱你的人快乐、伤心，其它的，谁管呢？”

呵呵，每天多一些笑容，去爱身边的这个世界。Time doesn't lie to any body.

感谢身边的每一个人，珍惜自己所拥有的一切！

ps:
TOMaster JBer 和 Master B，谢谢！ </description>
		<link>http://thechampionheart.blog.ubuntu.org.cn/2008/09/10/a-great-day%ef%bc%882008-0827%ef%bc%89/</link>
			</item>
	<item>
		<title>最郁闷的事情（2008-08-26）</title>
		<description>发发牢骚。

其实心里一直不舒服，我想纵使心再大的人，我想遇到这种情况可能也会和我同感。

在两个男人之间发生了冷战......

以前关系很好，现在却如同路人，真让人伤心！

The key point is I just DON'T KNOW WHY! Give a reason. </description>
		<link>http://thechampionheart.blog.ubuntu.org.cn/2008/09/10/%e6%9c%80%e9%83%81%e9%97%b7%e7%9a%84%e4%ba%8b%e6%83%85%ef%bc%882008-08-26%ef%bc%89/</link>
			</item>
	<item>
		<title>About Java数组创建</title>
		<description>
String s = new String("abc");创建了几个String对象？




引用变量与对象的区别；
字符串文字"abc"是一个String对象；
文字池(pool of literal strings)和堆(heap)中的字符串对象。

一、引用变量与对象：除了一些早期的Java书籍和现在的垃圾书籍，人们都可以从中比较清楚地学习到两者的区别。
A aa;
这个语句声明一个类A的引用变量aa[我们常常称之为句柄]，而对象一般通过new创建。所以题目中s仅仅是一个引用变量，它不是对象。

二、Java中所有的字符串文字[字符串常量]都是一个String的对象。有人[特别是C程序员]在一些场合喜欢把字符串"当作/看成"字符数组，这也没有办法，因为字符串与字符数组存在一些内在的联系。事实上，它与字符数组是两种完全不同的对象。

System.out.println("Hello".length());
char[] cc={'H','i'};
System.out.println(cc.length);

三、字符串对象的创建:
由于字符串对象的大量使用(它是一个对象，一般而言对象总是在heap分配内存)，Java中为了节省内存空间和运行时间(如比较字符串时，==比equals()快)，在编译阶段就把所有的字符串文字放到一个文字池(pool of literal strings)中，而运行时文字池成为常量池的一部分。文字池的好处，就是该池中所有相同的字符串常量被合并，只占用一个空间。
我们知道，对两个引用变量，使用==判断它们的值(引用)是否相等，即指向同一个对象：

String s1 = "abc" ;
String s2 = "abc" ;
if( s1 == s2 ) System.out.println("s1,s2 refer to the same object");
else System.out.println("trouble");


这里的输出显示，两个字符串文字保存为一个对象。就是说，上面的代码只在pool中创建了一个String对象。

现在看String s = new String("abc");语句，这里"abc"本身就是pool中的一个对象，而在运行时执行new String()时，
将pool中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s持有。ok，这条语句就创建了2个String对象。


String s1 = new String("abc") ;
String s2 = new String("abc") ;
if( s1 == s2 ...</description>
		<link>http://thechampionheart.blog.ubuntu.org.cn/2008/09/08/about-java%e6%95%b0%e7%bb%84%e5%88%9b%e5%bb%ba/</link>
			</item>
	<item>
		<title>关于 JAVA Exception</title>
		<description>异常的概念   
       任何的异常都是Throwable类（为何不是接口？？），并且在它之下包含两个字类Error / Exception，而Error仅在当在Java虚拟机中发生动态连接失败或其它的定位失败的时候，Java虚拟机抛出一个Error对象。典型的简易程序不捕获或抛出Errors对象，你可能永远不会遇到需要实例化Error的应用，那就让我们关心一下Exception。
       Exception中比较重要的就是RuntimeException（运行时异常）－可能在执行方法期间抛出但未被捕获的 RuntimeException 的任何子类都无需在 throws 子句中进行声明，也就是说你的应用应该不去“关心”（说不关心是不服责任的，但只是你不应该试图实例化它的字类）。  RuntimeException，就如同你不应该关心Error的产生与处理一样！RuntimeException描述的是程序的错误引起来的，因该由程序负担这个责任！（从责任这个角度看Error属于JVM需要负担的责任;RuntimeException是程序应该负担的责任;checked exception 是具体应用负担的责任）
       除了Error与RuntimeException，其他剩下的异常都是你需要关心的，而这些异常类统称为Checked Exception,至于Error与RuntimeException则被统称为Unchecked Exception.


         关于 Java 中引入的 Checked Exceptions，目前存在着很多反对意见。正方的观点是引入 Checked Exceptions，可以增加程度的鲁棒性。反方的观点是 Checked Exceptions 很少被开发人员正确使用过，并且降低了程序开发的生产率和代码的执行效率。

Java 中定义了两类异常： 

1) Checked exception: 这类异常都是Exception的子类 。异常的向上抛出机制进行处理，如果子类可能产生A异常，那么在父类中也必须throws A异常。可能导致的问题：代码效率低，耦合度过高。C#中就没有使用这种异常机制。

2) Unchecked exception: 这类异常都是RuntimeException的子类，虽然RuntimeException同样也是Exception的子类，但是它们是特殊的，它们不能通过client code来试图解决，所以称为Unchecked exception 。   
    
(JAVA视线论坛robbin's view，个人觉得用来做业务流程控制违背了Exception设计的初衷，但可以借鉴一下)
     在使用UseCase来描述一个场景的时候，有一个主事件流和n个异常流。异常流可能发生在主事件流的过程，而try语句里面实现的是主事件流，而catch里面实现的是异常流，在这里Exception不代表程序出现了异常或者错误，Exception只是面向对象化的业务逻辑控制方法。如果没有明白这一点，那么我认为并没有真正明白应该怎么使用Java来正确的编程。 
      而我自己写的程序，会自定义大量的Exception类，所有这些Exception类都不意味着程序出现了异常或者错误，只是代表非主事件流的发生的，用来进行那些分支流程的流程控制的。例如你往权限系统中增加一个用户，应该定义1个异常类，UserExistedException，抛出这个异常不代表你插入动作失败，只说明你碰到一个分支流程，留待后面的catch中来处理这个分支流程。传统的程序员会写一个if else来处理，而一个合格的OOP程序员应该有意识的使用try catch 方式来区分主事件流和n个分支流程的处理，通过try catch，而不是if else来从代码上把不同的事件流隔离开来进行分别的代码撰写。 

(另外一种观点，不同于robbin，个人赞同，并引用于此)
1。什么时候抛出异常--涉及到服务类
2。抛出checked还是unchecked的异常--涉及到客户类

       对第一个问题来说，我想异常本身这个字解释了某些东西，异常就是我们认为在正常情况下不可能发生的问题，并且服务代码不知道如何去处理。譬如说我做一个监控程序，需要用压缩卡提供的API去初始化所有的板卡，API提供的是boolean型的返回值，但我把这个API变成抛出一个异常，因为除非特殊原因，我不认为会发生初始化失败的情况，当然更不知道怎样去处理这个问题。又譬如Hibernate里面的LoadObject使用没有发现这个对象存在，那Hibernate也是认为不可能的，除非其他代码直接删除了数据库里面的记录，那么也需要抛出异常。当然Hibernate本身也不知道如何处理这种情况。
       但是如果发生的情况是可以预期的，那我不认为应该抛出例外。象上面这个userExist的情况，我认为应该在前面已经分流，应该首先判断这个用户是否存在，if(userExists())，然后进行处理，而不应当抛出例外。以及login应当返回true或者false。也就是说，这些属于程序的正常流程，而不是例外，不是异常。把例外作为正常程序流程的控制机制，只不过是把服务代码中的if转移到客户代码去，没有减少任何需要处理的代码，反而增加了系统的负担（生成例外栈）。
       ...</description>
		<link>http://thechampionheart.blog.ubuntu.org.cn/2008/09/06/%e5%85%b3%e4%ba%8e-java-exception/</link>
			</item>
	<item>
		<title>JDK and JRE</title>
		<description>JDK
JDK 是整个Java的核心，包括了Java运行环境（Java Runtime Envirnment），一堆Java工具和Java基础的类库（rt.jar）。不论什么Java应用服务器实质都是内置了某个版本的JDK.最主流的 JDK是Sun公司发布的JDK，除了Sun之外，还有很多公司和组织都开发了自己的JDK，例如IBM公司开发的JDK，BEA公司的Jrocket， 还有GNU组织开发的JDK等等。其中IBM的JDK包含的JVM（Java Virtual Machine）运行效率要比Sun JDK包含的JVM高出许多。而专门运行在x86平台的Jrocket在服务端运行效率也要比Sun JDK好很多。但不管怎么说，我们还是需要先把Sun JDK掌握好。
JDK一般有三种版本：SE（J2SE），standard edition，标准版，是我们通常用的一个版本EE（J2EE），enterpsise edtion，企业版，使用这种JDK开发J2EE应用程序，ME（J2ME），micro edtion，主要用于移动设备、嵌入式设备上的java应用程序Java开发工具（JDK）是许多Java专家最初使用的开发环境。尽管许多编程人员已 经使用第三方的开发工具，但JDK仍被当作Java开发的重要工具。JDK由一个标准类库和一组建立，测试及建立文档的Java实用程序组成。其核心 Java API是一些预定义的类库，开发人员需要用这些类来访问Java语言的功能。Java API包括一些重要的语言结构以及基本图形，网络和文件I/O.一般来说，Java API的非I/O部分对于运行Java的所有平台是相同的，而I/O部分则仅在通用Java环境中实现。
作为JDK实用程序，工具库中有七种主要程序。
Javac：Java编译器，将Java源代码转换成字节码。
Java：Java解释器，直接从类文件执行Java应用程序字节代码。
appletviewer：小程序浏览器，一种执行HTML文件上的Java小程序的Java浏览器。
Javadoc：根据Java源码及说明语句生成HTML文档。
Jdb：Java调试器，可以逐行执行程序，设置断点和检查变量。
Javah：产生可以调用Java过程的C过程，或建立能被Java程序调用的C过程的头文件。
Javap：Java反汇编器，显示编译类文件中的可访问功能和数据，同时显示字节代码含义。

JRE
JRE（Java Runtime Environment，Java运行环境），运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。是Sun的产品，包括两部 分：JavaRuntimeEnvironment和JavaPlug-inJavaRuntimeEnvironment（JRE）是可以在其上运行、 测试和传输应用程序的Java平台。它包括Java虚拟机、Java平台核心类和支持文件。它不包含开发工具——编译器、调试器和其它工具。JRE需要辅 助软件 ——JavaPlug-in——以便在浏览器中运行applet.J2RE是Java2 Runtime Environment，即Java运行环境，有时简称JRE.如果你只需要运行Java程序或Applet，下载并安装它即可。如果你要自行开发 Java软件，请下载JDK.在JDK中附带有JRE.注意由于Microsoft对Java的支持不完全，请不要使用IE自带的虚拟机来运行 Applet，务必安装一个JRE或JDK. </description>
		<link>http://thechampionheart.blog.ubuntu.org.cn/2008/08/27/jdk-and-jre/</link>
			</item>
Recent Posts: <ol><li><a href="http://thechampionheart.blog.ubuntu.org.cn/2008/10/28/im-still-fighting-for-a-good-future/" rel="bookmark" title="Permanent Link: I'm still fighting for a good future">I'm still fighting for a good future</a></li><li><a href="http://thechampionheart.blog.ubuntu.org.cn/2008/10/28/c%e5%86%85%e5%ad%98%e5%88%86%e9%85%8d%e6%96%b9%e5%bc%8f%ef%bc%88%e8%bd%ac%e8%bd%bd%ef%bc%89/" rel="bookmark" title="Permanent Link: C++内存分配方式（转载）">C++内存分配方式（转载）</a></li><li><a href="http://thechampionheart.blog.ubuntu.org.cn/2008/09/24/%e8%af%a6%e8%a7%a3java%e9%87%8c%e7%9a%84%e5%a0%86%e5%92%8c%e6%a0%88%ef%bc%88%e8%bd%ac%e8%bd%bd%ef%bc%8cexellent%ef%bc%81%ef%bc%89/" rel="bookmark" title="Permanent Link: 详解Java里的堆和栈（转载，exellent！）">详解Java里的堆和栈（转载，exellent！）</a></li><li><a href="http://thechampionheart.blog.ubuntu.org.cn/2008/09/15/a-skeleton-in-the-cupboard/" rel="bookmark" title="Permanent Link: A Skeleton in the Cupboard.">A Skeleton in the Cupboard.</a></li><li><a href="http://thechampionheart.blog.ubuntu.org.cn/2008/09/10/be-thankful-for-what-you-have/" rel="bookmark" title="Permanent Link: Be thankful for what you have">Be thankful for what you have</a></li></ol></channel>
</rss>
