7．1 Applet类
Applet是种特殊的Java程序，经过编译后可被嵌入到HTML文件中，并由Web浏览器内置的Java解释器执行。所有Applet都继承自同一个类java.appelt.Applet，这个类是Java语言的基础类，有关Applet的所有特性都被定义在这个类中。
7．1．1 Applet的特点
Applet
Application
运行环境
在浏览器中运行，或用appletviewer命令
单独运行
入口
从init( )方法开始
从main( )开始
来源
从网上来
放在本地
出于安全考虑，Java设计者对Applet做了一些必要的限制。P129
有关Applet的安全机制通常被设置在浏览器中。大多数浏览器都会禁止Applet执行下列操作：
（1）在运行时调用其他程序
（2）文件读写操作
（3）装载动态连接库和调用任何本地方法
（4）试图打开一个socket进行网络通信，但是所连接的主机并不是提供Applet的主机。
另一方面，java.applet包提供了Application所不具备的一些API接口。
7．1．2 Applet和HTML的关系
HTML可以没有Applet，但很多重要功能将无法实现，而Applet有赖于HTML才能运行，二者共同为Internet这个虚拟世界增添光彩。
7．1．3 Applet的生命周期与主要活动
例P131 import java.applet.Applet;
import java.awt.Graphics;
public class SC extends Applet{
StringBuffer buffer=new StringBuffer();
public void init( ) {addWords("初始化……");} //与位置顺序无关
public void start( ) {addWords("开始……");} //与位置顺序无关
public void stop( ) {addWords("停止……");} //关闭窗口后执行
public void destroy( ) {addWords("清除……");} //关闭窗口后执行
void addWords(String s)
{System.out.println(s); //在DOS界面显示
buffer.append(s);
repaint();} //自动调用paint方法
public void paint(Graphics g) {
g.drawString(buffer.toString(),5,15);}} //在图形界面显示内容
1．初始化（init）
当Applet首次加载（或重新加载）时，要进行初始化操作。初始化可进行建立添加到程序中的对象、设置对象初始状态、为成员变量赋初值、加载图像或字体等操作，这些可通过覆盖init方法来实现。
当然程序也可以没有init方法。
2．开始运行（start）
Applet在初始化完成后即被调用，如果运行已被停止，还可以再次启动。尽管在一个生命周期中，Applet可以多次开始运行，但初始化只能进行一次。
start方法可以在下列情况下自动执行多次：
* 浏览器载入小应用程序并执行init( )之后；
* 离开上述Web页之后，又重新回来时；(用back后退，forword前进按钮)
* 浏览器的窗口最小化后又恢复时。
在start方法中可以开始运行Applet的功能，也可以启动一个或多个线程来完成任务。一般情况下，如果覆盖了start方法就要覆盖stop方法
3．停止运行（stop）
stop方法可以在下列情况下自动执行多次：
* 离开小应用程序所在Web页时；(用back后退，forword前进按钮)
* 刷新该页面时；(重新reload该页面时)
* 关闭该Web页时；
* 最小化浏览器时。
4．清除（destory）
关闭该Web页时执行一次
5．画出（显示）（paint）
如果需要Applet显示一些内容的话,必须覆盖paint方法进行写屏。不论所显示的内容是文字、线条、背景色，还是一幅图形，都必须在paint方法中完成。
paint方法也是小应用程序执行时自动调用的方法，当下列情况下会发生paint方法的自动调用：
* 第一次加载含有小应用程序的Web时；
* Web页被覆盖后又重新显示时；
* 浏览器显示区域被缩小/放大时。
首先引用：import java.awt.Graphics
方法： public void paint(Graphics g){……}
6．刷新（repaint）
repaint方法：是小应用程序从java.awt.Component中继承来的方法，它首先激活update( )方法（也是在java.awt.Component中定义），清除显示区域的所有显示内容，再调用paint( )方法重绘显示区域。
7．1．4 HTML和Applet的参数传递
* 在网页中，必须使用<param>的标识来指定参数的名称和参数的内容值。格式：<param name=参数名 value=参数值>
* 在Applet程序中必须使用getParameter( )方法来取得参数的内容。格式：public String getParameter(“参数名”)
例：P133
import java.applet.Applet;
import java.awt.Graphics;
public class SC extends Applet{
String string=null;
int x,y;
public void init(){
string=getParameter("message");
x=Integer.parseInt(getParameter("xPos"));//写成(int)”30”错
y=Integer.parseInt(getParameter("yPos"));}//可以不用Integer.parseInt
public void paint(Graphics s){
if (string!=null)
s.drawString(string,x,y);
s.drawString("参数X为： "+x,30,60);
s.drawString("参数Y为： "+y,30,90);}}
7．1．5 Applet标签属性
参见P135
7．2 字符串类
在Java中字符串被定义为一个类，无论是字符串常量还是变量，都必须先生成String类的实例对象然后才能使用。
包java.lang中封装了两个字符串类String（java.lang.String）和StringBuffer，分别用于处理不变字符串和可变字符串。这两个类都被声明为final。因此不能被继承
7．2．1 字符串与字符串类
用双引号括起来的字符串是字符串常量，又称为无名字符串对象，由Java自动创建。
例：P137
说明：s.charAt(i) //返回字符串的第i个字符
buffer.append(char a) // 将字符参数添加到对象buffer尾部
buffer.toString( ) //将StringBuffer类型转换成String类型再返回。
7．2．2 字符串类的构造方法
例P139
import java.io.*;
import java.applet.Applet;
import java.awt.Graphics;
public class SC extends Applet{
byte b[]={'A',' ','b','y','t',' ','a','r','r','a','y'};
char c[]={'A',' ','c','h','a','r',' ','r','r','a','y'};
String s1,s2,s3,s4,s5,s6,s7,s8,s9;
StringBuffer b1,b2,b3;
public void init(){
b1=new StringBuffer();
b2=new StringBuffer(10);
b3=new StringBuffer("A string buffer");//写成b3="A string buffer"错
s1=new String();
s2=new String("A string"); // 写成s2="A string" 对
s3=new String(b3); // 写成s3=b3;错
s4=new String(b);
s5=new String(b,2,4);
try{
s6=new String(b,2,10,"GBK");
s7=new String(b,"GBK");
}catch (UnsupportedEncodingException e) {}
s8=new String(c);
s9=new String(c,2,4);}
public void paint(Graphics g)
{ g.drawString("s1="+s1,20,20);
g.drawString("s2="+s2,20,35);
g.drawString("s3="+s3,20,50);
g.drawString("s4="+s4,20,65);
g.drawString("s5="+s5,20,80);
g.drawString("s6="+s6,20,95);
g.drawString("s7="+s7,150,20);
g.drawString("s8="+s8,150,35);
g.drawString("s9="+s9,150,50);
g.drawString("b1="+b1.toString(),150,65);
g.drawString("b2="+b2.toString(),150,80);
g.drawString("b3="+b3.toString(),150,95); } }
7．2．3 String类的应用
1．求字符串长度（length）
格式：public int length( )
例：System.out.println("管理学院".length( )); // 4
System.out.println("GLXY".length( )); // 4 "GLXY".length( )则错
char c[]={'G','L','X','Y'};
System.out.println(c.length); // 4 ，c.length( )则错
2．字符串连接
格式：public String concat(String str )
例： String str="hello";
str=str.concat("Hi"); // 与 str+”Hi” 等价
System.out.println(str); // helloHi
别：“+”还可以把一个非字符串的数值连接至字符串尾部，编译器将自动把非字符串转换为字符串再进行连接。
3．字符串截取
格式：public char charAt(int index)
功能：返回第index个字符
格式：public String substring(int start [int end])
功能：从第start开始截取字符串,end代表结束位置
例： String s1="安徽城管学院",s2=s1;
System.out.println(s1.charAt(2)); // 城
s1=s1.substring(2);
System.out.println(s1); // 城管学院
System.out.println(s2.substring(2,4)); // 城管
4．字符串比较
格式： boolean equals(Object object)
boolean equalsIgnoreCase(String str) // 忽略大小写
int compareTo(Object object)
int compareTo(String str)
int compareToIgnoreCase(String str) // 忽略大小写
例： String s1="ABCD",s2="ABC",s3="abc";
System.out.println(s1.equals(s2)); // false
System.out.println(s2.equals(s3)); // false
System.out.println(s2.equalsIgnoreCase(s3)); // true
System.out.println("A".compareTo("B")); // -1 “A”比“B”小
System.out.println("B".compareTo("A")); // 1“B”比“A”大
System.out.println("ABC".compareTo("abc")); //-32 小，是负数
System.out.println("ABC".compareToIgnoreCase("abc"));//0 相同
说明：运算符“==”比较两个对象是否引用同一个实例，而equals( )则比较两个字符串中对应的每个字符值是否相同。
例： Sting a=”ABC” ,B=”ABC” ,C=”abc” ,D=”AB”
A==B // true
A==C // false
A==D // false
5．拷贝到字符串
格式1：static String copyValueOf(char[] data)
格式2：static String copyValueOf(char[] data ,int offset ,int count)
功能：将字符数组的内容拷贝到字符串中
例：char c[]={'A','B','C','D','E'};
String s1="XYZ",s2=s1;
s1=s1.copyValueOf(c); // s1值是“ABCDE”
s2=s2.copyValueOf(c,1,3); // s2值是“BCD”
s3=substring(c,3); // 错
s3=c; // 错
Sting s1= new String(c)
Sting s1= new String(c,2,3)
6．字符串大小写转换
例：String s1="Abc",s2,s3;
s2=s1.toUpperCase( ); // s2值是“ABC”
s3=s1.toLowerCase( ); // s3值是“abc”
7．字符串检索
格式：int indexOf(char ch) // 首次出现位置
int indexOf(String str)
int lastIndexOf(char ch) // 最后出现的位置
int lastIndexOf(String str)
功能：在一个字符串中检索指定字符或子串，返回所在位置的整数，若找不到则返回为-1。
例：String s1="ABABab";
System.out.println(s1.indexOf('a')); // 4
System.out.println(s1.indexOf("AB")); // 0
System.out.println(s1.lastIndexOf('A')); // 2
8．字符串转换为数组
字符串可以转换为字节数组或字符数组。
格式：byte []getBytes( ) //按系统默认字符集编码转换为字节数组
byte []getBytes(String enc ) //基中enc为字符集编码
char []toCharArray( ) // 转换为字符数组
例： byte b[]; char c[];
String s="计算机";
b=s.getBytes();
c=s.toCharArray();
System.out.println(b); // [B@17943a4
System.out.println(c); // 计算机
9．转换为字符串
String类提供了一组valueOf方法用来将其他数据类型转换成字符串，其参数可以是任何数据类型（byte类型除外），它们都是静态的，也就是说不必创建实例化对象即可直接调用这些方法。
格式： String.valueOf（数据类型）
例：char c[]={'A','B','C','D','E'};
String s="Help",s1,s2,s3;
s1=String.valueOf(c,1,3); // “BCD”
s2=String.valueOf(true); // “true”
s3=String.valueOf(95.5); // “95.5”
同时，类Integer,Double,Float和Long中也提供了方法valueOf( )把一个字符串转化为对应的数字类型。
例：String s="35";
Integer i=Integer.valueOf(s); // 35
Double d=Double.valueOf(s); // 35.0
10．字符串替换（补充）
格式：public String replace(char oldChar ,char newChar)
功能：把字符串中出现的所有指定字符转换成新字符
例：String s1="ABACAD",s2;
s2=s1.replace('A','Z'); // “ZBZCZD”
7．2．4 StringBuffer类的应用
StringBuffer表示可变字符串，可以在其中插入字符或在末尾添加字符。如果超出已分配的缓冲区，系统会自动地为它分配额外空间。
1．append方法
格式：public synchronized StringBuffer append(数据)
功能：在已有字符串末尾添加一个字符串str
例：P144 char data[]={'a','b','c','d','e'};
StringBuffer buffer=new StringBuffer();
buffer.append(100);
buffer.append('*');
buffer.append(2.50F);
buffer.append(" is equal to ");
buffer.append(250.000);
buffer.append(' ');
buffer.append(data);
buffer.append(' ');
buffer.append(data,2,3);
System.out.print(buffer);
运行结果：100*2.5 is equal to 250.0 abcde cde
String s=”ab”;
StringBuffer b=”XYZ”; //错
StringBuffer b=new StringBuffer(“XYZ”);
s=b ; // 错
s=b.toSting() // “XYZ”
b=s; //错
int i=b.length();
b=b.replace(0,s); //将字符串s值给bs
2．insert方法
格式：public synchronized StringBuffer insert(插入位置，数据)
功能：在插入位置处插入数据，总长度增加
例P144 char data[]={'a','b','c','d','e'};
StringBuffer buffer=new StringBuffer();
buffer.insert(0,100);
buffer.insert(0,2.5F);
buffer.insert(3,'*');
buffer.insert(0,250.0);
buffer.insert(5," is equal to ");
System.out.print(buffer);
运行结果：250.0 is equal to 2.5*100
3．其他方法
public StringBuffer delete(int start ,int end) //删除子串，不包括end位字符
public StringBuffer deleteCharAt(int index) //删除index位置上的字符
public StringBuffer replace(int start,int end,String str) //替换子串，字符串长度可增长或减短
StringBuffer reverse( ) //翻转字符串
例P144：StringBuffer buffer=new StringBuffer("安徽城市管理学院");
buffer=buffer.delete(0,2); // 城市管理学院
buffer=buffer.replace(2,4,"职业"); // 城市职业学院
buffer=buffer.reverse(); // 院学业职市城
buffer=buffer.deleteCharAt(1); // 院业职市城
7．3 输入输出流类
7．3．1 数据流概念
1．数据流
数据流是指一组有顺序的、有起点和终点的字节集合，实际上是一个数据序列，它可以看成是数据的导管。输入就是读取数据流，输出则是写入数据流。处理过程：打开流、读取或写入流、关闭流。
Java程序不直接操纵I/O设备，而是在程序和设备之间加入了一个中间介质，这就是数据流，采用数据流的目的就是使程序的输入输出操作独立于具体设备，程序一旦建立了数据流，就可以不用理会起点或终点是何种设备。
Java提供许多数据流的类和方法，封装在java.io包中，编程时用它处理输入输出，只要在程序前面加上语句：import java.io.*： ，即可使用其中的各种I/O方法。
2．输入流与输出流
建立数据流实际上就是建立数据传输通道，将起点和终点连接起来。
输入流可从键盘或文件获得数据，输出流可向显示器屏幕、打印机或文件中传输数据。Java中最基本的流类有2个：基本输入流InputStream，基本输出流OutputStream
3．缓冲流
对数据流的每次操作是以字节为单位进行的，为了提高数据传输效率，通常使用缓冲流（buffered stream），即为一个流配有一个缓冲区（buffer），一个缓冲区就是专门用于传送数据的一块内存。
当向一个缓冲流写入数据时，系统将数据发送到缓冲区，而不是直接发送外部设备，缓冲区自动记录数据，当缓冲区满时，系统将数据全部发送到相应设备。
当从一个缓冲流读取数据时，系统实际是从缓冲区中读取数据。当缓冲区空时，系统将从相应设备自动读取尽可能多的数据充满缓冲区。
7．3．2 Java的标准数据流
标准输入指键盘输入；标准输出指输出到显示器。
标准输入输出功能是通过Java中的系统类System实现的。它在java.lang包中，是一个最终类，有3个公共的静态的成员变量：in , out , err可在程序中直接调用它们。
1．标准输入System.in
System.in作为InputStream类的对象实现标准输入，可以调用它的read方法来读取键盘数据。read方法有3种格式：
public int read( ) // 读入一个字节，作为整数返回
public int read(byte b[]) throws IOException
public int read(byte b[],int off,int len) //?从输入流中读取长度为len的数据，写入字节数组b中从索引off开始绵位置 （不作要求）
如果输入流结束，返回-1。发生I/O错时，会抛出IOException异常。
例：byte a[]=new byte[10]; byte b[]=new byte[10];
System.in.read(a); System.in.read(b,1,2); //若输入abcdef回车abcdef回车
System.out.println((char)a[2]); // c
System.out.println((char)b[0]); // 空
System.out.println((char)b[1]); // a
System.out.println((char)b[2]); // b
System.out.println((char)b[3]); // 空
2．标准输出System.out
格式：void write(int b);
功能：将指定字节b写入输出流，如果b的值大于255，则只输出它的低位字节所表示的值
格式：void write(byte b[]);
功能：把字节数组中的b.length个字节写入输出流
格式：void write(byte b[],int off,int len);
功能：把字节数组b中从索引off开始的len个字节写入输出流
可以调用它的print（不换行输出） , println（换行输出） , 或write方法来输出各种类型的数据。它们不产生输出异常。
write方法用来输出字节数组，在输出时不换行，在输出单个字节时，并不能立即显示出来，必须调用flush方法或close方法强制回显。
例：byte a[]=new byte[15];
System.in.read(a); // 输入abced
System.out.println(a); // 输出[B@480457 乱码
System.out.write(a); // 输出abced
System.out.write(a,1,2); // 输出bc
System.out.println(a[1]); // 98
System.out.write(a[1]); // b
System.out.println(); //强制回显示，也可用System.out.close() ; System.out.flush( )方法;
注：（1）从键盘输入字符串后，保存在缓冲区中的元素还要上两个元素‘\r’（回车键），元素值为ASCII码值。
（2）read方法返回值为int，为实际读入的字节个数。
（3）read会产生输入异常，要么放在try…catch块中执行，要么令mai方法将异常抛出（throws IOException）
long skip(long n) ; (补充)
输入流的当前读取位置向前移动n字节，并返回实际跳过的字节数
例：P48 System.in.skip(2);
7．3．3 java.io包中的数据流类及文件类
java.io包封装了大量的数据流类，支持基于字节流（byte stream）的数据流（这种流对于16位的Unicode码表示的字符流的处理很不方便）和基于字符流（character stream）（以16位Unicode码形式表示）的数据流。
表7.1~7.4 见P148
为了全面管理文件系统，Java还提供了两个文件类：一般文件File和随机文件类RandomAccessFile。前者提供操作系统目录管理的功能，允许用户访问文件属性和路径等。可以顺序访问文件。后者用于对文件以随机操作方式读写数据。
7．3．4 数据流的应用
例：P150 import java.io.* ;
public class SC{
public static void main(String arg[]) throws IOException{
FileReader in=new FileReader("P3.java"); //建立文件输入流，打开P3.java
BufferedReader bin=new BufferedReader(in); //建立缓冲输入流
FileWriter out=new FileWriter("Hello.txt",true);// 建立文件输出流，true表示将数据保存在文件尾部
String str;
while((str=bin.readLine())!=null){ //读入一行
System.out.println(str);
out.write(str+"\n") ; }// 写入"Hello.txt"
in.close();
out.close(); }}
表7.9 字符文件流类的构造 P151
名 称
说 明
FileReader(String name)
name代表文件名，可包含路径
FileReader(File file)
file是文件类对象
FileReader(FileDescriptor fdobj)
fdobj代表一个打开的I/O设备
FileWriter(File file)
file是文件类对象
FileWriter(String name,booleam a)
a取真则将数据添加在文件尾部
如果要选择地读写文件，例如读写一行或几行，随机文件RandomAccessFile可实现这种操作，它能从文件的不同位置读写不同长度的数据。
例P151 import java.io.* ;
public class SC{
public static void main(String arg[]) {
String str[]={"First line\n","Second line\n","last line\n"};
try{
RandomAccessFile rf=new RandomAccessFile("hello.txt","rw");
System.out.println("\n文件的指针位置为："+rf.getFilePointer());
System.out.println("文件的长度为："+rf.length());
rf.seek(rf.length());
System.out.println("文件指针现在的位置为："+rf.getFilePointer());
for (int i=0;i<3;i++)
rf.writeBytes(str[i]);// 字符串转换为字节串添加到文件末尾
rf.seek(0);
System.out.println("\n文件现在内容：");
String s;
while((s=rf.readLine())!=null)
System.out.println(s);
rf.close(); }
catch(FileNotFoundException fnoe){}
catch(IOException ioe){} }}
7．3．5 文件（补充）
1．创建文件
格式：File pathname=new File(args[0])
功能：以路径文件名来建立文件对象
格式：File f=new File(pathname.getPath , fileNames[i])
功能：以路径+文件名创建文件对象
2．File类提供的方法
（1）对文件名操作提供方法
public String getName( ) //得到一个不包含路径的文件名
public String getParent( ) //得到文件上一级的目录名
public File getParenFile( ) //得到文件对象父路径名
public String getPath( ) //返回文件路径名字符串，即路径文件名
public String[] list( ) //返回一个字符串数组，为该文件所在目录下的所有文件名列表，如：String fileName[]=pathName.list( )
public String getCanonicalPath( ) throws IOException //返回该文件对象与系统平台相关的绝对路径,与getAbsoluttPath( )同。
public String renameTo(File newName ) //返回重命名后的文件名
public String getAbsolutePath( ) //返回文件绝对路径名
（2）测试文件属性操作提供方法
public boolean isDirectory( ) //测定是否是目录，如果File代表一个目录，则返回true，否则返回false
public boolean isFile( ) //测定是否是文件
public boolean isAbsolute( ) //测定是否是绝对文件
public boolean exists( ) //测定文件是否存在
public boolean canRead( ) //测定是否是可读文件
public boolean canWrite( ) //测定是否是可写文件
（2）测试文件属性操作提供方法
public boolean delete( ) // 删除当前文件并释放资源
public void deleteOnExit( ) // 执行完后，删除文件
public long length( ) // 返回文件字节长度
public long lastModified( ) //返回文件最后修改时间
（4）为目录操作提供的方法
public boolean mkdir( ) //创建目录
public boolean mkdir( ) //创建包含父目录的目录
public String[] list( ) // 返回当前目录下的文件
public String[] list(FilenameFilter filter) // 返回当前目录下经过滤后的文件
public static File[] listRoots( ) // 返回根目录结构
（5）其他方法
public int hashCode( ) // 返回文件名的哈希码
public boolean setLastModified(long time) //设置文件最后修改时间
public boolean setReadOnly( ) //设置文件只读属性
例：功能：显示指定目录下的子目录，如执行java SC c:\
import java.io.* ;
public class SC{
public static void main(String args[]) {
if(args.length==0) args=new String[]{".."} ;//命令行缺省值
try {
File pathName=new File(args[0]); //取命令行参数
String fileNames[]=pathName.list(); //取pathName下所有文件名列表
for (int i=0;i<fileNames.length;i++)
{ File f=new File(pathName.getPath(),fileNames[i]);//创建路径和文件名创建文件对象f
if(f.isDirectory()) //判断是否是目录
{System.out.println(f.getCanonicalPath()); //输出绝对路径
main(new String[] {f.getPath()}) ; //取下一级子目录
}}}
catch(IOException e)
{ e.printStackTrace( ); }}}
7．4 其他常用类
数学函数类Math，提供了基本数学运算；日期类Date，Calendar和DateFormat，提供了日期和时间操作；随机数类Random提供了随机数生成器；向量类Vector提供了类似于可变长数组的操作。
7．4．1 数学函数类Math
Math是一个最终类，可直接在程序中加Math前缀调用，其成员变量和常用成员方法如下：
static double E // 数学常量e
static double PI // 圆周率Л
static double sin(double a) // 正弦函数，参数为弧度
static double cos(double a) // 余弦函数，参数为弧度
static double tan(double a) // 正切函数，参数为弧度
static double toDegrees(double angrad) // 弧度转换为角度
static double toRadians(double angdeg) // 角度转换为弧度
static double exp(double a) // 常数e的a次幂
static double log(double a) // 自然对数
static double sqrt(double a) // 平方根
static double pow(double a,double b) // a的b次方
static double round(double a) // 四舍五入
static double round(float a) // 四舍五入
static double random( ) // 产生大于等于0.0小于1.0的随机数
static double abs(double a) // 绝对值，参数可以是float,int,long
static double max(double a,double b) //最大值，参数可以是float,int,long
static double min(double a,double b) //最小值，参数可以是float,int,long
例：System.out.println(Math.PI); // 3.141592653589793
System.out.println(Math.sqrt(9)); // 3.0
System.out.println(Math.random()); //0.061703095869295566
System.out.println(Math.round(7.5)); // 8
System.out.println(Math.round(7.4)); // 7
System.out.println(Math.max(9,4)); // 9 Math.max(9,4,10)则错
7．4．2 日期类Math
Java提供了3个日期类：
Date ：用于创建日期对象并获得日期
Calendar ：可获取和设置日期
DateFormat：用于创建日期格式化器，由格式化器将日期转换为各种日期格式串输出
Date和Calendar类在java.util包中，DateFormat类在java.text包中
Java语言规定的基准日期为1970.1.1 00:00:00格林威治（GMT）标准时
例P154 import java.text.*;
import java.util.*;
import java.awt.* ;
import java.applet.*;
public class SC extends Applet {
public void paint(Graphics g){
Date today;
Calendar now;
DateFormat f1,f2;
String s1,s2;
today=new Date(); //获取系统当前日期
g.drawString("字符串格式："+today.toString(),20,20);
f1=DateFormat.getInstance(); //以默认格式生成格式化器
s1=f1.format(today); //将日期转换为字符串
g.drawString("系统格式："+s1,20,40);
//生成长格式的中国日期格式化器
f1=DateFormat.getDateInstance(DateFormat.LONG,Locale.CHINA);
//生成长格式的中国时间格式化器
f2=DateFormat.getTimeInstance(DateFormat.LONG,Locale.CHINA);
s1=f1.format(today); //将日期转换为日期字符串
s2=f2.format(today); //将日期转换为时间字符串
g.drawString("中国格式："+s1+" "+s2,20,60);
now=Calendar.getInstance() ;//获取系统时间
s1=now.get(now.HOUR)+"时"+now.get(now.MINUTE)+"分"+now.get(now.SECOND)+"秒";
g.drawString("调整前时间："+s1,20,80);
now.set(2001,2,15,9,9,9);
today=now.getTime();
g.drawString("调整后时间"+today.toString(),20,100); }}
7．4．3 随机数类Random
为了使用Java程序有良好的可移植性，应尽可能使用Random类来生成随机数，而不用Math.random( )。
Random有两个构造方法：Random( )(使用系统时间为种子数)，Random(long seed)。构造方法只是创建了随机数生成器，必须调用生成器的方法才能产生随机数。Random具有nextBoolean，nextInt等方法。
Random包含在java.util包中。
例：Random r=new Random( );
int i1=r.nextInt( );
int i2=r.nextInt(20); // 产生大于等于0小于20的随机整数
double d1=r.nextDouble( ); //产生大于等于0.0小于1.0的随机数
double d1=r.nextDouble(20.0); // 错
7．4．4 向量类Vector
Vector被设计成一个能不断增长的序列，用来保存对象引用。类似于可变长数组，但功能更加强大，任何类型的对象都可以放入Vector。
Vector包含在java.util包中，常用方法如下。
Vector(int initCapacity,int increment) //构造方法，指定初始容量和增量
void addElement(Object obj) //在尾部添加元素，元素个数自动增1
boolean removeElement(Object obj) //删除第一个与obj相同的元素
void setElementAt(Object obj , int index) // 替换指定位置的元素
Object elementAt(int index) //返回指定位置的元素
int indexOf(Object obj) //返回指定元素obj在向量中的位置
int size( ) //返回元素个数
int capacity( ) //返回向量长度
void trimToSize( ) //按当前元素个数缩减向量长度
Enumeration elements( ) //生成一个向量元素的枚举
例：P157
7．4．5 Class类与Runtime类
通过Class类与Runtime类的方法可以获得运行时的信息，如当前类名、超类名、包名、内存空间以及操作系统名称等
例：P159
