一个计算机专业学生几年的编程经验汇总

想来学习 Java 也有两个年头了，永远不敢说多么精通，但也想谈谈自己的感受，写给软件学院的同仁们，

帮助大家在技术的道路上少一点弯路。说得伟大一点是希望大家为软件学院争气，其实最主要的还是大家

自身的进步提升??

1． 关于动态加载机制??

学习 Java 比 C++更容易理解 OOP 的思想，毕竟 C++还混合了不少面向过程的成分。很多人都能背出来

Java 语言的特点，所谓的动态加载机制等等。当然概念往往是先记住而后消化的，可有多少人真正去体

会过动态加载的机制，试图去寻找过其中的细节呢? 提供大家一个方法：

在命令行窗口运行 Java 程序的时候，加上这个很有用的参数：

情。尝试自己这样做：

javac -classpath yourpath *.java

java -classpath yourpath *.class

也许很多人都能看懂，设置 classpath 的目的就是告诉编译器去哪里寻找你的 class 文件. 不过至少笔者

今日才弄懂 JVM 去查询类的原理，编译器加载类要依靠 classloader， 而 classloader 有 3 个级别，从高

到低分别是 BootClassLoader(名字可能不准确) , ExtClassLoader, AppClassLoader.

这 3 个加载器分别对应着编译器去寻找类文件的优先级别和不同的路径： BootClassLoader 对应 jre/

classes 路径，是编译器最优先寻找 class 的地方

ExtClassLoader 对应 jre/lib/ext 路径，是编译器次优先寻找 class 的地方

AppClassLoader 对应当前路径，所以也是编译器默认找 class 的地方

种体系的是 Sun 公司曾经的技术核心宫力先生，一个纯种华人哦！^_^

这样希望大家不至于迷惑为什么总报错找不到类文件，不管是自己写的还是导入的第三方的 jar 文件

（J2ee 中经常需要导入的）。

3． 关于 jdk 和 jre??

大家肯定在安装 JDK 的时候会有选择是否安装单独的 jre，一般都会一起安装，我也建议大家这样做。因

为这样更能帮助大家弄清楚它们的区别：

Jre 是 java runtime environment, 是 java 程序的运行环境。既然是运行，当然要包含 jvm，也就是大

家熟悉的虚拟机啦， 还有所有 java 类库的 class 文件，都在 lib 目录下打包成了 jar。大家可以自己验证。

至于在 windows 上的虚拟机是哪个文件呢？ 学过 MFC 的都 知道什么是 dll 文件吧，那么大家看

看 jre/bin/client 里面是不是有一个 jvm.dll 呢？那就是虚拟机。

一个 Jre. 那么为什么要包括另外一个 Jre 呢？而且 jdk/jre/bin 同时有 client 和 server 两个文件夹下都包

含一个 jvm.dll。 说明是有两个虚拟机的。这一点不知道大家是否注意到了呢？

才有 javac，这一点很好理解，因为 jre 只是一个运行环境而已。与开发无关，正因为如此，具备开发功能

的 jdk 自己的 jre 下才会同时有 client 性质的 jvm 和 server 性质的 jvm， 而仅仅作为运行环境的 jre 下只需

要 client 性质的 jvm.dll 就够了。

记得在环境变量 path 中设置 jdk/bin 路径麽？这应该是大家学习 Java 的第一步吧， 老师会告诉大家不设

“%SystemRoot%\system32;%SystemRoot%;”这样的配置，那么再去 Windows/system32 下面去看看吧，

发现了什么？有一个 java.exe。

如果强行能够把 jdk/bin 挪到 system32 变量前面，当然也可以迫使使用 jdk/jre 里面的 java，不过除非有必

要，我不建议大家这么做。使用单独的 jre 跑 java 程序也算是客户环境下的一种测试。

这下大家应该更清楚 jdk 和 jre 内部的一些联系和区别了吧？

PS: 其实还有满多感想可以总结的，一次写多了怕大家扔砖头砸死我，怪我太罗唆。大家应该更加踏实

更加务实的去做一些研究并互相分享心得，大方向和太前沿的技术讨论是必要的但最好不要太多，毕竟自

己基础都还没打好，什么都讲最新版本其实是进步的一大障碍！

API 的时候 怎么去审视或者分析其中的一个 package ，每个包最重要的两个部分就是 interfaces 和

classes，接口代表了它能做什么，实现类则代表了它如何去做。关注实现类之前，我们应该先理解清楚

它的来源接口，不管在 j2se 还是 j2ee 中，都应该是这样。那么我们先看这三个接口：List、Set、Map。

也 许 有 些 人 不 太 熟 悉 这 三 个 名 字 ， 但 相 信 大 部 分 人 都 熟 悉

ArrayList，LinkedList，TreeSet，HashSet，HashMap， Hashtable 等实现类的名字。它们的区别也是

满容易理解的，List 放可以重复的对象集合，Set 放不可重复的对象组合，而 Map 则放 <Key,Value >

这样的名值对， Key 不可重复，Value 可以。这里有几个容易混淆的问题：

到底 Vector 和 ArrayList，Hashtable 和 HashMap 有什么区别？

很多面试官喜欢问这个问题，其实更专业一点应该这样问：新集合框架和旧集合框架有哪些区别？新集合

框架大家可以在这些包中找 since jdk1.2 的，之前的如 vector 和 Hashtable 都是旧的集合框架包括的类。

那么区别是？

a. 新集合框架的命名更加科学合理。例如 List 下的 ArrayList 和 LinkedList

b. 新集合框架下全部都是非线程安全的。建议去 jdk 里面包含的源代码里面自己去亲自看看 vector 和

template 语法。

那么大家是否想过为什么要从旧集合框架默认全部加锁防止多线程访问更新到新集合框架全部取消锁，默

笔者的观点是任何技术的发展都未必是遵循它们的初衷的，很多重大改变是受到客观环境的影响的。大家

知道 Java 的初衷是为什么而开发的麽？是为嵌入式程序开发的。记得上一篇讲到 classLoader 机制麽？

那正是为了节约嵌入式开发环境下内存而设计的。而走到今天，Java 成了人们心中为互联网诞生的语言。

互联网意味着什么？多线程是必然的趋势。客观环境在变，Java 技术也随着飞速发展，导致越来越脱离

它的初衷。据说 Sun 公司其实主打的是 J2se，结果又是由于客观环境影响，J2se 几乎遗忘，留在大家谈

专家预言将在亚洲或者中国出现， Whatever，客观环境变化趋势才是决定大方向的关键。当然笔者也希

望会出现在中国，^_^~~

2． 关于 Java 设计模式

身边的很多在看 GOF 的 23 种设计模式，似乎学习它无论在学校还是在职场，都成了一种流行风气。我不

想列举解释这 23 种 Design Pattern， 我写这些的初衷一直都是谈自己的经历和看法，希望能帮助大家

理解。

首先我觉得设计模式只是对一类问题的一种通用解决办法，只要是面向对象的编程预言都可以用得上这

23 种。理解它们最好的方法就是亲自去写每一种，哪怕是一个简单的应用就足够了。如果代码实现也记

不住的话，记忆它们对应的 UML 图会是一个比较好的办法，当然前提是必须了解 UML。

同时最好能利用 Java 自身的类库帮助记忆，例如比较常用的观察者模式，在 java.util.*有现成的 Observer

接口和 Observable 这个实现类，看看源代码相信就足够理解观察者模式了。再比如装饰器模式，大家只

FileOutputStream、BufferedReader、PrintWriter 的时候就能感觉到原来设计模式离我们如此之近，而且

另外，在学习某些模式的同时，反而更能帮助我们理解 java 类库的某些特点。例如当你编写原型

(Prototype)模式的时候，你必须了解的是 java.lang.Cloneable 这个接口和所有类的基类 Object 的

clone()这个方法。即深 copy 和浅 copy 的区别：

Object.clone()默认实现的是浅 copy，也就是复制一份对象拷贝，但如果对象包含其他对象的引用，不会

复制引用，所以原对象和拷贝共用那个引用的对象。

深 copy 当然就是包括对象的引用都一起复制啦。这样原对象和拷贝对象，都分别拥有一份引用对象。如

果要实现深 copy 就必须首先实现 java.lang.Cloneable 接口，然后重写 clone()方法。因为在 Object 中的

clone()方法是 protected 签名的，而 Cloneable 接口的作用就是把 protected 放大到 public，这样 clone()

才能被重写。

那么又有个问题了？如果引用的对象又引用了其他对象呢？这样一直判断并复制下去，是不是显得很麻烦？

曾经有位前辈告诉我的方法是重写 clone 方法的时候直接把原对象序列化到磁盘上再反序列化回来，这样

不 用 判 断 就 可 以 得 到 一 个 深 copy 的 结 果 。 如 果 大 家 不 了 解 序 列 化 的 作 法 建 议 看 一 看

ObjectOutputStream 和 ObjectInputStream

归根结底，模式只是思想上的东西，把它当成前人总结的经验其实一点都不为过。鼓励大家动手自己去写，

例如代理模式，可以简单的写一个 Child 类， Adult 类。Child 要买任何东西由 Adult 来代理实现。简单来

说就是 Adult 里的 buy()内部实际调用的是 Child 的 buy()，可是暴露在 main 函数的却是 Adult.buy()。这样

Java 杂谈（三）

这已经笔者写的第三篇 Java 杂记了，庆幸前两篇一直得到论坛朋友们的支持鼓励，还望大家继续指

正不足之处。笔者也一直渴望通过这样方式清醒的自审，来寻找自己技术上的不足之处，希望和共同爱好

Java 的同仁们一起提高。

"getClass().getName() + "@" + Integer.toHexString(hashCode())"

其实不用我过多的解释，大家都能看懂这个串的组成。接下来再看看 hashCode()：

public native int hashCode()；

由于是 native 方法，跟 OS 的处理方式相关，源代码里仅仅有一个声明罢了。我们有兴趣的话完全可

以去深究它的 hashCode 到底是由 OS 怎么样产生的呢？但笔者建议最重要的还是先记住使用它的几条原

则吧！首先如果 equals()方法相同的对象具有相通的 hashCode，但 equals ()对象不相通的时候并不保证

hashCode()方法返回不同的整数。而且下一次运行同一个程序，同一个对象 未必还是当初的那个

hashCode() 哦。

其余的方法呢？nofigy()、notifyAll()、clone()、wait()都是 native 方法的，说明依赖于操作系统的实现。

最后一个有趣的方法是 finalize()，类似 C++的析构函数，签名是 protected，证明只有继承扩展了才能使

用，方法体是空的，默示什么也不做。它的作用据笔者的了解仅仅是通知 JVM 此对象不再使用，随时可

以被销毁，而实际的销毁权还是在于虚拟机手上。那么它真的什么也不做麽？未必，实际上如果是线程对

笔者曾经听一位搞 Java 培训多年的前辈说在他看来 hashCode 方法没有任何意义，仅仅是为了配合证明

学过数据结构的课程大家都会知道有一种结构叫 hash table，目的是通过给每个对象分配一个唯一

的索引来提高查询的效率。那么 Java 也不会肆意扭曲改变这个概念，所以 hashCode 唯一的作用就是为

支 持 数 据 结 构 中 的 哈 希 表 结 构 而 存 在 的 ， 换 句 话 说 ， 也 就 是 只 有 用 到 集 合 框 架 的

Hashtable、HashMap、HashSet 的时候，才需要重载 hashCode()方法，

这样才能使得我们能人为的去控制在哈希结构中索引是否相等。笔者举一个例子：

曾经为了写一个求解类程序，需要随机列出 1,2,3,4 组成的不同排列组合，所以笔者写了一个数组类

用 int[]来存组合结果，然后把随机产生的组合加入一个 HashSet 中，就是想利用 HashSet 不包括重复元素

的特点。可是 HashSet 怎么判断是不是重复的元素呢？当然是通过 hashCode()返回的结果是否相等来判

断啦，可做一下这个实验：

这明明是同一种组合，却是不同的 hashCode，加入 Set 的时候会被当成不同的对象。这个时候我们

就需要自己来重写 hashCode()方法了，如何写呢？其实也是基于原始的 hashCode()，毕竟那是操作系统

的实现， 找到相通对象唯一的标识，实现方式很多，笔者的实现方式是：

return A[0]“+” A[1]“+” A[2]“+” A[3]; //显示上比较直观

然后利用 toString()来计算 hashCode()：

return this.toString().hashCode()；

这样上述 A 和 B 返回的就都是”1234”，在测试 toString().hashCode()，由于 String 在内存中的副本是

一样的，”1234”.hashCode()返回的一定是相同的结果。

方法名来调用该对象的任何方法。这是因为 Java 的类在内存中除了 C++中也有的静态动态数据区之外，

还包括一份对类自身的描述，也正是通过这描述中的信息，才能帮助我们才运行时读取里面的内容，得到

的时候，怎么知道它有哪些属性呢？再明显简单不过的例子就是自己写一个 JavaBean 的解析器：

a. 通过 Class.forName(“Bean 的类名”)得到 Class 对象，例如叫 ABeanClass

b. 通过 ABeanClass 的 getMethods()方法，得到 Method[]对象

c. 按照规范所有 get 方法名后的单词就代表着该 Bean 的一个属性

d. 当已经知道一个方法名，可以调用 newInstance()得到一个实例，然后通过 invoke()方法将方法的

名字和方法需要用的参数传递进去，就可以动态调用此方法。

当然还有更复杂的应用，这里就不赘述，大家可以参考 Class 类和 Method 类的方法。

束锁被解除。它的实现原理很简单，仅仅是不让第二把锁再次被加在同一个对象或类上，仅此而已。一个

class A{

void g(){}

}

当 A 的一个对象 a 被第一个线程调用其 f()方法的时候，第二个线程不能调用 a 的 synchronized 方法

例如 f()，因为那是在试图在对象上加第二把锁。但调用 g()却是可以的，因为并没有在同一对象上加两把

锁的行为产生。

这样大家能理解了麽？明白它的原理能更好的帮助大家设计同步机制，不要滥用加锁。

PS：下篇笔者计划开始对 J2ee 接触到的各个方面来进行总结，谈谈自己的经验和想法。希望大家还

能一如既往的支持笔者写下去，指正不足之处。

Java 杂谈（四）