JAVA中程序包的基本概念

程序包是类和接口的集合，包体现了Java面向对象编程特性中的 封装机制 。利用程序包可以把常用的类或功能相似的类放在一个程序包中。就像文件夹组织在一起，使硬盘更清晰、有条例一样，Java中的包把各种类组织在一起，使得程序功能清楚、结构分明。特别是，使用包有利于实现不同程序间类的复用。

包是一种松散的类的集合。一般不要求处于同一个包中的类有明确的相互关系（如包含、继承）但是由于同一个包中的类在默认情况下可以互相访问，所以为了方便编程和管理，通常把需要在一起工作的类放在同一个包中。

在Java中，包的概念同其他编程语言中函数库的概念是相同的。而且Java中已经含有大量的类库，可以直接用。

由于 Java 编译器为每个类生成一个字节码文件，且文件名与类名相同，因此同名的类有可能发生冲突。为了解决这一问题， Java 提供包来管理类名空间。

在 缺省 情况下，系统会为每一个.java源文件创建一个 无名包 ，该.java文件中定义的所有类都隶属于这个无名包，它们之间可以相互引用 非private 的域或方法。但由于这个无名包是没有名字的，所以它 不能被其他包所引用 。为了解决这个问题，可以创建有名字的包。

类、方法缺省访问权限就是可以在它所属的包中被访问。说明为 public 的类、方法才可以在其他包中被访问。如果类和方法被说明为 protected , 则其他包中只有它的子类才可以访问它们。

一 包的组成及命名

1 Java是一种网络编程语言，支持在internet上动态装载模块，因此，它特别注意避免名字空间的冲突。包的概念可以防止冲突的出现。

2 包是一组类和接口的集合，我们可以把一组相关的类组成一个包，同一个包内的类不能重名，但不同包内的类可以重名。 包实际上提供了一种命名机制和可见性限制机制。 每个类名和接口名都包含在某个包中。

3 包中的基本单元是类。

4 实际上，我们在程序中使用的每一个变量和方法都隐含地用全限定名进行访问，全限定名的组成方式为( 全限定名 )：

包名.类名.变量或方法名

包名由分离的字段组成，段与段之间用"."隔开。

二 包的声明(创建)

格式：

package 包名;

如：

package myPackage;

public class ClassA

{

......

}

class ClassB

{

......

}

class ClassC

{

....

}

说明：

1 package语句必须是源程序(.java)中非注释、非空行的第一条语句

2 用package声明包后，源程序中定义的所有类(.class)都将放在该包中

3 创建包就是在当前文件夹下创建一个子文件夹来存放该包中所有类的.class文件。“.”表示子文件夹

4 一个源程序中只能有一个类被声明为public，否则将出现编译错误

5 可在不同的源程序中使用相同的包名将不同源程序中的类放到相同的包中

6 如果在源程序中没有显式地声明一个包，那么系统就会将该文件中定义的所有类放在一个缺省的无名包中

三 包的使用

一般情况下，类只能引用与它在同一个包中的类。如果需要使用其它包中的 public 类，可以使用以下的方法:

1 使用包名、类名前缀

包名.类名 对象名

如

CardClasses.D200_Card my200 = new CardClasses.D200_Card();

2 引入

在程序的开始部分用import语句，将需要使用的类加载，以后在程序中使用这个类就不需要使用包名作前缀。

⑴ 格式1：

import 包名.类名；

引入一个类后，该类的使用方法就和在用户文件中定义的类一样。 如：

import CardClasses.D200_Card;

D200_Card my200 = new D200_Card();

⑵ 格式2

import 包名.*

引入包中的多个类，不必每个类都使用import语句， 如：

import Java.net.*;

"*" 表示该包中的所有类，但不能够包括包中子包中的类。 如：

import Java.awt.*

和

import Java.awt.event.*

不同的java系统对路径的用法有些差别，应注意系统的说明

说明 ： Java总是隐含地引入Java.lang包，即：如果只使用Java.lang包中的类，则不需要做任何额外的工作，但是如果想使用其他包内的类或是用户自己定义的包中的类，则必须在程序中显式地将该类引入

3 设置CLASSPATH

通过设置环境变量 CLASSPATH 指明所有 缺省的字节码文件 的路径。当一个程序找不到它所需要的类的字节码文件时，系统会自动到此环境变量中找。

JDK设置方法：

• 在AUTOEXEC.BAT中用：SET CLASSPATH =.;C:/JDK1.2;

• JDK中java.exe开关参数-classpath指定目录

JBuilder设置方法：在project->property对话框的“output”对话框中配置

3 Java的系统程序包

Java提供了大量的类，为方便使用分成若干个包。包有称为类库或API包。常用的Java包有：

（1）Java.lang 程序包

java 语言的核心部分就是 java.lang, 它定义了 Java 中的大多数基本的类。每个 java 类都隐含语句“ import java. lang.*; ”，由此可见，该包的重要性。

java.lang 包包含了 Object 类， java.lang.Object 类是 Java 中整个类层次结构的根结点，这个软件包还定义了基本数据类型的类： String 、 boolean 、 Character 、 Byte 、 Integer 、 Short 、 Long 、 Float 、 Double 。这些类支持数字类型的转换和字符串操作，在前面的章节里已经涉及了这些内容。下面是 java.lang 中的类 主要包括:

• 数据类型类 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long、Short

• 基本数据函数Math类

• 用于字符串处理的String类和StringBuffer类

• System、Object类

• 线程Thread和ThreadDeath类

. 字符串类

java.lang提供了两种字符串类： String 类和 StringBuffer 类。

<1> String 类

String 类提供几种字符串创建方法：

String s="Hello! "; 使用字符串常量自动创建 String 实例 。

String s= new String(String s)； 通过 String 对象或字符串常量传递给构造方法。

public String(char value[]); 整个字符数组赋给 String 构造方法。

public String(char value[],int offset,int count); 字符数组一部分赋给 String 构造方法， offset 为起始下标， count 为子数组长度。

public String(StringBuffer );

public String( byte ascii[ ], int hiByte );

public String( byte ascii[ ], int hiByte, int startIndex, int numChars );

String 类提供了丰富的字符串操作方法，其中重要的列举如下：

public int length(); 返回字符串的长度。

public char charAt(int index); 返回字符串位置 index 处的字符。

public boolean equals(Object o); 比较两个字符串对象，相等返回 true ，反之，返回 false 。

public int compareTo(String s); 比较两个字符串字典顺序，相等返回 0 ， s 大于当前串 返回一个负值， s 小于当前串返回一个正值。

public boolean regionMatches(int toffset,String Other,int ooffset,int len); 从当前字符串位置 toffset 开始寻找字符串 Other 、起始位置为 ooffset 、长度为 len 的子串。如发现匹配，返回 true ，否则，返回 false 。

public boolean startsWith(String prefix); 从当前字符串位起始位置 t 开始寻找字符串 prefix 。如发现匹配，返回 true ，否则，返回 false 。

public boolean endsWith(String suffix); 如当前字符串的结尾子串与 suffix 匹配，返回 true ，否则，返回 false 。

public int indexOf(String str); 在当前字符串中寻找与 str 匹配的子串，返回首次匹配的起始下标值，无匹配返回 -1 。

public String substring(int beginIndex,int endIndex); 在当前字符串中，求从起始位置 beginIndex 到结束位置 endIndex 的子串。

public String concat(String str); 将当前字符串与 str 连接，返回连接后的字符串。

public String toLowertCase(); 将当前字符串全转换为小写形式。

public String toUpperCase(); 将当前字符串全转换为大写形式。

public Char toCharArray(); 将当前字符串转换为字符数组。

public Static String valueOf(Object obj); 把 variable 转换为字符串。

例：

String s1 = new String("Hello World.");

char cArray[] = {'J', 'B', 'u', 'i', 'l', 'd', 'e', 'r'};
String s2 = new String(cArray); //s2 = "JBuilder"

int i = s1.length(); //i = 12
char c = s1.charAt(6); //c = 'W'
i = s1.indexOf('e'); //i = 1 (index of 'e' in "Hello World.")

String s3 = "abcdef".substring(2, 5); //s3 = "cde"
String s4 = s3.concat("f"); //s4 = "cdef"
String s5 = String.valueOf(i); //s5 = "1" (valueOf() is static)

<2> StringBuffer类

String类实现一种 不能改变的静态字符串 ，StringBuffer类实现一种 动态可变的字符串 。StringBuffer类可以用于创建String类，StringBuffer一旦建立，用toString()方法将其转换为String类。以后，就可以使用String类方法来操作。

StringBuffer 类提供三种创建方法：

public StringBuffer(); 创建一个空的 StringBuffer 类。

public StringBuffer(int length); 创建一个大小为 length 的 StringBuffer 类。

public StringBuffer(String str); 按str创建一个动态可变的 StringBuffer 类。

StringBuffer 类提供的方法主要用于把输入数据转换为 String 类。输入数据可来自键盘或其它数据源。类型可以是字符、字符数组、整数、浮点数和 Object 类型等。

下面介绍 StringBuffer 的主要方法：

public int length(); 返回缓冲区的字符数。

public int capacity(); 返回缓冲区剩余空间。

public synchronized StringBuffer append(type variable); 把 variable 转换为字符串，然后与当前字符串连接。

public synchronized StringBuffer append(Char(char ch)); 把字符 ch 连接到当前串尾。

public synchronized StringBuffer insert(int offset,type variable); 把 variable 转换为字符串，然后插入到当前串由 offset 指定的位置。

public synchronized StringBuffer insert(int offset,char ch); 把字符 ch 插入到当前串由 offset 指定的位置。

public synchronized String toString(); 把 StringBuffer 转换为字符串 String 。

例 6-1 利用 StringBuffer 类将键盘输入的数据建立一个字符串实例。

import java.io.*;

public class StringBufferToString {

public static void main(String[] args) {

char ch;

try {

System.out.println("Enter Width!");

int length =System.in.read();

StringBuffer strb=new StringBuffer(length);

while((ch= （ char ） System.in.read())!='/n')

{

strb.append(ch);

}

} catch (IOException e) { }

String str=strb.toString();

System.out.println(str);

}

}

（2）Java.util 程序包

包含一些低级的实用工具类。这些实用工具类主要有：Date类、Random类、Vector类。

<1>日期时间类

日期时间类是一个相对简单、但使用频繁的类，它提供了独立于具体系统的日期 / 时间的表示形式。利用日期时间类提供的方法，你可以获取当前日期和时间，创建日期和时间参数，计算某年或某月的天数，或者对当前日期进行比较。日期时间类的实例可通过如下几种方法予以创建：

public Date(): 这个构造方法将把当前日期和时间保存到所创建的 Date 实例中。

public Date(int year, int month, int date) : 这个构造方法将根据所给定的 year 、 month 、 date 参数创建一个 Date 实例。也就是说，利用此构造方法，所创建的 Date 实例表示的日期与年（ year ）、月 (month) 、日 (day) 参数表示的日期等同。

public Date(int year, int month, int date, int hours, int minutes):

这个构造方法类似于第 2 个方法，只不过这里还提供了具体的小时（ hours ）和分钟（ minutes ）参数，因而时间要更为精确。

public Date(int year, int month, int date, int hours,int minutes,int seconds): 这个构造方法类似于第 3 个方法，所不同的是这里还提供了具体的（ seconds ）参数，时间又精确了一些。

一旦创建了日期时间类的一个实例，就可以用它的方法来检索有关日期和时间的信息。下面列出了日期时间类的方法 :

public int getYear(); 返回当前日期中的年份。

public int getMonth(); 返回当前日期中的月份。

public int getDate(); 返回当前日期在月份中的日期值（ 1-31 ）。

public int getDay(); 确认某天是星期几。

public int getHours(); 返回当前日期中的小时数。

public int getMinutes(); 返回当前日期中的分钟数。

public int getSeconds(); 返回当前日期中的秒数。

public boolean befor(Date when); 对日期实例所代表的时间和 when 进行比较。若比 when 早，返回 true; 否则返回 false

public boolean after(Date when); 对日期实例所代表的时间和 when 进行比较。若比 when 晚，返回 true; 否则返回 false 。

public boolean equal(Object obj); 比较两个日期对象。若相等则返回 true ，否则返回 false 。

public String toString(); 返回当前日期参数的字符串表示形式。注意：不同主机系统的日期表示形式不尽相同。

日期时间类的使用非常简单，只需要创建一个类实例不带任何参数，就可以生成一个代表当前日期的类。如下所示：

Date today = new Date()

System.Out.println(today . ToString());

或者也可用一个更为简单的方式：

System.Out.println(today);

后一种方式中， println 将自动调用 toString 方法，因而无需显式调用。

<2> 向量类及其使用

A 向量和数组的异同

向量和数组存在许多相似之处，它们均可用以保存列表对象。数组只能保存固定大小的列表，它必须一次申请所有的存储单元。如果事先无法确定列表内究竟要存放多少对象， Java 的数组就无能为力了，向量数据类型却提供了一种与“动态数组”相近的概念。

尽管向量与数组相比有许多重要的优点，但它也有一些不足之处，其中之一是它不能直接存储简单数据类型。向量和数组分别适用于不同的场合。一般而言，下列场合更适合于使用向量：

（ 1 ）如果你需要频繁进行对象的插入和删除工作，或者因为需要处理的对象数目不定。

（ 2 ）列表成员全部都是对象，或者可以用对象方便地表示，

（ 3 ）需要很快确定列表内是否存在某一特定对象，并且希望很快了解到对象的存放位置。

这主要是因为向量作为一个对象，提供了比数组更多的方法。另一方面，由于向量只能存储对象，如果需要把简单数据类型保存到向量，必须使用 Java 的数据类型类，因此，有些场合下使用数组反而比使用向量要方便一些。下列场合适合于使用数组：

（ 1 ）所需处理的对象数目固定，或大致可以确定，尽管有些对象经常发生变化，

（ 2 ）所需处理的是简单数据类型。

B 向量类的构造方法、属性和方法

要使用向量，首先必须创建一个 Vector 类实例，这通过向量的构造方法创建。向量类共有 3 种形式的构造方法，如下所示：

Vector(int capacity, int capacityIncrement); 用指定的向量容量及其增量参数，创建一个空向量。

Vector(int capacity); 用给定的向量容量参数，创建一空向量。

Vector(); 创建一空向量。

这里需要对所谓的“向量容量”和“容量增量”参数作一说明。为优化存储管理， Java 的每个向量均可以使用一个“向量容量”参数和一个“容量增量”参数。向量容量通常是一个大于向量实际元素个数的整数，容量增量则规定了每当向量元素个数达到极限时，需一次性扩充的向量容量大小。也就是说，当新增向量元素时，如果向量内元素个数已经达到了向量的极限大小，向量并不是申请一个空间，而是多个空间，数目由容量增量参数确定。如果容量增量参数为 0 ，则每次向量容量都将增加一倍大小。设置这两个参数可增加向量类的使用效率。你也可以忽略这两个参数，这时 Java 将自动为你维护向量的使用，包括必要时向量的增容等。除构造方法外，向量类还提供了 3 个属性变量，如下所示：

protected int capacityIncrement; 当向量大小不足时,所用的增量大小

protected int elementCount; 向量的元素个数

protected Object elementData[ ]; 向量成员数据所用的缓冲

一旦创建了向量类的实例，就可以用它的方法来执行插入、删除及查找对象等操作。向量类提供了极为丰富的方法，下面是其中一些主要的方法：

public final synchronized void copyInto(Object anArray[]); 把向量元素拷贝到指定数组

public final synchronized void trimToSize(): 把向量容量调整到正好等于向量元素个数以压缩向量的存储空间。这样，随后的插入操作将导致重新申请内存空间。

public final synchronized void setSize(int newSize); 设置向量 大小。

如果向量被缩小， 多余的元素将被截断，如果被放大，新增的向 量元素将置为 null 。

public final int capacity() ; 返回向量容量。

public final int size() ; 返回向量的元素个数，注意和 capacity( ) 之间的区别。

public final boolean isEmpty() ; 若向量不包括任何元素，返回 true ，否则返回 false 。

public final synchronized Enumeration elements() ， 返回向量元素

所对应的枚举值，以便随后用 Enumeration( ) 方法获取该向量元素。

public final boolean contains (Object elem) ， 若向量中包括了对

象 elem ，返回 true ，否则返回 false 。

public final int indexOf (Object elem) ， 返回向量下标，若对象不 存在，返回 -1 。

public final synchronized int indexOf (Object elem,int index) ， 从指定位置（ index ）开始搜索向量，返回对象所对应的向量下标值。若未找到对象，返回 -1 。

public final int lastIndexOf (Object elem) ， 从向量末尾向前搜索向量，返回对象的下标 值。

public final synchronized int lastIndexOf (Object elem,int index) ， 从指定位置开始向前搜索向量，返回给定对象的下标值。

public final synchronized Object elementAt (int index) ， 返回指定下标处的对象。若下标值非法，抛出 ArrayIndexOutOfBoundsException 异常。

public final synchronized Object firstElement () ， 返回向量的第一个元素。若向量为空，抛出 NoSuchElementException 异常。

public final synchronized Object lastElement () ， 返回向量的最后一个元素。若向量为空，抛出 NoSuchElementException 异常。

public final synchronized void setElementAt (Object obj, int index) ， 把给定对象存放到给定下标处，该下标处的原有对象丢失。若下标值非法，抛出 异常。

public final synchronized void removeElementAt (int index) ， 删除给定下标处的向量元 素，后面元素前移一个位置。若下标值非法，抛出 ArrayIndexOutOfBoundsException 异常。

public final synchronized void insertElementAt (Object obj,int index) ， 把给定对象插入到指定下标处。该下标之后的元素后移一个位置。若下标值非法，抛出 异常。

public final synchronized void addElement (Object obj) ， 把给定对象增加到向量末尾。

public final synchronized boolean removeElement (Object obj) ， 从向量中删除指定对象。若给定对象在向量中保存多次，则只删除其第一个实例。若向量中没有这个对象，返回 false 。

public final synchronized void removeAllElements() ， 删除向量中的所有对象。这时向量将变成空向量。

public final synchronized String toString() ， 把向量转换成字符串。请注意：这个方法实际上覆盖了 Object 类中的 toString() 方法。

<3> 建立向量实例

和数组一样，向量的内存空间通过 new 操作符实现。一个向量在被创建后，将自行在系统内部维护一个专用数组，并在必要时对数组大小进行动态调整。比方说，如果插入一个向量元素时，向量的空间需求超过了这个内部数组的大小，向量将向系统申请一些新的内存空间。

Vector theVector = new Vector();

<4> 向量维护

创建向量实例之后，就可以把对象插入到向量。这时将用到 addElement( ) 方法。如下面的程序：

Vector theVector = new Vector();

for( int i = 0; i<10; i++ )

{

Integer newInteger = new Integer(i);

theVector. addElement( newInteger );

}

addElement( ) 方法把对象插入到向量末尾。

向量可用以保存任何类型的对象，同一个向量实例甚至还可以保存多种不同类型的对象。下面我们给出另外一个例子，这个例子中，给向量交错插入一些浮点数和字符串。

Vector theVector = new Vector( );

String testString;

testString = ″ pai ″ ;

theVector.addElement( testString );

Float testFloat = new Float(3.14 );

theVector.addElement( testFloat );

testString = ″ Faill ″;

theVector.addElement(testString);

Float testFloat = new Float( 59 );

theVector.addElement( testFloat );

执行这段代码，向量将包括如下内容： { ″ pai ″ , 3.14, ″ Faill ″ , 59} 。

增加向量元素的另一方式是通过 insertElementAt( ) 方法。该方法把对象插入到向量的给定位置。

另一经常用到的维护操作是从向量中删除一个对象。这时有三种方法可用： removeElement(), removeElementAt(), removeAllElement() 。三个方法分别用于不同场合。 removeElement() 删除指定对象， removeElementAt() 删除给定位置处的对象， removeAllElement( ) 则删除所有向量成员。对于前两个方法需要注意的是删除之后整个向量的变化：删除一个对象后，后面的对象将前移一个位置。对于前面例子中介绍的向量，下面语句将删除其中的 3.14 和 59 ，而不是 3.14 和“pai”。

Float deleteFloat = new Float(3.14);

theVector.removeElement(deleteFloat);

theVector.removeElementAt(2);

<5> 对象查找

与数组相比，向量的优势之一在于它提供了丰富的方法，使我们能够方便快捷地从向量中查找对象。对象查找中最常遇见的可能是给定一个下标值，希望由此确定该下标处的对象。这时可使用 elementAt( ) 方法。如下面这行程序：

Object tempObj = theVector.elementAt(0);

这行程序返回一对象引用，该引用指向向量成员“pai”。

有时我们可能需要确定向量中是否包括了某一确定的对象，如果使用数组来确定不太方便。使用向量就方便得多，因为它有一个contains()方法，可直接实现此项功能。我们再来看这个方法：

public final boolean contains(Object elem);

这个方法返回一布尔值。若向量包含了对象elem，返回true，否则返回false。

我们经常用下标来访问数组元素，这是使用数组的最有效方法。向量成员也可用下标进行访问，其中最简单的方法是使用刚刚介绍的elementAt()方法，它可以返回给定下标处的对象。除这个方法外，其他两个用下标操作的方法是indexOf()和lastIndexOf()。下面我们再来看一下这两个方法：

public final synchronized int indexOf( Object elem, int start_index ) ;

public final synchronized int lastIndexOf( Object elem, int start_index ) ;

这两个方法均从给定下标开始搜索向量来确定向量中是否包含了指定的对象。如果是，则返回该对象的下标值，否则返回 -1 。差别在于 indexOf() 是从前往后搜索，而 lastIndexOf() 是从后向前搜索。

（3）Java.io 程序包

是Java语言的输入输出类库，Java语言的文件操作都是由该类库中的输入输出类来实现的，此外该类库提供了一些与其他外部设备交换信息的类。该包除了包含标准输入、输出类外，还有缓存流、过滤流等。

（4）Java.net 程序包

含有访问网上资源的URL类，用于通信的Socket类和网络协议子类库等。

（5）Java.awt 程序包

提供了创建图形用户界面的全部工具。如：窗口、对话框等。

（6）Java.applet 程序包

是所有Java小程序的基础类库。只包含一个applet类，所有小程序都从该类派生。

（7）Java.security 程序包

包括java.security.acl和java.security.interface子类库，利用这些类可对Java程序加密，设定相应的安全权限等。