public Cache() {
                super();
        }
                
        public Cache(String key, String value, long timeOut, boolean expired) {
                this.key = key;
                this.value = value;
                this.timeOut = timeOut;
                this.expired = expired;
        }

        public String getKey() {
                return key;
        }

        public long getTimeOut() {
                return timeOut;
        }

        public Object getValue() {
                return value;
        }

        public void setKey(String string) {
                key = string;
        }

        public void setTimeOut(long l) {
                timeOut = l;
        }

        public void setValue(Object object) {
                value = object;
        }

        public boolean isExpired() {
                return expired;
        }

        public void setExpired(boolean b) {
                expired = b;
        }
}

另外一个类：
import java.util.Date;
import java.util.HashMap;

public class CacheManager {
        private static HashMap cacheMap = new HashMap();

        /**
         * This class is singleton so private constructor is used.
         */
        private CacheManager() {
                super();
        }

        /**
         * returns cache item from hashmap
         * @param key
         * @return Cache
         */
        private synchronized static Cache getCache(String key) {
                return (Cache)cacheMap.get(key);
        }

        /**
         * Looks at the hashmap if a cache item exists or not
         * @param key
         * @return Cache
         */
        private synchronized static boolean hasCache(String key) {
                return cacheMap.containsKey(key);
        }

        /**
         * Invalidates all cache
         */
        public synchronized static void invalidateAll() {
                cacheMap.clear();
        }

        /**
         * Invalidates a single cache item
         * @param key
         */
        public synchronized static void invalidate(String key) {
                cacheMap.remove(key);
        }

        /**
         * Adds new item to cache hashmap
         * @param key
         * @return Cache
         */
        private synchronized static void putCache(String key, Cache object) {
           cacheMap.put(key, object);
        }

        /**
         * Reads a cache item's content
         * @param key
         * @return
         */
        public static Cache getContent(String key) {
                 if (hasCache(key)) {
                        Cache cache = getCache(key);
                        if (cacheExpired(cache)) {
                                cache.setExpired(true);
                        }
                        return cache;
                 } else {
                         return null;
                 }
        }

        /**
         * 
         * @param key
         * @param content
         * @param ttl
         */
        public static void putContent(String key, Object content, long ttl) {
                Cache cache = new Cache();
                cache.setKey(key);
                cache.setValue(content);
                cache.setTimeOut(ttl + new Date().getTime());
                cache.setExpired(false);
                putCache(key, cache);
        }
        
        /** @modelguid {172828D6-3AB2-46C4-96E2-E72B34264031} */
        private static boolean cacheExpired(Cache cache) {
                if (cache == null) {
                        return false;
                }
                long milisNow = new Date().getTime();
                long milisExpire = cache.getTimeOut();
                if (milisExpire < 0) {                // Cache never expires 
                        return false;
                } else if (milisNow >= milisExpire) {
                        return true;
                } else {
                        return false;
                }
        }

}

Java Instant Messenger (or JIM) is an application to allow instant messaging over a network. JIM does not have a centralized server. Instead, users run the server on one of the computers on the network and other users connect to that server.

(This Description is auto-translated)
http://zh.sourceforge.jp/projects/sfnet_jinstantmessage/

3、IM客户端 Spark
Spark是一个开源，跨平台IM客户端。它的特性支持集组聊天，电话集成和强大安全性能。如果企业内部部署IM使用Openfire+Spark是最佳的组合。
http://www.oschina.net/p/spark
http://blog.csdn.net/masterjames/archive/2009/08/21/4465255.aspx


４、LumaQQ 
 LumaQQ 是一个独立的   Java   QQ   客户端，具有可重用的纯Java核心和基于SWT的仿   QQ   界面。我们遵循GNU   General   Public   License   许可证（简称GPL）发布。该条款的原文可见和   LumaQQ   源代码一同发布的   COPYING   文件。    
      需要特别声明的是   LumaQQ   是以研究和学习为目的的，我们并没有违反   QQ   的版权许可的东西。一切的协议分析都是把   QQ   当作黑箱分析，我们所做的一切都遵循中华人民共和国《计算机软件保护条例》。
http://lumaqq.linuxsir.org/main/index.php

５、Openfire
Openfire 是实时的基于WEB的即时消息传输平台，是原来的Jive Messenger
http://www.oschina.net/p/openfire

６、类似QQ的聊天软件JAVA版源码（附设计文档）
作者：其实像QQ聊天这样的软件有很多，但基本上都没有公开源代码，而且也只是提供软件客户端，有一些像ICQ的软件虽提供服务端但却不公开源代码。本人很想知道它的运行机理，想弄明白它是怎么一回事，所以就试着做了一个，虽然没有正式公司的那么复杂和友好的界面，但至少可以给你点启发，对学习是有帮助的。
http://www.codefans.net/soft/1472.shtml
http://www.chinajia.com/soft/downinfo/3383.html

７、JavaQQ.
用java写的简单QQ，共同学习 。
http://www.itxuexi.com/bbs/thread-13226-1-1.html
http://download.csdn.net/source/745684

Java 中的 ClassPath 和 Package

前言:

由于这两个问题新手问得较多, 且回答比较零散, 很难统一整理, 所
以就直接写了一篇, 还请大家见谅.

正文:

一, 类路径 (class path)

当你满怀着希望安装好了 java, 然后兴冲冲地写了个 hello world,然后编译,
运行, 就等着那两个美好的单词出现在眼前, 可是不幸的是, 只看到了 Can't find
class HelloWorld 或者 Exception in thread "main" java.lang.NoSuchMethodError: ma
in.
为什么呢? 编译好的 class 明明在呀.
我们一起来看一看 java 程序的运行过程. 我们已经知道 java 是通过 java

发信人: SuperMMX (笑天子), 信区: Java
标 题: [整理] Java 的 Class Path 和 Package
发信站: BBS 水木清华站 (Mon Apr 9 08:15:01 2001)

Java 中的 ClassPath 和 Package

前言:

由于这两个问题新手问得较多, 且回答比较零散, 很难统一整理, 所
以就直接写了一篇, 还请大家见谅.

正文:

一, 类路径 (class path)

当你满怀着希望安装好了 java, 然后兴冲冲地写了个 hello world,然后编译,
运行, 就等着那两个美好的单词出现在眼前, 可是不幸的是, 只看到了 Can't find
class HelloWorld 或者 Exception in thread "main" java.lang.NoSuchMethodError: ma
in.
为什么呢? 编译好的 class 明明在呀.
我们一起来看一看 java 程序的运行过程. 我们已经知道 java 是通过 java

虚拟机来解释运行的, 也就是通过 java 命令, javac 编译生成的 .class
文件就是虚拟机要执行的代码, 称之为字节码(bytecode), 虚拟机通过 classloader
来装载这些字节码, 也就是通常意义上的类. 这里就有一个问题, classloader 从
哪里知道 java 本身的类库及用户自己的类在什么地方呢? 或者有着缺省值(当前路径).
或者要有一个用户指定的变量来表明, 这个变量就是类路径(classpath), 或者在运行
的时候传参数给虚拟机. 这也就是指明 classpath 的三个方法. 编译的过程和运行
的过程大同小异, 只是一个是找出来编译, 另一个是找出来装载.
实际上 java 虚拟机是由 java luncher 初始化的, 也就是 java (或 java.exe)
这个程序来做的. 虚拟机按以下顺序搜索并装载所有需要的类:
1, 引导类: 组成 java 平台的类, 包含 rt.jar 和 i18n.jar 中的类.
2, 扩展类: 使用 java 扩展机制的类, 都是位于扩展目录($JAVA_HOME/jre/lib/ext)
中的 .jar 档案包.
3, 用户类: 开发者定义的类或者没有使用 java 扩展机制的第三方产品. 你必须在
命令行中使用 -classpath 选项或者使用 CLASSPATH 环境变量来确定这些类的位置. 我
们在上面所说的用户自己的类就是特指这些类.
这样, 一般来说, 用户只需指定用户类的位置, 引导类和扩展类是"自动"寻找的.
那么到底该怎么做呢? 用户类路径就是一些包含类文件的目录, .jar, .zip 文件的
列表, 至于类具体怎么找, 因为牵扯到 package 的问题, 下面将会说到, 暂时可认为
只要包含了这个类就算找到了这个类. 根据平台的不同分隔符略有不同, 类 unix 的系
统基本上都是 ":", windows 多是 ";". 其可能的来源是:

* ".", 即当前目录, 这个是缺省值.

* CLASSPATH 环境变量, 一旦设置, 将缺省值覆盖.
* 命令行参数 -cp 或者 -classpath, 一旦指定, 将上两者覆盖.
* 由 -jar 参数指定的 .jar 档案包, 就把所有其他的值覆盖, 所有的类都来自这个指
定的档案包中. 由于生成可执行的 .jar 文件, 还需要其他一些知识, 比如 package, 还有
特定的配置文件, 本文的最后会提到. 可先看看 jdk 自带的一些例子.

我们举个 HelloWorld 的例子来说明. 先做以下假设:
* 当前目录是 /HelloWorld (或 c:\HelloWorld, 以后都使用前一个)
* jdk 版本为 1.2.2 (linux 下的)
* PATH 环境变量设置正确. (这样可以在任何目录下都可以使用工具)
* 文件是 HelloWorld.java, 内容是:

public class HelloWorld
{
public static void main(String[] args)
{
System.out.println("Hello World!\n");
System.exit(0);
}
}

首先这个文件一定要写对, 如果对 c 熟悉的话, 很有可能写成这样:

public static void main(int argc, String[] argv)
{
....
}

这样是不对的, 不信可以试一试. 由于手头没有 java 的规范, 所以
作如下猜想: java 的 application 程序, 必须以 public static void main(String[])
开始, 其他不一样的都不行.

到现在为止, 我们设置方面只设置了 PATH.

1, 当前路径就是指你的 .class 文件在当前目录下,

[HelloWorld]$ javac HelloWorld.java //这一步不会有多大问题,
[HelloWorld]$ java HelloWorld // 这一步可能就会有问题.

如果出了象开头那样的问题, 首先确定不是由于敲错命令而出错. 如果没有敲错命令,
那么接着做:

[HelloWorld]$ echo $CLASSPATH
或者

c:\HelloWorld>echo %CLASSPATH%

看看 CLASSPATH 环境变量是否设置了, 如果设置了, 那么用以下命令:

[HelloWorld]$ CLASSPATH=
或者
c:\HelloWorld> set CLASSPATH=

来使它为空, 然后重新运行. 这次用户类路径缺省的是 ".", 所以应该不会有相
同的问题了. 还有一个方法就是把 "." 加入到 CLASSPATH 中.

[/]$ CLASSPATH=$CLASSPATH:.
或者
c:\HelloWorld> set CLASSPATH=%CLASSPATH%;.

同样也可以成功. Good Luck.

2, 当你的程序需要第三方的类库支持, 而且比较常用, 就可以采用此种方法.比如常
用的数据库驱动程序, 写 servlet 需要的 servlet 包等等. 设置方法就是在环境变量中
加入 CLASSPATH. 然后就可以直接编译运行了. 还是以 HelloWorld 为例, 比如你想在根
目录中运行它, 那么你直接在根目录下执行

$ java HelloWorld
或者
c:\>java HelloWorld

这样肯定会出错, 如果你的 CLASSPATH 没有改动的话. 我想大家应该知道为什么错了
吧, 那么怎么改呢? 前面说过, 用户类路径就是一些包含你所需要的类的目录, .jar 档案
包, .zip 包. 现在没有生成包, 所以只好把 HelloWorld.class 所在的目录加到 CLASSPAT
H
了, 根据前面的做法, 再运行一次, 看看, 呵呵, 成功了, 换个路径, 又成功了!! 不仅仅
可
以直接运行其中的类, 当你要 import 其中的某些类时, 同样处理.
不知道你想到没有, 随着你的系统的不断的扩充, (当然了, 都是一些需要 java 的东
西)
如果都加到这个环境变量里, 那这个变量会越来越臃肿, 虽然环境变量空间可以开很大, 总
觉得有些不舒服. 看看下面一个方法.

3, 在命令行参数中指明 classpath.

还是和上面相同的目标, 在任何目录下执行 HelloWorld, 用这个方法怎么实现呢?

[/]$ java -cp /HelloWorld HelloWorld
或者

c:\>java -cp c:\HelloWorld HelloWorld

就可以了. 这是这种方法的最简单的应用了. 当你使用了另外的包的时候, 还可以采用
这
种方法. 例如:

$ javac -classpath aPath/aPackage.jar:. myJava.java
$ java -cp aPath/aPackage.jar:. myJava
或者
c:\> javac -classpath aPath\aPackage.jar;. myJava.java
c:\> java -cp aPath\aPackage.jar;. myJava

这种方法也有一个不方便的的地方就是当第三方包所在的路径较长或者需要两个以上包
的
时候, 每次编译运行都要写很长, 非常不方便, 这时候可以写脚本来解决. 比如一个例子:

compile (文件, 权限改为可执行, 当前目录)

$ cat compile
---------------------------
#!/bin/bash

javac -classpath aPath\aPackage.jar:anotherPath\anotherPackage.jar:. myJav
a.java
---------------------------

run (文件, 权限改为可执行, 当前目录)

$cat run
---------------------------
#!/bin/bash

java -cp aPath\aPackage.jar:anotherPath\anotherPackage.jar:. myJava
---------------------------

或者:

compile.bat

c:\HelloWorld> type compile.bat
-------------------------
javac -classpath aPath\aPackage.jar:anotherPath\anotherPackage.jar:. myJav
a.java
-------------------------

run.bat

c:\HelloWorld> type run.bat
------------------------
java -cp aPath\aPackage.jar:anotherPath\anotherPackage.jar:. myJava
------------------------
就可以了. 试试看.
前面提到了扩展类, 扩展类是什么呢? java 的扩展类就是应用程序开发者用来
扩展核心平台功能的 java 类的包(或者是 native code). 虚拟机能像使用系统类一
样使用这些扩展类. 有人建议可以把包放入扩展目录里, 这样, CLASSPATH 也不用设了,
也不用指定了, 岂不是很方便? 确实可以正确运行, 但是个人认为这样不好, 不能什么
东西都往里搁, 一些标准的扩展包可以, 比如, JavaServlet, Java3D 等等. 可以提个
建议, 加一个环境变量, 比如叫 JARPATH, 指定一个目录, 专门存放用户的 jar zip
等包, 这个要等 SUN 公司来做了.

windows98 下, 我原来安装的时候, 一直装不上, 总是死机, 好不容易装上了, 缺
省的是不能运行正确的, 然后把 tool.jar 放入 CLASSPATH 后工作正常. 现在作测试,
去掉仍然是正确的. 经过多次测试, 发现如果原来曾装过 jdk 的都很好, 没有装过的
装的时候会死机, 多装几次就可以了. 如果你发现正确安装后, 不能正常工作, 就把
tools.jar 加入 CLASSPATH, 试一下.

二, 包 (package)

Java 中的 "包" 是一个比较重要的概念, package 是这样定义的:

Definition: A package is a collection of related classes and interfaces
that provides access protection and namespace management.

也就是: 一个包就是一些提供访问保护和命名空间管理的相关类与接口的集合.
使用包的目的就是使类容易查找使用, 防止命名冲突, 以及控制访问.
这里我们不讨论关于包的过多的东西, 只讨论和编译, 运行, 类路径相关的东西.
至于包的其他内容, 请自己查阅相关文档.

简单一点来说, 包就是一个目录, 下面的子包就是子目录, 这个包里的类就是
这个目录下的文件. 我们用一个例子来说明.
首先建目录结构如下: PackageTest/source/, 以后根目录指的是 PackageTest
目录, 我们的源程序放在 source 目录下. 源程序如下:

PackageTest.java

package pktest;

import pktest.subpk.*;

public class PackageTest
{
private String value;

public PackageTest(String s)
{
value = s;
}

public void printvalue()
{
System.out.println("value of PackageTest is " + value);
}

public static void main(String[] args)
{
PackageTest test = new PackageTest("This is a Test Package");
test.printvalue();
PackageSecond second = new PackageSecond("I am in PackageTest");

second.printvalue();
PackageSub sub = new PackageSub("I am in PackageTest");
sub.printvalue();
System.exit(0);
}
}

PackageSecond.java

package pktest;

public class PackageSecond
{
private String value;

public PackageSecond(String s)
{
value = s;
}

public void printvalue()
{

System.out.println("value of PackageSecond is " + value);
}
}

PackageSub.java

package pktest.subpk;

import pktest.*;

public class PackageSub
{
private String value;

public PackageSub(String s)
{
value = s;
}

public void printvalue()
{
PackageSecond second = new PackageSecond("I am in subpackage.");

second.printvalue();
System.out.println("value of PackageSub is " + value);
}

}

Main.java

import pktest.*;
import pktest.subpk.*;

public class Main()
{
public static void main()
{
PackageSecond second = new PackageSecond("I am in Main");
second.printvalue();
PackageSub sub = new PackageSub("I am in Main");
sub.printvalue();
System.exit(0);
}
}

其中, Main.java 是包之外的一个程序, 用来测试包外的程序访问包内的类,
PackageTest.java 属于 pktest 这个包, 也是主程序. PackageSecond.java 也
属于 pktest, PackageSub 属于 pktest 下的 subpk 包, 也就是 pktest.subpk.
详细使用情况, 请参看源程序.
好了, 先把源程序都放在 source 目录下, 使 source 成为当前目录, 然后编
译一下, 呵呵, 出错了,

Main.java:1: Package pktest not found in import.
import pktest.*;

这里涉及到类路径中包是怎么查找的, 前面我们做了一点假设: "只要包含了
这个类就算找到了这个类", 现在就有问题了. 其实 jdk 的 工具 javac java
javadoc 都需要查找类, 看见目录, 就认为是包的名字, 对于 import 语句来说,
一个包对应一个目录. 这个例子中, import pktest.*, 我们知道类路径可以包
含一个目录, 那么就以那个目录为根, 比如有个目录 /myclass, 那么就会在查找
/myclass/pktest 目录及其下的类. 所有的都找遍, 如果没有就会报错. 由于现在
的类路径只有当前目录, 而当前目录下没有 pktest 目录, 所以就会出错. 类路径
还可以包含 .jar .zip 文件, 这些就是可以带目录的压缩包, 可以把 .jar .zip
文件看做一个虚拟的目录, 然后就和目录一样对待了.
好了, 应该知道怎么做了吧, 修改后的目录结构如下:

PackageTest
|
|__source Main.java
|
|__pktest PackageTest.java PackageSecond.java
|
|__subpk PackageSub.java

然后重新编译, 运行, 哈哈, 通过了. 我们再来运行一下 PackageTest.

[source]$ java pktest/PackageTest

怎么又出错了?

Exception in thread "main" java.lang.NoClassDefFoundError: pktest/PackageTest

是这样的, java 所要运行的是一个类的名字, 它可不管你的类在什么地方, 就象
我们前面所讨论的一样来查找这个类, 所以它把 pktest/PackageTest 看成是一个类的
名字了, 当然会出错了, 应该这么做,

[source]$ java pktest.PackageTest

大家应该明白道理吧, 我就不多说了. 注意 javac 不一样, 是可以指明源文件路径
的, javac 只编译, 不运行, 查找类也只有在源文件中碰到 import 时才会做, 与源文件
所在的包没有关系.
似乎还又些不好的地方, 怎么生成的 .class 文件这么分散呀, 看着真别扭. 别急,
javac 有一个 -d 命令行参数, 可以指定一个目录, 把生成的 .class 文件按照包给你
好好地搁在这个目录里面.

[source]$ mkdir classes
[source]$ javac -d classes pktest/PackageTest.java
[source]$ javac -d classes Main.java

那么运行怎么运行呢?

[source]$ cd classes
[classes]$ java pktest.PackageTest
[classes]$ java Main

就可以了. 其实 jdk 的这一套工具小巧简单, 功能强大, 不会用或者用错其
实不关工具的事, 关键是明白工具背后的一些原理和必要的知识. 集成环境是很好,
但是它屏蔽了很多底层的知识, 不出错还好, 一旦出错, 如果没有这些必要的知识
就很难办, 只好上 bbs 问, 别人只告诉了你解决的具体方法, 下一次遇到稍微变化
一点的问题又不懂了. 所以不要拘泥于工具, java 的这一套工具组合起来使用, 中

小型工程(五六十个类), 还是应付得下来的.

三, jar 文件

以下把 .jar .zip 都看做是 .jar 文件.

1, 从前面我们可以看出来 jar 文件在 java 中非常重要, 极大地方便了用户的
使用. 我们也可以做自己的 .jar 包.
还是使用前面那个例子, Main.java 是包之外的东西, 用了 pktest 包中的类,
我们现在就是要把 pktest 做成一个 .jar 包, 很简单, 刚才我们已经把 pktest
中的 .class 都集中起来了,

[classes]$ jar -cvf mypackage.jar pktest

就会生成 mypackage.jar 文件, 测试一下, 刚才我们生成的 Main.class 就在
classes 目录下, 所以, 从前面可以知道:

[classes]$ java -cp mypackage.jar:. Main

就可以运行了.

2, 如果你看过 jdk 所带的例子, 你就会知道, .jar 还可以直接运行,

[/demo]$ java -jar aJar.jar

那好, 就那我们的试一试,

[classes]$ java -jar mypackage.jar
Failed to load Main-Class manifest attribute from
mypackage.jar

看来我们的 jar 和它的 jar 还不一样, 有什么不一样呢? 拿它一个例子出来,
重新编译, 生成 .jar 文件, 比较后发现, 是 .jar 压缩包中 META-INF/MANIFEST.MF
文件不一样, 多了一行, Main-Class: xxxxx, 再看看出错信息, 原来是没有指定
Main-Class, 看看 jar 命令, 发现有一个参数 -m,

-m include manifest information from specified manifest file

和出错信息有点关系, 看来它要读一个配制文件. 只好照猫画虎写一个了.

[classes]$ cat myManifest
Manifest-Version: 1.0

Main-Class: pktest.PackageTest
Created-By: 1.2.2 (Sun Microsystems Inc.)

[classes]$ jar cvfm mypackage.jar myManifest pktest
added manifest
adding: pktest/(in = 0) (out= 0)(stored 0%)
adding: pktest/PackageSecond.class(in = 659) (out= 395)(deflated 40%)
adding: pktest/subpk/(in = 0) (out= 0)(stored 0%)
adding: pktest/subpk/PackageSub.class(in = 744) (out= 454)(deflated 38%)
adding: pktest/PackageTest.class(in = 1041) (out= 602)(deflated 42%)

[classes]$ java -jar mypackage.jar
value of PackageTest is This is a Test Package
value of PackageSecond is I am in PackageTest
value of PackageSecond is I am in subpackage.
value of PackageSub is I am in PackageTest

好了, 成功了, 这样就做好了一个可以直接执行的 .jar 文件. 大家可以自己试一试
做一个以 Main 为主程序的可执行的 jar.

小结:

这篇文章中, 我们讨论了 java 中的 class path, package, jar 等基本但比较
重要的东西, 主要是 class path. 并不是简单的一份 CLASSPATH 的完全功略, 而是
试图让读者明白其原理, 自己思考, 自己动手. 其实大多数东西都在 sun 的 java doc
中都有, 我只不过结合例子稍微谈了一下, 希望能有所帮助. 由于条件所限, 只测试了
jdk1.2.2 在 98 及 linux 的情况, 其他版本的 jdk 和平台请大家自己测试, 错误在
所难免, 还请指正.

下面是一些需要注意的问题:

1, 如果类路径中需要用到 .jar 文件, 必须把 jar 文件的文件名放入类路径, 而不是
其所在的目录.
2, 在任何时候, 类名必须带有完全的包名,
3, "." 当前目录最好在你的类路径中.

下面是一些常见的编译和运行的模式.

4. To compile HelloWorld.java app in the default package in C:\MyDir, use
CD \MyDir
C:\jdk1.3\bin\Javac.exe -classpath . HelloWorld.java
5. To run a HelloWorld.class app, in the default package in C:\MyDir, use
CD \MyDir

C:\jdk1.3\bin\Java.exe -classpath . HelloWorld
6. To run a HelloWorld.class app, in the default package in a jar in C:\MyDir, u
se
CD \MyDir
C:\jdk1.3\bin\Java.exe -classpath HelloWorld.jar HelloWorld
7. To compile a HelloWorld.java app in C:\MyPackage, in package MyPackage, use
CD \
C:\jdk1.3\bin\Javac.exe -classpath . MyPackage\HelloWorld.java
8. To run a HelloWorld.class app in C:\MyPackage, in package MyPackage, use
CD \
C:\jdk1.3\bin\Java.exe -classpath . MyPackage.HelloWorld
9. To run a HelloWorld.class app in C:\MyPackage, in a jar in package MyPackage,
use
CD \MyDir
C:\jdk1.3\bin\Java.exe -classpath HelloWorld.jar MyPackage.HelloWorl
d

(注: default package 指的是在程序中不指定任何包).

最后一个小小的建议, 把 sun 的 jdk tools document．tion 好好地看一看,
把 jdk 的那些工具 java javac javadoc jar javap jdb......好好用一用, 会
有好处的. The Simplest Is The Best.

 2.如何一次把一个目录下的所有.jar加入到classpath?

tomcat的做法
//tomcat.bat
...
set _LIBJARS=
for %%i in (%TOMCAT_HOME%\lib\*.jar) do call
%TOMCAT_HOME%\bin\cpappend.bat %%i
...

//cpappend.bat
set _LIBJARS=%_LIBJARS%;%1
 

3.classspath 的默认值是什么?

在 JDK 1.2 中，有三个搜索路径用于查找类：
1) java 搜索类的第一个位置是自举类路径。
可通过调用 System.getProperty("sun.boot.class.path") 检查该路径的值。
注意，其中前缀“sun.”显示至少到现在为止，该属性是特定于 Sun 公司的实现。
2) java 查找类的第二个位置是扩展目录。
可通过调用 System.getProperty("java.ext.dirs") 检查目录列表。
3) java 查找类的第三个位置是应用程序类路径。
可通过调用 System.getProperty("java.class.path") 检查该路径的值。

you can get:

1) java_base\jre\lib\rt.jar
java_base\jre\lib\i18n.jar
java_base\jre\classes
2) java_base\jre\lib\ext

4.怎样找到程序运行需要的类?

编译的时候用选项 javac -verbose ********
可以看你的程序都用到了类库中的哪些类 .

java -verbose
javac -verbose
是jdk很好的调试功能

5. Linux下Path和ClassPath是怎么设的?
修改文件 /etc/profile
CLASSPATH = pathAathBathC
export CLASSPATH

JAVA_HOME类似
和windows下设置的主要区别应该在分隔符上

6.如何修改path和classpath?

方法一：用cmd进入控制台，输入set命令，你会看到你机子上的所有环境变量的名称和值！
然后你再输入set classpath=你要设的目录。就可以了！！！
方法二：
2000,控制面板-》系统-》高级-》环境变量-》系统变量，如果没有CLASSPATH变量就自己新建
一个
xp:
开始-> 我的电脑->属性->高级－＞环境变量->新建
JAVA_HOME
CLASSPATH
PATH

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/yicikou/archive/2004/06/28/28715.aspx

• Arbow
• 等级:
• 
• 文章: 133
• 积分: 561
• 来自: 广州
• 

• 空心菜
• 等级:
• 
• 文章: 38
• 积分: 785
• 

包括class文件的结构、class是如何进入到虚拟机中的（类装载）、class的消亡（垃圾收集）

Class 的结构

   Class 文件由 java 代码编译而来，每个类都会生成一个 .class 文件。 Java class 文件中包含了 java 虚拟机所需知道的、关于类或接口的所有信息。这些信息用表格的形式来说明，我们可以得到 classfile 表：如图 1

图 1 classfile 表的格式

其中类型或者为表名，或者如表 1 所示的“基本类型”。所有存储在类型 u2 、 u4 和 u8 中的值，在 class 文件中以高位在前的形式出现。

表 1 class 文件“基本类型”

Classfile 表中各项简介如下：

1)         Magic( 魔数 )

每个 java class 文件的前 4 个字节被称为 magic number ： 0xCAFEBABE 。魔数的作用在于，可以轻松的分辨出 java class 文件和非 java class 文件。

 Class 文件的下面 4 个字节包含了主次版本号。随着 java 技术的发展， java class 文件格式可能会加入新特性。 Class 文件格式一旦发生变化，版本号也会随之变化。如果 class 文件的版本号超出了 java 虚拟机所能处理的有效范围， java 虚拟机将不会处理该文件。

 之后的是常量池。其中包含了与文件中类和接口相关的常量。常量池中存储了诸如文字字符串、 final 变量值、类名和方法名的常量。 Java 虚拟机把常量池组织为入口列表的形式。在实际列表 constant_pool 之前，是入口在列表中的计数 constant_pool_count 。

 常量池中的许多入口都指向其他的常量池入口，而且 class 文件中紧随着常量池的许多条目也会指向常量池中的入口。在整个 class 文件中，指示常量池入口在常量池列表中位置的整数索引都指向这些常量池入口。列表中的一项索引值为 1 ，第二项索引值为 2 ，以此类推。

例： act.class 的常量池。

“ { }V ”表示一个返回类型为 void 的方法。

 访问标志。这个字段表示的意思指明了文件中定义的是类还是接口；还定义了在类或接口的声明中，使用了哪种修饰符：是抽象的还是公共的，或者是 final 。类的类型可以为 final ，而 final 类不可能是抽象的，同时接口也不能为 final 类型。

 这个类的名字和超类名字。特殊的，对于 object 类， super_class 为 0 ，除此以外 super_class 对于所有的类均有效。对于接口，在常量池入口 super_class 位置的项为 java.lang.object

。

 紧接着 super_class 的是 Interfaces_count 。此项的含义为：在文件中由该类直接实现或者由该接口所扩展的父接口的数量。在这个技术的后面，是名为 interfaces 的数组，它包含了对每个由由该类直接实现或者由该接口所扩展的父接口的常量池索引。