以下内容转载自 Sun关于CLASSPATH设置的中文说明文档：

使用 CLASSPATH 环境变量

一般用户将想要使用 -classpath 命令行选项。下面将介绍如何设置 CLASSPATH 环境变量或清除以前安装遗留下的设置。

设置 CLASSPATH

在 DOS 提示符下，可用 set 命令修改 CLASSPATH 环境变量。其格式为：

   set CLASSPATH=path1;path2 ...

路径应该以指定驱动器的字母开头，例如 C:\...。这样，在偶然切换到不同驱动器时仍可找到类（例如，如果路径项以 \... 开头，并且当前位于驱动器 D: 上，则所需的类将在 D: 而不是 C: 驱动器上找）。

清除 CLASSPATH

如果 CLASSPATH 环境变量被设置成不正确的值，或启动文件或脚本程序设置了不正确路径，则可通过使用下列命令清除 CLASSPATH：

  C:> set CLASSPATH=

该命令仅清除当前会话的 CLASSPATH。要确保在以后的会话中具有正确的 CLASSPATH 设置，则应该删除或修改启动设置。

更改启动设置

如果在系统启动时设置 CLASSPATH 变量，则查找它的位置取决于所使用的操作系统：
 

操作系统	方法
Windows 98 和 Windows 95	检查 autoexec.bat 文件中的 set 命令。
Windows xp	启动“控制面板”，选择“系统”，单击“环境”选项卡，并在“用户变量”部分中，检查 CLASSPATH 变量。

理解类路径和包名

Java 类被组织成包，而这些包被映射到文件系统中的目录。但是与文件系统不同的是，无论何时指定包名，都应指定完整包名 -- 永远不要仅指定它的一部分。例如，java.awt.Button 的包名总是应指定为 java.awt。

例如，假定想要 Java 运行环境在包 utility.myapp 中查找名为 Cool.class 的类。如果该目录的路径为 C:\java\MyClasses\utility\myapp，则应该将类路径设置成包含 C:\java\MyClasses。

要运行该应用程序，可使用下述 JVM 命令：

C:>  java -classpath C:\java\MyClasses utility.myapp.Cool

当该应用程序运行时，JVM 使用类路径设置查找在 utility.myapp 包中定义的任何其他类。

注意：应在命令中指定完整包名。例如，设置类路径包含 C:\java\MyClasses\utility 并使用命令 java myapp.Cool 是不可能的，因为这找不到该类。

（您可能想知道用什么定义类的包名。答案是：包名是类的一部分，并且不能修改，除非重新编译该类。）

注意：包规范机制一个有趣的结果是，属于相同包的多个文件实际上可存在于不同的目录中。对于每个类，包名都是相同的，但是每个文件的路径可从类路径中的不同目录开始。

文件夹和归档文件

当类存储在目录（文件夹）中时，例如 c:\java\MyClasses\utility\myapp，则类路径项指向包含包名第一个元素的目录（在这里为 C:\java\MyClasses，因为包名是 utility.myapp）。

但是当类存储在归档文件（.zip 或 .jar 文件）中时，类路径项则是该 .zip 或 .jar 文件的路径。例如，要使用位于 .jar 文件中的类库，则命令应该类似下述形式：

   java -classpath C:\java\MyClasses\myclasses.jar utility.myapp.Cool

多重指定

要在目录 C:\java\MyClasses 和 C:\java\OtherClasses 中查找类文件，则可将类路径设置为：

   java -classpath C:\java\MyClasses;C:\java\OtherClasses ...

注意两个路径之间用分号分隔。

指定次序

指定多个类路径项的次序是相当重要的。Java 解释器将按照目录在类路径变量中的次序在各个目录中查找类。在上例中，Java 解释器首先在目录 C:\java\MyClasses 中查找需要的类。只有当它在该目录中没有找到该类时，解释器才能到 C:\java\OtherClasses 目录中查找。

 以上需要注意的是：我是在j2se1.5的版本上设置的 系统是XP.Pro
     1.在 “我的电脑”下设置成功CLASSPATH后 就不用再在每次运行javac和java命令提示符的时候设置CLASSPATH   除非包路径有所改变
    2.编译成功以后 可以在任何地方执行该.class文件
    3.当运行java命令提示符的时候  务必注明该文件的相对路径
    4.在设置 文件所在包的包名的时候不能跟 java定义的包名字一样 诸如java，javax之类的

          第1部分上传完毕   ！

           单击下载：

            http://www.orbitfiles.com/download/macinter   

                         陆续更新中......
            

             第4章 初始化和清理
        
         1.构造函数
      是与类名字相同的一种特殊函数  
      提供构造函数，可以确保对象的初始化动作一定会被执行
      <构造函数是不会返回任何东西的>
      没有自定义任何构造函数 编译器会调用默认的构造器
      如果定义了构造器(有或者无参数) 编译器就不会为你分配构造器
       
         2.关键字this
      仅用于函数之内 能够唤起此函数所在的那个类的引用
      以下引用Sun的JLS关于this关键字的说明：

      The keyword this may be used only in the body of an instance method,
      instance initializer or constructor, or in the initializer of an instance variable of a class.
      If it appears anywhere else, a compile-time error occurs.        
     
      When used as a primary expression, the keyword this denotes a value that is a reference
      to the object for which the instance method was invoked ,
      or to the object being constructed. The type of this is the class C within which the keyword this occurs.
      At run time, the class of the actual object referred to may be the class C or any subclass of C.

      翻译一下就是：
      <E文太烂>
      关键字this应该仅仅被用在实例化方法，实例初始化(??)或者构造器，又或者在类的实例化变量的初始化时(??)<像是下面Flower(String s, int petals)构造器中s的赋值??>

    如果它出现在其他地方，将会在编译时发生错误.
     
      当被使用在主表达式时，关键字this表示的是一个指向在实例化方法中调用的类或者是正在被构造的类的引用.
      This在关键字发生类C的内部.在运行的时候，事实上指向的是类C或者类C的子类 .

    一段来自Think in java 2中有关构造函数以及this的代码：

 1   public   class  Flower  {
 2       
 3           int  petalCount  =   0 ;
 4          String s  =   new  String( " null " );
 5          
 6          Flower( int  petals)
 7            {
 8              petalCount  =  petals;
 9              System.out.println( " Constructor w/ int arg only, petalCount=  " +  petalCount);
10            }
11            
12         Flower(String ss) 
13          {
14             System.out.println( " Constructor w/ String arg only, s= "   +  ss);
15             s  =  ss;
16         }
17         
18         Flower(String s,  int  petals) 
19          {
20             this (petals); 
21           // this(s);  //  Can't call two!
22            this .s  =  s;  //  Another use of "this"
23            System.out.println( " String & int args " );
24         }
25         
26        Flower() 
27         {
28             this ( " hi " ,  47 );
29            System.out.println( " default constructor (no args) " );
30        }
31        
32       void  print() 
33       {
34         // !    this(11);  //  Not inside non-constructor!
35        System.out.println(  " petalCount =  "   +  petalCount  +   "  s =  " +  s);
36      }
37      
38    public   static   void  main(String[] args) 
39       {
40         Flower x  =   new  Flower();
41         x.print();
42      }  
43   
44   
45 }  

Constructor w /   int  arg only, petalCount =   47
String  &   int  args
default  constructor (no args)
petalCount  =   47  s  =  hi

  class  Tag  {
  Tag( int  marker)  {
    System.out.println( " Tag( "   +  marker  +   " ) " );
    }
   }

class  Card  {
  Tag t1  =   new  Tag( 1 );  //  Before constructor
  Card()  {
     //  Indicate we're in the constructor:
    System.out.println( " Card() " );
    t3  =   new  Tag( 33 );  //  Reinitialize t3
  }
  Tag t2  =   new  Tag( 2 );  //  After constructor
   void  f()  {
    System.out.println( " f() " );
  }
  Tag t3  =   new  Tag( 3 );  //  At end
}

public   class  OrderOfInitialization  {
   public   static   void  main(String[] args)  {
    Card t  =   new  Card();   // 程序入手点
    t.f();  //  Shows that construction is done
  }
}  
      

Tag( 1 )
Tag( 2 )
Tag( 3 )
Card()
Tag( 33 )
f()

         第3章  控制程序流程
  
    1.赋值和指派
  赋值动作以"=" 运算符
  对基本型别：A=B,B的内容复制给A 如果你修改A值，B不会被修改
  对象而言：实际操作的是reference 所以像上面的话就指向了同一个对象
 
   2.运算
  int i=9 与 Integer i=new Integer(9) 是不一样的
  后者是对象的声明
  对象的比较：内容和引用的比较
  对象内容的比较：object1.equals(object2)
  <！注意！>
 

  为甚么第1个结果是true，第2个是false
 
 以下引至JavaAPI ：

 Object 类的 equals 方法实现对象上差别可能性最大的相等关系；
 即，对于任何非空引用值 x 和 y，当且仅当 x 和 y <引用同一个对象>时，
 此方法才返回 true（x == y 具有值 true）
 指向同一个对象是才返回true

      3.位运算符
   AND  &    2个输入符皆为1时，才为1，否则为0
   OR    |     任何一个为1，就为1；2个都是0时，才为0
   XOR  ^    2个输入位恰有1个为1时才为1，不能同时为1
   NOT  ~    仅仅接受1位操作数，产生输入位的反相
   <以上的位运算符除NOT(~)都可以和=号并用>
  
   4.位移运算符
   只有<<,>>,<<=,>>=,>>>=
   没有<<<=
   并且只能用于整数型别的数上(byte,short,int,long)
  
   <<: 左操作数向左移，左移的个数由右操作数决定
   ------------------
   Ex:  byte i=4;
         i<<=2;
   ------------------
   二进制表示：    00000100         4
  <<向左移2位    00010000          16
 
  -------------------
  Ex: byte i=-4;
       i<<=2;
  -------------------
  负数是先计算正数再取反(??)
 
  >>:操作数是正数的，则左操作数向右移
       操作数是负数的，如果原值是正数，较高位补0
                             原值是负数，较高位补1
  而>>>是原值是正还是负 都在较高位处处补0       
  <byte和short计算先晋升为int，最后再转化为byte或者short>                        
                
   5.if-else三元运算符
   boolean expression ? value1:value2
   true就执行value1，false就执行value2
  
   6.String运算问题
   ------------------------
    Ex: int x=1,y=2,z=3;
    String s="x,y,z"
    System.out.println(s+x+y+z);
    System.out.println(x+y+z+s);
   -------------------------
    results: x,y,z123
               6x,y,z
              
    7.当if小括号里面的2个类型均是boolean时：
       

 boolean i=false,j=false;
    
         if(i==j){
          
             System.out.println("i==j");
             
         }
         if(i=j){
          
            System.out.println("i=j");
         
        }        
           
      boolean i=true,j=true;
    
         if(i==j){
          
             System.out.println("i==j");
             
         }
         if(i=j){
          
            System.out.println("i=j");
         
        }           

   如果i与j true false不一样 if(i=j)后面的句子是不会被执行的
   如果i与j同是false  if(i=j)后面的句子不会被执行
   如果i与j同是true  if(i=j)后面的句子却会被执行
                 
     8.数据类型之间的转换
        小转大是自动转换 大转小是强制转换
       
        float,int,boolean  ---> string
        String.valueOf(i)
       
        String --->int,float,
        Integer.parseInt(i)
       
        String --->long,double
        Long.parseInt(i)
        Double.parseInt(i)
     
      9.流程控制
      if-else        else字句是可有可无
      while    在循环开始时会评估一次 执行一次以后会再评估的
      do-while   语句至少执行一次，即使是开始就评估为false
      for(initialization;boolean-exp;step)
        在for小括号里的第1部分和第3部分可以由多个逗号(,)分隔的句子构成
        他们会被依序执行
      break  是跳出循环体 不再执行循环体里的部分
      continue    是回到循环起始处，开始下一个循环
     
      switch
        语法：switch(integral-sele) {
               
             case intergral-sele1 :statement; break;
             case intergral-sele2 :statement; break;
             case intergral-sele3 :statement; break;
               ......
            default : statement;
       
           }          
        <注意>
        如果没有break语句，语句执行到可执行的条件句子以后，后面的语句会继续执行
        如果没有break语句，也找不到可执行的句子，如果有default语句，会执行
         default语句以及default以后的句子  

       TO BE CONTINUED ......
  
                 MACINTER.

          第2章 万事万物皆对象 
  
       1.虽然抽象对象概念上把所有东西"视为"对象，但用以操作对象的那些标记符
 却仅仅是其 reference 即引用
 
       2.8大基本数据类型（基本型别）
          byte,short,int,long,float,double,char,string
除string以外都是直接存放数据值，不再是reference形式

       3.Array数组：必须保证数组一定会被初始化
对数组数据的调用不能逾越数组的下标
产生数组对象时，真正产生其实是个存储reference的数组

       4.当使用new来产生java对象，即使离开了生存空间，该对象依然存在
只是对象的引用在生存空间以外消失了，而该对象会继续占用内存

       5.定义类即class
 数据成员和函数 也就是 成员变量和方法
class中的成员是基本型别时，如果未进行初始化，java会保证它有缺省值
<但是并不意味着你能调用之>   
<只用当变量是class内的成员是，才会提供此初始值>     
 
       6.当返回类型为void时，关键字return只是用来离开函数
而不必等到执行至函数最末端
  
       7.关键字static
不论产生多少个对象，或不存在任何对象的情形下，其存储空间只有1个
<不用跟class对象绑在一起>
      
       8.注释和内嵌式文档
<对程序员而言是很重要的>
comment:/*           */ ,  //,
javadoc命令句：
针对以 /** 为首的注释内，以 */ 为结束
注释位置都必须恰好在 类，变量，方法定义之前
<只会针对public和protected>

 Example：
 

  // : c02:HelloDate.java
  //  From 'Thinking in Java, 2nd ed.' by Bruce Eckel
//  www.BruceEckel.com . See copyright notice in CopyRight.txt.
   import java.util. * ; 

/** */ /**  The first Thinking in Java example program.
 * Displays a string and today's date.
 *  @author  Bruce Eckel
 *  @author  www.BruceEckel.com 
 *  @version  2.0 
*/
public   class  HelloDate  {
   /** */ /**  Sole entry point to class & application
   *  @param  args array of string arguments
   *  @return  No return value
   *  @exception  exceptions No exceptions thrown
   */
   public   static   void  main(String[] args)  {
    System.out.println( " Hello, it's:  " );
    System.out.println( new  Date());
  }
}   // /:~                                  

 TO BE CONTINUED ......
  
        MACINTER.

15:56:00