System類保存靜態(tài)方法和變量的集合。標(biāo)準(zhǔn)的輸入，輸出和Java運行時錯誤輸出存儲在變量in，out和err中。由System類定義的方法列在表14-11中。注意當(dāng)所做操作是安全方式所不允許的時，許多方法引發(fā)一個安全異常（SecurityException）。應(yīng)當(dāng)注意的另一點是：Java 2不贊成使用runFinalizersonExit( )方法。該方法是在Java 1.1中增加的，同時也被證明是不可靠的。
讓我們看一看System類的一些普遍用法。
表11  由Sysem定義的方法
方法 描述 
static void arraycopy(Object source, int   sourceStart, Object target, int targetStart,   int size) 復(fù)制數(shù)組。被復(fù)制的數(shù)組由source傳遞，而source中開始復(fù)制數(shù)組時的下標(biāo)由sourceStart傳遞。接收復(fù)制的數(shù)組由target傳遞。而target中開始復(fù)制數(shù)組時的下標(biāo)由targetStart傳遞。Size是被復(fù)制的元素的個數(shù) 
static long currentTimeMillis( )  返回自1970年1月1日午夜至今的時間，時間單位為毫秒。 
static void exit(int exitCode)  暫停執(zhí)行，返回exitCode值給父進(jìn)程（通常為操作系統(tǒng)）。按照約定，0表示正常退出，所有其他的值代表某種形式的錯誤 
static void gc( )  初始化垃圾回收 
static Properties getProperties( )  返回與Java運行系統(tǒng)有關(guān)的屬性類（Properties class）將在第15章中介紹） 
static String getProperty(String which)  返回與which有關(guān)的屬性。如果期望的屬性沒有被發(fā)現(xiàn)，返回一個空對象（null object） 
static String getProperty(String which,   String default) 返回一個與which有關(guān)的屬性。如果期望的屬性沒有被發(fā)現(xiàn)，則返回default 
static SecurityManager getSecurityManager( )  返回當(dāng)前的安全管理程序，如果沒有安裝安全管理程序，則返回一個空對象（null object） 
static native int identityHashCode(Object obj)  返回obj的特征散列碼 
static void load(String libraryFileName)  載入其文件由libraryFileName指定的動態(tài)庫，必須指定其完全路徑 
static void loadLibrary(String libraryName)  載入其庫名為libraryName的動態(tài)庫 
static String mapLibraryName(String lib)  對應(yīng)名為lib的庫，返回一個指定平臺的名字（在Java 2中新增加的） 
static void runFinalization( )  啟動調(diào)用不用的但還不是回收站中的對象的finalize( )方法。 
static void setErr(PrintStream eStream)  設(shè)置標(biāo)準(zhǔn)的錯誤（err）流為iStream 
static void setIn(InputStream iStream)  設(shè)置標(biāo)準(zhǔn)的輸入（in）流為oStream 
static void setOut(PrintStream oStream) 設(shè)置標(biāo)準(zhǔn)的輸出（out）流eStream 
static void  setProperties(Properties sysProperties) 設(shè)置由sysProperties指定的當(dāng)前系統(tǒng)屬性 
Static String setProperty(String which,  String v)  將v值賦給名為which的屬性（在Java 2中新增加的） 
static void setSecurityManager ( SecurityManager secMan) 設(shè)置由secMan指定的安全管理程序 

可以發(fā)現(xiàn)System類的一個特別有意義的用法是利用currentTimeMillis( )方法來記錄你的程序的不同部分的執(zhí)行時間。currentTimeMillis( )方法返回自從1970年1月1號午夜起到現(xiàn)在的時間，時間單位是毫秒。如果要記錄你的程序中一段有問題程序的運行時間可以在這段程序開始之前存儲當(dāng)前時間，在該段程序結(jié)束之際再次調(diào)用currentTimeMillis( )方法。執(zhí)行該段程序所花費的時間為其結(jié)束時刻的時間值減去其開始時刻的時間值。下面的程序說明了這一點：
// Timing program execution.

class Elapsed {
  public static void main(String args[]) {
    long start, end;

    System.out.println("Timing a for loop from 0 to 1,000,000");

    // time a for loop from 0 to 1,000,000    
    start = System.currentTimeMillis(); // get starting time
    for(int i=0; i < 1000000; i++) ;
    end = System.currentTimeMillis(); // get ending time

    System.out.println("Elapsed time: " + (end-start));
  }
}
這里是程序運行的一個輸出樣本（記住你的程序的運行結(jié)果可能與此不同）：
Timing a for loop from 0 to 1,000,000
Elapsed time: 10

使用arraycopy( )方法可以將一個任意類型的數(shù)組快速地從一個地方復(fù)制到另一個地方。這比使用Java中編寫的循環(huán)要快的多。下面是一個用arraycopy( )方法復(fù)制兩個數(shù)組的例子。首先，將數(shù)組a復(fù)制給數(shù)組b，接下來，數(shù)組a中的所有元素向后移一位，然后數(shù)組b中元素向前移一位。
// Using arraycopy().

class ACDemo {
  static byte a[] = { 65, 66, 67, 68, 69, 70, 71, 72, 73, 74 };
  static byte b[] = { 77, 77, 77, 77, 77, 77, 77, 77, 77, 77 };

  public static void main(String args[]) {
    System.out.println("a = " + new String(a));
    System.out.println("b = " + new String(b));
    System.arraycopy(a, 0, b, 0, a.length);
    System.out.println("a = " + new String(a));
    System.out.println("b = " + new String(b));
    System.arraycopy(a, 0, a, 1, a.length - 1);
    System.arraycopy(b, 1, b, 0, b.length - 1);
    System.out.println("a = " + new String(a));
    System.out.println("b = " + new String(b));
  }
}
正如從下面的輸出中看到的那樣，可以使用相同的源和目的在任一方向進(jìn)行復(fù)制：
a = ABCDEFGHIJ
b = MMMMMMMMMM
a = ABCDEFGHIJ
b = ABCDEFGHIJ
a = AABCDEFGHI
b = BCDEFGHIJJ

下面的屬性在Java 2的所有環(huán)境中可以使用：
file.separator java.vendor.url os.arch 
java.class.path java.version os.name 
java.class.version java.vm.name os.version 
java.ext.dirs java.vm.specification.name Path.separator 
java.home java.vm.specification.vendor User.dir 
java.specification.name java.vm.specification.version User.home 
java.specification.vendor java.vm.vendor User.name 
java.specification.version java.vm.version  
java.vendor line.separator  
可以通過調(diào)用System.getProperty( )方法來獲得不同環(huán)境變量的值。例如下面的程序顯示當(dāng)前用戶目錄的路徑：
class ShowUserDir {
  public static void main(String args[]) {
    System.out.println(System.getProperty("user.dir"));
  }
}

正如我們在第1部分所提及的，Object類是其他所有類的一個超類。表14-12給出了Object類中定義的方法，這些方法對于每一個對象都是可用的。

表12  由Object定義的方法
方法 描述 
Object clone( )   Throws      CloneNotSupportedException 創(chuàng)建一個與調(diào)用對象一樣的新對象 
Boolean equals(Object object) 如果調(diào)用對象等價于object返回true 
void finalize( )   throws Throwable 默認(rèn)的finalize( )方法。常常被子類重載 
final Class getClass( )  獲得描述調(diào)用對象的Class對象 
int hashCode( )  返回與調(diào)用對象關(guān)聯(lián)的散列碼 
final void notify( )  恢復(fù)等待調(diào)用對象的線程的執(zhí)行 
final void notifyAll( )  恢復(fù)等待調(diào)用對象的所有線程的執(zhí)行 
String toString( )  返回描述對象的一個字符串 
final void wait( )   throws InterruptedException 等待另一個執(zhí)行的線程 
final void wait(long milliseconds)   throws InterruptedException 等待直至指定毫秒數(shù)的另一個執(zhí)行的線程 
final void wait(long milliseconds,              int nanoseconds)   throws InterruptedException 等待直至指定毫秒加毫微秒數(shù)的另一個執(zhí)行的線程 

由Object類定義的絕大部分方法在本書其他部分討論。而一個特別值得關(guān)注的方法是clone( )。clone( )方法創(chuàng)建調(diào)用它的對象的一個復(fù)制副本。只有那些實現(xiàn)Cloneable接口的類能被復(fù)制。
Cloneable接口沒有定義成員。它通常用于指明被創(chuàng)建的一個允許對對象進(jìn)行位復(fù)制（也就是對象副本）的類。如果試圖用一個不支持Cloneable接口的類調(diào)用clone( )方法，將引發(fā)一個CloneNotSupportedException異常。當(dāng)一個副本被創(chuàng)建時，并沒有調(diào)用被復(fù)制對象的構(gòu)造函數(shù)。副本僅僅是原對象的一個簡單精確的拷貝。
復(fù)制是一個具有潛在危險的操作，因為它可能引起不是你所期望的副作用。例如，假如被復(fù)制的對象包含了一個稱為obRef的引用變量，當(dāng)副本創(chuàng)建時，副本中的obRef如同原對象中的obRef一樣引用相同的對象。如果副本改變了被obRef引用的對象的內(nèi)容，那么對應(yīng)的原對象也將被改變。這里是另一個例子。如果一個對象打開一個I/O流并被復(fù)制，兩個對象將可操作相同的流。而且，如果其中一個對象關(guān)閉了流，而另一個對象仍試圖對I/O流進(jìn)行寫操作的話，將導(dǎo)致錯誤。
由于復(fù)制可能引起問題，因此在Object內(nèi)，clone( )方法被說明為protected。這就意味著它必須或者被由實現(xiàn)Cloneable的類所定義的方法調(diào)用，或者必須被那些類顯式重載以便它是公共的。讓我們看關(guān)于下面每一種方法的例子。
下面的程序?qū)崿F(xiàn)Cloneable接口并定義cloneTest( )方法，該方法在Object中調(diào)用clone( )方法：
// Demonstrate the clone() method.

class TestClone implements Cloneable {
  int a;
  double b;

  // This method calls Object‘s clone().
  TestClone cloneTest() {
    try {
      // call clone in Object.
      return (TestClone) super.clone();
    } catch(CloneNotSupportedException e) {
      System.out.println("Cloning not allowed.");
      return this;
    }
  }
}

class CloneDemo {
  public static void main(String args[]) {
    TestClone x1 = new TestClone();
    TestClone x2;

    x1.a = 10;
    x1.b = 20.98;

    x2 = x1.cloneTest(); // clone x1

    System.out.println("x1: " + x1.a + " " + x1.b);
    System.out.println("x2: " + x2.a + " " + x2.b);
  }
}
這里，方法cloneTest( )在Object中調(diào)用clone( )方法并且返回結(jié)果。注意由clone( )方法返回的對象必須被強制轉(zhuǎn)換成它的適當(dāng)類型（TestClone）。
下面的例子重載clone( )方法以便它能被其類外的程序所調(diào)用。為了完成這項功能，它的存取說明符必須是public，如下所示：
// Override the clone() method.

class TestClone implements Cloneable {
  int a;
  double b;

  // clone() is now overridden and is public.
  public Object clone() {
    try {
      // call clone in Object.
      return super.clone();
    } catch(CloneNotSupportedException e) {
      System.out.println("Cloning not allowed.");
      return this;
    }
  }
}

class CloneDemo2 {
  public static void main(String args[]) {
    TestClone x1 = new TestClone();
    TestClone x2;

    x1.a = 10;
    x1.b = 20.98;

    // here, clone() is called directly.
    x2 = (TestClone) x1.clone(); 

    System.out.println("x1: " + x1.a + " " + x1.b);
    System.out.println("x2: " + x2.a + " " + x2.b);
  }
}
由復(fù)制帶來的副作用最初一般是比較難發(fā)現(xiàn)的。通常很容易想到的是類在復(fù)制時是很安全的，而實際卻不是這樣。一般在沒有一個必須的原因的情況下，對任何類都不應(yīng)該執(zhí)行Cloneable。

Class封裝對象或接口運行時的狀態(tài)。當(dāng)類被加載時，類型Class的對象被自動創(chuàng)建。不能顯式說明一個類（Class）對象。一般地，通過調(diào)用由Object定義的getClass( )方法來獲得一個類（Class）對象。由Class定義的一些最常用的方法列在表14-13中。
表13  由Class定義的一些方法
方法 描述 
static Class forName(String name)   throws ClassNotFoundException 返回一個給定全名的Class對象 
static Class forName(String name,   Boolean how, ClassLoader ldr)   throws ClassNotFoundException 返回一個給定全名的Calss對象。對象由ldr指定的加載程序加載。如果how為true，對象被初始化，否則它將不被初始化（在Java 2中新增加的） 
Class[ ] getClasses( )  對每一個公共類和接口，返回一個類（Class）對象。這些公共類和接口是調(diào)用對象的成員 
ClassLoader getClassLoader( )  返回一個加載類或接口的ClassLoader對象，類或接口用于實例化調(diào)用對象 
Constructor[ ] getConstructors( )   throws SecurityException 對這個類的所有的公共構(gòu)造函數(shù)，返回一個Constructor對象 
Constructor[ ] getDeclaredConstructors( )   throws SecurityException 對由這個類所聲明的所有構(gòu)造函數(shù)，返回一個Constructor對象 
Field[ ] getDeclaredFields( )   throws SecurityException 對由這個類所聲明的所有域，返回一個Field對象 
Method[ ] getDeclaredMethods( )   throws SecurityException 對由這個類或接口所聲明的所有方法，返回一個Method對象 
Field[ ] getFields( )   throws SecurityException 對于這個類的所有公共域，返回一個Field對象 
Class[ ] getInterfaces( )  當(dāng)調(diào)用對象時，這個方法返回一個由該對象的類類型實現(xiàn)的接口數(shù)組。當(dāng)調(diào)用接口時，這個方法返回一個由該接口擴(kuò)展的接口數(shù)組 
Method[ ] getMethods( )   throws SecurityException 對這個類中的所有公共方法，返回一個Method對象 
String getName( )  返回調(diào)用對象的類或接口的全名 
ProtectionDomain getProtectionDomain( )  返回與調(diào)用對象有關(guān)的保護(hù)范圍（在Java 2中新增加的） 
Class getSuperclass( )  返回調(diào)用對象的超類。如果調(diào)用對象是類型Object的，則返回值為空（null） 
Boolean isInterface( )  如果調(diào)用對象是一個接口，則返回true。否則返回false 
Object newInstance( )   throws IllegalAccessException,         InstantiationException 創(chuàng)建一個與調(diào)用對象類型相同的新的實例（即一個新對象）。這相當(dāng)于對類的默認(rèn)構(gòu)造函數(shù)使用new。返回新對象 
String toString( )  返回調(diào)用對象或接口的字符串表達(dá)式 
由Class定義的方法經(jīng)常用在需要知道對象的運行時類型信息的場合。如同表14-13中所說明的那樣，由Class提供的方法確定關(guān)于特定的類的附加信息。例如它的公共構(gòu)造函數(shù)，域以及方法。這對于本書后面將要討論的Java Beans函數(shù)是很重要的。
下面的程序說明了getClass( )（從Object繼承的）和getSuperclass( )方法（從Class繼承的）：
// Demonstrate Run-Time Type Information.
class X {
  int a;
  float b;
}

class Y extends X {
  double c;
}

class RTTI {
  public static void main(String args[]) {
    X x = new X();
    Y y = new Y();
    Class clObj;

    clObj = x.getClass(); // get Class reference
    System.out.println("x is object of type: " +
                       clObj.getName());

    clObj = y.getClass(); // get Class reference
    System.out.println("y is object of type: " +
                       clObj.getName());
    clObj = clObj.getSuperclass();
    System.out.println("y‘s superclass is " +
                       clObj.getName());
  }
}
這個程序的輸出如下所示：
x is object of type: X
y is object of type: Y
y’s superclass is X

抽象類ClassLoader規(guī)定了類是如何加載的。應(yīng)用程序可以創(chuàng)建擴(kuò)展ClassLoader的子類，實現(xiàn)它的方法。這樣做允許使用不同于通常由Java運行時系統(tǒng)加載的另一些方法來加載類。由ClassLoader定義的一些方法列在表14-14中。
表14  由CalssLoader定義的一些方法
方法 描述 
final Class defineClass(String str, byte b[ ],   int index, int numBytes)   throws ClassFormatError 返回一個類（Class）對象，類的名字在str中，對象包含在由b指定的字節(jié)數(shù)組中。該數(shù)組中對象開始的位置下標(biāo)由index指定，而該數(shù)組的長度為numBytes。b中的數(shù)據(jù)必須表示一個有效的對象 
final Class findSystemClass(String name)   throws ClassNotFoundException 返回一個給定名字的類（Class）對象 
abstract Class loadClass(String name, boolean callResolveClass)   throws ClassNotFoundException 如果callResolveClass為true，這個抽象方法的實現(xiàn)工具必須加載一個給定名字的類，并調(diào)用resolveClass( )方法 
final void resolveClass(Class obj) 用obj引用的類被解析（即，它的名字被輸入在類名字空間中） 
 

Math類保留了所有用于幾何學(xué)，三角學(xué)以及幾種一般用途方法的浮點函數(shù)。Math定義了兩個雙精度（double）常數(shù)：E（近似為2.72）和PI（近似為3.14）。

下面的三種方法對一個以弧度為單位的角度接收一個雙精度（double）參數(shù)并且返回它們各自的超越函數(shù)的結(jié)果：
方法 描述 
Static double sin(double arg) 返回由以弧度為單位由arg指定的角度的正弦值 
static double cos(double arg) 返回由以弧度為單位由arg指定的角度的余弦值 
static double tan(double arg) 返回由以弧度為單位由arg指定的角度的正切值 
下面的方法將超越函數(shù)的結(jié)果作為一個參數(shù)，按弧度返回產(chǎn)生這個結(jié)果的角度值。它們是其非弧度形式的反。
方法 描述 
static double asin(double arg) 返回一個角度，該角度的正弦值由arg指定 
static double acos(double arg) 返回一個角度，該角度的余弦值由arg指定 
static double atan(double arg) 返回一個角度，該角度的正切值由arg指定 
static double atan2(double x, double y) 返回一個角度，該角度的正切值為x/y 

Math定義了下面的指數(shù)方法：
方法 描述 
static double exp(double arg) 返回arg的e 
static double log(double arg) 返回arg的自然對數(shù)值 
static double pow(double y, double x) 返回以y為底數(shù)，以x為指數(shù)的冪值；例如pow(2.0, 3.0)返回8.0 
static double sqrt(double arg) 返回arg的平方根 

Math類定義了幾個提供不同類型舍入運算的方法。這些方法列在表15中。

表15  由Math定義的舍入方法
方法 描述 
static int abs(int arg)  返回arg的絕對值 
static long abs(long arg)  返回arg的絕對值 
static float abs(float arg)  返回arg的絕對值 
static double abs(double arg) 返回arg的絕對值 
static double ceil(double arg)  返回大于或等于arg的最小整數(shù) 
static double floor(double arg)  返回小于或等于arg的最大整數(shù) 
static int max(int x, int y)  返回x和y中的最大值 
static long max(long x, long y)  返回x和y中的最大值 
static float max(float x, float y)  返回x和y中的最大值 
static double max(double x, double y)  返回x和y中的最大值 
static int min(int x, int y)  返回x和y中的最小值 
static long min(long x, long y)  返回x和y中的最小值 
static float min(float x, float y)  返回x和y中的最小值 
static double min(double x, double y)  返回x和y中的最小值 
static double rint(double arg)  返回最接近arg的整數(shù)值 
static int round(float arg)  返回arg的只入不舍的最近的整型（int）值 
static long round(double arg) 返回arg的只入不舍的最近的長整型（long）值 

除了給出的方法，Math還定義了下面這些方法：
static double IEEEremainder(double dividend, double divisor)
static double random( )
static double toRadians(double angle)
static double toDegrees(double angle)
IEEEremainder( )方法返回dividend/divisor的余數(shù)。random( )方法返回一個偽隨機數(shù)，其值介于0與1之間。在大多數(shù)情況下，當(dāng)需要產(chǎn)生隨機數(shù)時，通常用Random類。toRadians( )方法將角度的度轉(zhuǎn)換為弧度。而toDegrees( )方法將弧度轉(zhuǎn)換為度。這后兩種方法是在Java 2中新增加的。
下面是一個說明toRadians( )和toDegrees( )方法的例子：
// Demonstrate toDegrees() and toRadians().
class Angles {
  public static void main(String args[]) {
    double theta = 120.0;

    System.out.println(theta + " degrees is " +
                       Math.toRadians(theta) + " radians.");

    theta = 1.312;
    System.out.println(theta + " radians is " +
                       Math.toDegrees(theta) + " degrees.");
  }
}
程序輸出如下所示：
120.0 degrees is 2.0943951023931953 radians.
1.312 radians is 75.17206272116401 degrees.

在Java 2的1.3版本中增加了StrictMath類。這個類定義一個與Math中的數(shù)學(xué)方法類似的一套完整的數(shù)學(xué)方法。兩者的區(qū)別在于StrictMath中的方法對所有Java工具保證產(chǎn)生精確一致的結(jié)果，而Math中的方法更大程度上是為了提高性能。

Compiler類支持創(chuàng)建將字節(jié)碼編譯而非解釋成可執(zhí)行碼的Java環(huán)境。常規(guī)的程序不使用它。

Runnable接口以及Thread和ThreadGroup類支持多線程編程。下面分別予以說明。
注意：關(guān)于管理線程，實現(xiàn)Runnable接口以及創(chuàng)建多線程程序的概述已在第11章中介紹過。

Runnable接口必須由啟動執(zhí)行的獨立線程的類所實現(xiàn)。Runnable僅定義了一種抽象方法，叫做run( )。該方法是線程的入口點。它的形式如下所示：
abstract void run( )
所創(chuàng)建的線程必須實現(xiàn)該方法。

Thread創(chuàng)建一個新的執(zhí)行線程。它定義了如下的構(gòu)造函數(shù)：
Thread( )
Thread(Runnable threadOb)
Thread(Runnable threadOb, StringthreadName)
Thread(String threadName)
Thread(ThreadGroup groupOb, Runnable threadOb)
Thread(ThreadGroup groupOb, Runnable threadOb, String threadName)
Thread(ThreadGroup groupOb, String threadName)
threadOb是實現(xiàn)Runnable接口的類的一個實例，它定義了線程運行開始的地方。線程的名字由threadName指定。當(dāng)名字未被指定時，Java虛擬機將創(chuàng)建一個。groupOb指定了新線程所屬的線程組。當(dāng)沒有線程組被指定時，新線程與其父線程屬于同一線程組。
下面的常數(shù)由Thread定義：
MAX_PRIORITY
MIN_PRIORITY
NORM_PRIORITY
正如所期望的那樣，這些常數(shù)指定了最大，最小以及默認(rèn)的線程優(yōu)先權(quán)。
由Thread定義的方法列在表14-16中。在比Java 2早的版本中，Thread中也包括了stop( )，suspend( )以及resume( )方法。然而正如在第11章中解釋的那樣，這些方法由于其固有的不穩(wěn)定性而在Java 2中被擯棄了。在Java 2中擯棄的還有countStackFrames( )方法，因為它調(diào)用了suspend( )方法。
表16  由Thread定義的方法
方法 描述 
static int activeCount( )  返回線程所屬的線程組中線程的個數(shù) 
void checkAccess( )  引起安全管理程序檢驗當(dāng)前的線程能訪問和/或能改變在其上checkAccess( )方法被調(diào)用的線程 
static Thread currentThread( )  返回一個Thread對象，該對象封裝了調(diào)用這個方法的線程 
void destroy( )  終止線程 
static int enumerate(Thread threads[ ])  將當(dāng)前線程組中的所有Thread對象的拷貝放入threads中。返回線程的個數(shù) 
ClassLoader getContextClassLoader( )  返回用于對這個線程加載類和資源的類加載程序（在Java 2中新增加的） 
final String getName( )  返回線程名 
final int getPriority( )  返回線程的屬性設(shè)置 
final ThreadGroup getThreadGroup( )  返回調(diào)用線程是其中一個成員的ThreadGroup對象 
void interrupt( )  中斷線程 
static boolean interrupted( )  如果當(dāng)前執(zhí)行的線程已經(jīng)被預(yù)先設(shè)置了中斷，則返回true；否則，返回false 
final boolean isAlive( )  如果線程仍在運行中，則返回true；否則返回false 
final boolean isDaemon( )  如果線程是一個后臺進(jìn)程線程（Java運行系統(tǒng)的一部分），則返回true；否則返回false 
boolean isInterrupted( )  如果線程被中斷，則返回true，否則返回false 
final void join( )   throws InterruptedException 等待直至線程終止 
續(xù)表
方法 描述 
final void join(long milliseconds)   throws InterruptedException 等待直到為終止線程而指定的以毫秒計時的時間 
final void join(long milliseconds, int nanoseconds)   throws InterruptedException 等待直到為終止線程而指定的以毫秒加毫微秒計時的時間 
void run( )  開始線程的執(zhí)行 
void setContextClassLoader(ClassLoader cl)  設(shè)置將被調(diào)用線程用于cl的類加載程序（在Java 2中新增加的） 
final void setDaemon(boolean state)  標(biāo)記線程為后臺進(jìn)程線程 
final void setName(String threadName)  將線程的名字設(shè)置為由threadName指定的名字 
final void setPriority(int priority)  設(shè)置由priority指定的線程優(yōu)先權(quán) 
static void sleep(long milliseconds)   throws InterruptedException 以指定的毫秒為單位的時間長度掛起執(zhí)行的線程 
static void sleep(long milliseconds, int nanoseconds)   throws InterruptedException 以指定的毫秒加毫微秒為單位的時間長度掛起執(zhí)行的線程 
void start( )  開始線程的執(zhí)行 
String toString( )  返回線程的等價字符串形式 
static void yield( )  調(diào)用線程將CPU讓給其他的線程 
14.13.3  ThreadGroup
線程組（ThreadGroup）創(chuàng)建了一組線程。它定義了如下的兩個構(gòu)造函數(shù)：
ThreadGroup(String groupName)
ThreadGroup(ThreadGroup parentOb, String groupName)
對于兩種形式，groupName指定了線程組的名字。第一種形式創(chuàng)建一個新的線程組，該線程組將當(dāng)前的線程作為它的父線程。在第二種形式中，父線程由parentOb指定。
由ThreadGroup定義的方法列在表14-17中。在比Java 2更早出現(xiàn)的Java版本中，ThreadGroup中也包括了stop( )，suspend( )以及resume( )方法。這些方法由于其本身固有的不穩(wěn)定性，而在Java 2中被擯棄。
表14-17  由ThreadGroup定義的方法
方法 描述 
int activeCount( )  返回線程組加上以這個線程作為父類的所有線程組中線程的個數(shù) 
int activeGroupCount( )  返回調(diào)用線程是父類的線程的組數(shù) 
final void checkAccess( )  引起安全管理程序檢驗調(diào)用線程能訪問和/或能改變在其上checkAccess( )方法被調(diào)用的線程組 

final void destroy( )  撤消被調(diào)用的線程組（以及任一子線程組） 
int enumerate(Thread group[ ])  將構(gòu)成調(diào)用線程組的線程放入group數(shù)組中 
int enumerate(Thread group[ ], boolean all)  將構(gòu)成調(diào)用線程組的線程放入group數(shù)組中。如果all為true，那么線程組的所有子線程組中的線程也被放入group中 
int enumerate(ThreadGroup group[ ])  將調(diào)用線程組的子線程組放入group數(shù)組中 
int enumerate(ThreadGroup group[ ],   boolean all) 將調(diào)用線程組的子線程組放入group數(shù)組中。如果all為true，所有子線程組的子線程組（等等）也被放入group中 
final int getMaxPriority( )  返回對線程組設(shè)置的最大優(yōu)先權(quán) 
final String getName( )  返回線程組名 
final ThreadGroup getParent( )  如果調(diào)用ThreadGroup對象沒有父類，則返回null；否則返回調(diào)用對象的父類 
final void interrupt( )  調(diào)用線程組中所有線程的interrupt( )方法（在Java 2中新增加的） 
final boolean isDaemon( )  如果線程組是一個端口后臺進(jìn)程組，則返回true；否則返回false 
boolean isDestroyed( )  如果線程組已經(jīng)被破壞，則返回true；否則，返回false 
void list( )  顯示關(guān)于線程組的信息 
final boolean parentOf(ThreadGroup group)  如果調(diào)用線程是group的父線程（或group本身），則返回true；否則返回false 
final void setDaemon(boolean isDaemon) 如果isDaemon為true，那么調(diào)用線程組被標(biāo)記為一個端口后臺進(jìn)程組 
final void setMaxPriority(int priority)  對調(diào)用線程組設(shè)置最大優(yōu)先權(quán)priority 
String toString( )  返回線程組的字符串等價形式 
void uncaughtException(Thread thread,  Throwable e) 當(dāng)一個異常未被捕獲時，該方法被調(diào)用 
線程組提供了一種方便的方法，可以將一組線程當(dāng)做一個單元來管理。這在想掛起或恢復(fù)一些相關(guān)的線程的情況下，是特別有用的。例如假想在一個程序中，有一組線程被用來打印文檔，另一組線程被用來將該文檔顯示在屏幕上，同時另一組線程將文檔保存為磁盤文件。如果打印被異常中止了，想用一種很簡單的方法停止所有與打印有關(guān)的線程。線程組為這種處理提供了方便。下面的程序說明了這種用法，在程序中創(chuàng)建兩個線程組，每一線程組中有兩個線程：
// Demonstrate thread groups.
class NewThread extends Thread {
  boolean suspendFlag;

  NewThread(String threadname, ThreadGroup tgOb) {
    super(tgOb, threadname);
    System.out.println("New thread: " + this);
    suspendFlag = false;
    start(); // Start the thread
  }

  // This is the entry point for thread.
  public void run() {
    try {
      for(int i = 5; i > 0; i--) {
        System.out.println(getName() + ": " + i);
        Thread.sleep(1000);
        synchronized(this) {
          while(suspendFlag) {
            wait();
          }
        }
      }
    } catch (Exception e) {
      System.out.println("Exception in " + getName());
    }
    System.out.println(getName() + " exiting.");
  }

  void mysuspend() {
    suspendFlag = true;
  }

  synchronized void myresume() {
    suspendFlag = false;
    notify();
  }
}

class ThreadGroupDemo {
  public static void main(String args[]) {
    ThreadGroup groupA = new ThreadGroup("Group A");
    ThreadGroup groupB = new ThreadGroup("Group B");

    NewThread ob1 = new NewThread("One", groupA);
    NewThread ob2 = new NewThread("Two", groupA);
    NewThread ob3 = new NewThread("Three", groupB);
    NewThread ob4 = new NewThread("Four", groupB);

    System.out.println("\nHere is output from list():");
    groupA.list();
    groupB.list();
    System.out.println();

    System.out.println("Suspending Group A");
    Thread tga[] = new Thread[groupA.activeCount()];
    groupA.enumerate(tga); // get threads in group
    for(int i = 0; i < tga.length; i++) {
      ((NewThread)tga[i]).mysuspend(); // suspend each thread
    }

    try {
      Thread.sleep(4000); 
    } catch (InterruptedException e) {
      System.out.println("Main thread interrupted.");
    }

    System.out.println("Resuming Group A");
    for(int i = 0; i < tga.length; i++) {
      ((NewThread)tga[i]).myresume(); // resume threads in group
    }

    // wait for threads to finish
    try {
      System.out.println("Waiting for threads to finish.");
      ob1.join();
      ob2.join();
      ob3.join();
      ob4.join();
    } catch (Exception e) {
      System.out.println("Exception in Main thread");
    }

System.out.println("Main thread exiting.");
  }
}
該程序的一個輸出樣本如下所示：
New thread: Thread[One,5,Group A]
New thread: Thread[Two,5,Group A]
New thread: Thread[Three,5,Group B]
New thread: Thread[Four,5,Group B]
Here is output from list():
java.lang.ThreadGroup[name=Group A,maxpri=10]
  Thread[One,5,Group A]
  Thread[Two,5,Group A]
java.lang.ThreadGroup[name=Group B,maxpri=10]
  Thread[Three,5,Group B]
  Thread[Four,5,Group B]
Suspending Group A
Three: 5
Four: 5
Three: 4
Four: 4
Three: 3
Four: 3
Three: 2
Four: 2
Resuming Group A
Waiting for threads to finish.
One: 5
Two: 5
Three: 1
Four: 1
One: 4
Two: 4
Three exiting.
Four exiting.
One: 3
Two: 3
One: 2
Two: 2
One: 1
Two: 1
One exiting.
Two exiting.
Main thread exiting.
注意在這個程序中，線程組A被掛起四秒。由于輸出確認(rèn)，造成線程One和線程Two暫停，但是線程Three和線程Four仍然運行。四秒鐘之后，線程One和線程Two被恢復(fù)。注意線程組A是如何被掛起和恢復(fù)的。首先通過對線程組A調(diào)用enumerate( )方法得到線程組A中的線程。然后每一個線程重復(fù)通過得到的數(shù)組而被掛起。為了恢復(fù)線程組A中的線程，序列再一次被遍歷，每一個線程被恢復(fù)。最后一點：這個例子使用了Java 2推薦使用的方法去完成掛起和恢復(fù)線程的任務(wù)。而沒有用在Java 2中被擯棄的方法suspend( )和resume( )。

在Java 2的java.lang中增加了兩個與線程有關(guān)的類：
 ThreadLocal?用于創(chuàng)建線程局部變量。每個線程都擁有自己局部變量的拷貝。
 InheritableThreadLocal?創(chuàng)建可以被繼承的線程局部變量。

在Java 2中增加了一個稱為Package的類。這個類封裝了與包有關(guān)的版本數(shù)據(jù)。包版本信息由于包的增值以及由于Java程序可能需要知道哪些包版本可以利用而變得更加重要。Package中定義的方法列在表14-18中。下面的程序通過顯示程序當(dāng)前已知的包而說明了Package。
表18  由Package定義的方法
方法 描述 
String getImplementationTitle( ) 返回調(diào)用包的標(biāo)題 
String getImplementationVendor( )  返回調(diào)用包的實現(xiàn)程序的程序名 
String getImplementationVersion( )  返回調(diào)用包的版本號 
String getName( )  返回調(diào)用包的名字 
Static Package getPackage(String pkgName)  返回一個由pkgName指定的Package對象 
Static Package[ ] getPackages( )  返回調(diào)用程序當(dāng)前已知的所有包 
String getSpecificationTitle( )  返回調(diào)用包的規(guī)格說明的標(biāo)題 
String getSpecificationVendor( )  返回對調(diào)用包的規(guī)格說明的所有者的名字 
String getSpecificationVersion( ) 返回調(diào)用包的規(guī)格說明的版本號 
Int hashCode( ) 返回調(diào)用包的散列碼 
Boolean isCompatibleWith(String verNum)   throws NumberFormatException 如果verNum小于或等于調(diào)用包的版本號，則返回true 
Boolean isSealed( ) 如果調(diào)用包被封，則返回true；否則返回false 
Boolean isSealed(URL url) 如果調(diào)用包相對于url被封，則返回true；否則返回false。 
String toString( ) 返回調(diào)用包的等價字符串形式 
// Demonstrate Package
class PkgTest {
  public static void main(String args[]) {
    Package pkgs[];

    pkgs = Package.getPackages();

    for(int i=0; i < pkgs.length; i++)
      System.out.println(
             pkgs[i].getName() + " " +
             pkgs[i].getImplementationTitle() + " " +
             pkgs[i].getImplementationVendor() + " " +
             pkgs[i].getImplementationVersion()
      );

  }
}

在Java 2的java.lang中也新增加了RuntimePermission。它與Java的安全機制有關(guān)，這里不做進(jìn)一步的討論。

Throwable類支持Java的異常處理系統(tǒng)，它是派生所有異常類的類。在本書第10章已經(jīng)討論過它。

SecurityManager是一個子類可以實現(xiàn)的抽象類，它用于創(chuàng)建一個安全管理程序。一般不需要實現(xiàn)自己的安全管理程序，如果非要這樣做，需要查閱與你的Java開發(fā)系統(tǒng)一起得到的相關(guān)文檔。

Java 2在java.lang中新增加了一個接口：Comparable。實現(xiàn)Comparable的類的對象可以被排序。換句話說，實現(xiàn)Comparable的類包含了可以按某種有意義的方式進(jìn)行比較的對象。Comparable接口說明了一個方法，該方法用于確定Java 2調(diào)用一個類的實例的自然順序。該方法如下所示：
int compareTo(Object obj)
這個方法比較調(diào)用對象和obj。如果他們相等，就返回0。如果調(diào)用對象比obj小，則返回一個負(fù)值。否則返回一個正值。
該接口由前面已經(jīng)介紹的幾種類實現(xiàn)。特別是Byte，Character，Double，F(xiàn)loat，Long，Short，String以及Integer類定義了compareTo( )方法。另外，下一章將會介紹到，實現(xiàn)這個接口的對象可以被使用在不同的集合中。

在Java中定義了兩個java.lang的子包：java.lang.ref和java.lang.reflect。下面分別予以簡單介紹。

在前面學(xué)到過，在Java中，垃圾回收工具自動確定何時對一個對象，沒有引用存在。然后這個對象就被認(rèn)為是不再需要的，同時它所占的內(nèi)存也被釋放。在Java 2中新增加的java.lang.ref包中的類對垃圾回收處理提供更加靈活的控制。例如，假設(shè)你的程序創(chuàng)建了大量的在后面某個時間又想重新使用的對象，可以持續(xù)保持對這些對象的引用，但是這可能需要更多的內(nèi)存開銷。
作為替代，可以對這些對象定義“軟”引用。如果可以利用的內(nèi)存接近用完的話，一個可以“軟實現(xiàn)”的對象可以從垃圾回收工具中釋放。在那種情況下，垃圾回收工具將這個對象的“軟”引用設(shè)為空（null）。否則，垃圾回收工具保存對象以便以后使用。
程序設(shè)計人員具有確定是否一個“軟實現(xiàn)”的對象被釋放的能力。如果它被釋放了，可以重新創(chuàng)建它。如果沒有釋放，該對象對于后面的應(yīng)用將一直是可以利用的。也可以為對象創(chuàng)建“弱”（weak）和“假想”（phantom）引用，不過關(guān)于這些以及java.lang.ref包中其他特性的討論已經(jīng)超過了本書的范圍。

Reflection是一個程序分析自己的能力。包java.lang.reflect提供了獲得關(guān)于一個類的域、構(gòu)造函數(shù)、方法和修改符的能力。需要這些信息去創(chuàng)建可以使你利用Java Beans組件的軟件工具。這個工具使用映射動態(tài)地確定組件的特征。這個主題將在第25章中討論。
另外，包java.lang.reflect包括了一個可以動態(tài)創(chuàng)建和訪問數(shù)組的類。