56. 下面看一个使用各种类型变量声明并改变的示例。程序中pi为常量，s1、i1、l1、ch1、f1、d1、b1为全局变量，可以在方法change中发生改变，然后在方法main中输出。而s2、i2、l2、ch2、f2、d2、b2是方法main的局部变量，它们的作用范围只局限于方法main中。
【例2.2】测试不同数据类型的变量，程序输出如图2.2所示。源程序代码如下：
//程序文件名称为SetVariable.java
public class SetVariable
{
//全局变量
57. static double pi = 3.141592654；//数学常量 static short s1;
static int i1;
static long l1;
static char ch1;
static float f1;
static double d1;
static boolean b1;
public static void main(String args[])
{
65. 【例2.3】测试运算符及表达式，程序输出如图2.3所示。源程序代码如下：
//程序文件名称为NumberOper.java
public class NumberOper
{
public static void main(String args[])
{
//变量初始化
int a = 30;
int b = 20;
//定义结果变量
int r1,r2,r3,r4,r5,r6,r7,r8,r9;
//计算结果
r1 = a + b;
66. r2 = a-b;
r3 = a * b;
r4 = a / b;
r5 = a % b;
r6 = a ++;
r7 = b--;
r8 = ++ a;
r9 = -- b;
//输出结果
System.out.println("a = " + a + " b = " + b); //a,b的值
System.out.println("a+b = " + r1);
System.out.println("a-b = " + r2);
70. 【例2.4】编写程序，测试关系运算符及其表达式，程序输出如图2.4所示。源程序代码如下：//程序文件名称为TestRelation.java
public class TestRelation
{
public static void main(String args[])
{
//变量初始化
int a = 30;
int b = 20;
//定义结果变量
boolean r1,r2,r3,r4,r5,r6;
//计算结果
71. r1 = a == b;
r2 = a != b;
r3 = a > b;
r4 = a < b;
r5 = a >= b;
r6 = a <= b;
//输出结果
System.out.println("a = " + a + " b = " + b);
System.out.println("a==b = " + r1);
System.out.println("a!=b = " + r2);
System.out.println("a>b = " + r3);
System.out.println("a=b = " + r5);
System.out.println("a<=b = " + r6);
}
}
72. 图2.4 程序输出结果
73. 2.3.3 布尔逻辑运算符表2.3 布尔运算符及规则
74. 图2.3为布尔逻辑运算符及其规则示例等。其中简洁与和简洁或的执行结果分别与非简洁与和非简洁或的执行结果是一致的，不同在于简洁与检测出符号左端的值为假时，不再判断符号右端的值，直接将运算结果置为假；而简洁或与非简洁或的不同在于简洁或检测出符号左端为真时，不再判断符号右端的值，直接将运算结果置为真。
例如：
Boolean a = false;
Boolean b = true;
a && b检测到a为假，则无需判断b的值，直接将值置为假；而b || a时检测到b为真，则无需判断a的值，直接将值置为真。
75. 【例2.5】测试布尔表达式，程序输出结果如图2.5所示。源程序代码如下：
//程序文件名称为TestLogic.java
public class TestLogic
{
public static void main(String args[])
{
//变量初始化
boolean a = false;
boolean b = true;
//定义结果变量
boolean r1,r2,r3,r4,r5,r6;
//计算结果
79. 【例2.6】测试位运算符<<和>>，程序输出结果如图2.6所示。源程序代码如下：
//程序文件名称为TestBit.java
public class TestBit
{
public static void main(String args[])
{
//变量初始化
int a = 36;
int b = 2;
//定义结果变量
int r1,r2;
80. //计算结果
r1 = a >> b;
r2 = a << b;
//输出结果
System.out.println("a = " + a + " b = " + b);
System.out.println("a>>b = " + r1);
System.out.println("a<
90. 【例2.7】测试if-else语句，如果x>10，则输出x的值，并提示结果正确，否则输出x= 10，提示结果不正确。程序输出结果如图2.7所示。源程序代码如下：
//程序文件名称为TestIf.java
public class TestIf
{
//声明全局变量x
static int x;
public static void main(String args[])
{
x = 12;
if(x>10)
{
96. 【例2.8】测试switch语句，当x=1、2、3时，分别打印1、2、3，x不为这三个值时，打印x的值。程序输出结果如图2.8所示。源程序代码如下：
//程序文件名称为TestSwitch.java
public class TestSwitch
{
public static void main(String args[])
//声明变量x
int x;
x = 12;
97. System.out.println("x=12时打印的值");
choose(x);
x = 3;
System.out.println("x=3时打印的值");
choose(x);
}
//choose方法：switch语句结构
public static void choose(int x)
{
switch(x)
{
98. case 1:
System.out.println(1);
break;
case 2:
System.out.println(2);
break;
case 3:
System.out.println(3);
break;
default:
System.out.println(x);
}
}
}
102. 【例2.9】用for循环统计1～100(包括100)之间数的总和。程序输出结果如图2.9所示。源程序代码如下：
//程序文件名称为TestFor.java
public class TestFor
{
public static void main(String args[])
{
int sum = 0;
for(int i = 1; i<=100; i++)
sum += i;
System.out.println("1到100(包括100)的数的总和为：" + sum);
}
}
105. 上面for循环语句的例子改为while语句后如下所示：
int sum = 0;
int i = 1;
while (i<=100)
{
sum += i;
i++;
}
System.out.println("1到100(包括100)的数的总和为：" + sum);
106. 2.4.4 do语句
do语句实现受条件控制的循环，其基本格式为：
do
{
语句或块;
}
while(布尔表达式)
107. 先执行语句或块，然后再判断布尔表达式。与while语句不同，当布尔表达式一次都不为true时，while语句一开始判断就跳出循环，不执行语句或块，而在do语句中则要执行一次。上面那个例子改为do循环为：
int sum = 0;
int i = 1;
do
{
sum += i;
i++;
}
while (i<=100);
System.out.println("1到100(包括100)的数的总和为：" + sum);
109. 数组声明时实际是创建一个引用，通过代表引用的这个名字来引用数组。数组声明格式如下：
数据类型 标识符[]
例如：
int a[]；//声明一个数据类型为整型的数组a
pencil b[]；//声明一个数据类型为pencil类的数组b
110. 2.5.2 创建数组
由于数组是一个对象，所以可以使用关键字new来创建一个数组，例如：
a = new int[10]；//创建存储10个整型数据的数组a
b = new pencil[20]；//创建存储20个pencil类数据的数组b
数组创建时，每个元素都按它所存放数据类型的缺省值被初始化，如上面数组a的值被初始化为0，也可以进行显式初始化。在Java编程语言中，为了保证系统的安全，所有的变量在使用之前必须是初始化的，如果未初始化，编译时会提示出错。有两种初始化数组的方式，分别如下：
112. 【例2.10】编写程序测试数组，程序输出结果如图2.10所示。源程序代码如下：
//程序文件名称为TestArray.java
public class TestArray
{
public static void main(String args[])
{
//声明数组
int a[];
char b[];
//创建数组
113. a = new int[3];
b = new char[2];
//数组初始化
for (int i = 0; i<3; i++)
{
a[i] = i*3;
}
b[0] = 'a';
b[1] = 'b';
//快速初始化数组
int c[] = {0,1*3,2*3};
//输出结果
System.out.print("数组a\n");
114. for (int i = 0; i<2; i++)
{
System.out.print(b[i] + " ");
}
System.out.print("\n数组c\n");
for (int i = 0; i<3; i++)
{
System.out.print(c[i] + " ");
}
}
}
121. //程序文件名为SetApple.java
public class SetApple
{
public static void main(String[] args)
{
apple a = new apple();//创建apple类
a.appleweight = 0.5;//实例变量赋值
System.out.println("苹果的重量为1两");
System.out.println(a.bite());//调用实例方法
a.appleweight = 5;
System.out.println("苹果的重量为5两");
System.out.println(a.bite());
}
}
122. //自定义类
class apple
{
//属性
long applecolor;//对应苹果的颜色
double appleweight;//苹果的重量
boolean eatup;//是否吃完
//类方法
public boolean bite()
{
if (appleweight<1)
{
System.out.println("苹果已经吃完了！哈哈");
eatup = true;
}
126. 例如：
public class HelloApplet extends Applet
访问说明符为public，类名HelloApplet，扩展类为JDK包自带的java.applet.Applet类。由于public的存在，所以文件名必须存为HelloApplet.java，同类名保持一致。
129. 3. 创建类的实例
使用关键字 new进行创建，例如：
HelloApplet hp = new HelloApplet();
例3.1中，自定义类apple，访问标识符缺省，定义三个属性：
long applecolor;//对应苹果的颜色
double appleweight;//苹果的重量
boolean eatup;//是否吃完
130. 一个方法为：
public boolean bite()//类方法{...}
公有类SetApplet中引用自定义类，首先创建类的实例：
apple a = new apple();
其次赋初值：
a.appleweight = 0.5;//实例变量赋值
最后调用它的方法：
System.out.println(a.bite());//调用实例方法
131. 3.1.2 类的单继承性
Java编程语言中允许用extends关键字从一个类扩展出一个新类，新类继承超类的成员变量和方法，并可以覆盖方法。
【例3.2】测试类的单继承性，程序输出结果如图3.2所示。源程序代码如下：
//程序文件名TestExtend.java
public class TestExtend extends Employee
{
public static void main(String[] args)
{
System.out.println("覆盖的方法调用：" + getSalary("王一",500));
132. System.out.println("继承的方法调用：" + getSalary2("王一",500));
System.out.println("覆盖的方法调用：" + getSalary("王飞",10000));
System.out.println(“继承的方法调用：” + getSalary2(“王飞 ",10000));
}
public static String getSalary(String name, int salary)
{
String str;
if (salary>5000)
str = "名字: " + name + " Salary: " + salary;
else
str = "名字: " + name + " Salary: 低于5000";
133. return str;
}
};
class Employee
{
public String name;//名字
public int salary;//薪水
public static String getSalary(String name, int salary)
{
String str;
str = "名字: " + name + " Salary: " + salary;
return str;
}
134. public static String getSalary2(String name, int salary)
{
String str;
str = "名字: " + name + " Salary: " + salary;
return str;
}
};
137. 3.1.3 特殊变量
类中有两个特殊变量super和this。
1. super
类声明中用关键字extends扩展了其超类之后，super用在扩展类中引用其超类中的成员变量。
【例3.3】使用super变量，输出结果如图3.3所示。源程序代码如下：
//程序文件名为UseSuper.java
public class UseSuper
{
138. public static void main(String[] args)
{
Manager m = new Manager();
m.name = "王飞";
m.salary = 10000;
m.department = "业务部";
System.out.println(m.getSalary());
}
}
class Employee
{
139. public String name;//名字
public int salary;//薪水
//方法
public String getSalary()
{
String str;
str = "名字: " + name + "\nSalary: " + salary;
return str;
}
}
class Manager extends Employee
140. {
public String department;//部门
//方法
public String getSalary()
{
//使用super变量调用超类的方法
return super.getSalary() + "\nDepartment: " + department;
}
}
141. 图3.3 测试super变量的输出
142. 2. this
this变量指向当前对象或实例。
str = "名字: " + name + "\nSalary: " + salary;
上例中的语句可以换成下面的语句。
str = "名字: " + this.name + "\nSalary: " + this.salary;
这两者是等同的，因为在Java编程语言中，系统自动将this关键字与当前对象的变量相关联。但有一种情况例外，就是当在某些完全分离的类中调用一个方法并将当前对象的一个引用作为参数传递时。例如：
Day d = new Day(this);
143. 3.1.4 构造函数
类中的构造函数用来初始化一个类。构造函数为公有类型，无返回值，用来从类实例中访问类时初始化此类的私有变量。
【例3.4】基于例3.3将公有变量改成私有变量之后，增加两个构造函数，访问通过外部调用构造函数实现初始化赋值，得到如图3.3所示的结果。
//程序文件名为UseConstruct.java
public class UseConstruct
{
public static void main(String[] args)
{
144. Manager m = new Manager("王飞",10000,"业务部");//初始化赋值
System.out.println(m.getSalary());
}
}
class Employee
{
private String name;//名字
private int salary;//薪水
//构造函数
public Employee(String _name, int _salary)
{
145. name = _name;
salary = _salary;
}
public String getSalary()
{
String str;
str = "名字: " + name + "\nSalary: " + salary;
return str;
}
}
class Manager extends Employee
{
private String department;
146. //构造函数
public Manager(String _name, int _salary, String _department)
{
super(_name,_salary);
department = _department;
}
public String getSalary()
{
return super.getSalary() + "\nDepartment: " + department;
}
}
149. 【例3.5】编写程序测试包，先建立一个Company文件夹，然后建立名为Manager.java的类文件。源程序代码如下：
//程序文件名为Manager.java
package Company;//声明包名Company
class Employee
{
public String name;//名字
public int salary;//薪水
public String getSalary()
{
150. String str;
str = "名字: " + name + "\nSalary: " + salary;
return str;
}
}
public class Manager extends Employee
{
public String department;//部门
public String getSalary()
{
return super.getSalary() + "\nDepartment: " + department;
}
}
151. 对此文件进行编译，生成类文件Manager.class。
在原目录建立源程序文件UsePackage.java。源程序代码如下：
//程序文件名UsePackage.java
import Company.Manager;//引入包中的类
public class UsePackage
{
public static void main(String[] args)
{
Manager m = new Manager();
m.name = "王飞";
m.salary = 10000;
m.department = "业务部";
System.out.println(m.getSalary());
}
}
155. 【例3.6】测试接口，定义接口文件Product.java，定义了两个常量，声明了一个方法。接口文件如下：
//程序文件名Product.java
public interface Product
{
static final String MAKER = "计算机制造厂";
static final String ADDRESS = "上海";
public int getPrice();
}
156. 使用接口的源文件代码如下：
//程序文件名UseInterface.java
public class UseInterface
{
public static void main(String[] args)
{
Computer p = new Computer();
System.out.print(p.ADDRESS + p.MAKER);
System.out.println(" 计算机的价格：" + p.getPrice()+ " 万元");
}
}
157. class Computer implements Product
{
public int getPrice()
{
return 1;
}
}
160. public Vector(int initialCapacity);
该方法创建一个初始长度为initialCapacity的Vector。
public Vector(int initialCapacity, int capacityIncrement);
该方法创建一个初始长度为initialCapacity的Vector，当向量需要增长时，增加capacityIncrement个元素。
161. (1) Vector类中添加、删除对象的方法如下：
public void add(int index, Object element)
在index位置添加对象element。
public boolean add(Object o)
在Vector的末尾添加对象o。
public Object remove(int index)
删除index位置的对象，后面的对象依次前提。
162. (2) Vector类中访问、修改对象的方法如下：
public Object get(int index)
返回index位置对象。
public Object set(int index, Object element)
修改index位置的对象为element。
163. (3) 其它方法：
public String toString()
将元素转换成字符串。
public int size()
返回对象的长度。
164. 【例3.7】操作Vector对象，进行元素的添加、插入、修改和删除。程序输出结果如图3.6所示。源程序代码如下：
//程序文件名为UseVector.java
import java.util.Vector;//引入JDK的Vector类
public class UseVector
{
public static void main(String[] args)
{
165. Vector vScore = new Vector();
vScore.add(" 86"); //添加元素
vScore.add(" 98"); //添加元素
vScore.add(1, " 99"); //插入元素
//输出结果
for (int I = 0; I < vScore.size(); I++)
{
System.out.print(vScore.get(i) + " ");
}
vScore.set(1, " 77"); //修改第二个元素
vScore.remove(0); //删除第一个元素
168. 3.3.2 Hashtable类
Hashtable类存储的是对象的名-值对。将对象的名和它的值相关联同时存储，并可以根据对象名来提取它的值。在Hashtable中，一个键名只能对应着一个键值，然而一个键值可以对应多个键名，键名必须是惟一的。构造函数以及常用方法如下：
public Hashtable()
构建散列表。
public Hashtable(int initialCapacity)
构建长度为initialCapacity的散列表。
public int size()
169. 返回散列表的名的个数。
public Object remove(Object key)
删除散列表中key名及其对应的value值。
public Object put(Object key,Object value)
将对象名key和对象值value存放到散列表中。
public Object get(Object key)
返回散列表key名对应的值。
public String toString()
转换成字符串。
170. 【例3.8】操作Hashtable对象，进行添加、修改、删除等操作，输出结果如图3.7所示。源程序代码如下：
//程序文件名为UseHashtable.java
import java.util.Hashtable;
public class UseHashtable
{
public static void main(String[] args)
{
Hashtable hScore = new Hashtable();
hScore.put("张一","86");
178. 3.3.4 Date类
Date类用来指定日期和时间，其构造函数及常用方法如下：
public Date()
从当前时间构造日期时间对象。
public String toString()
转换成字符串。
public long getTime()
返回自新世纪以来的毫秒数，可以用于时间计算。
179. 【例3.10】测试执行循环花费的时间(数量级为毫秒)，具体时间情况如图3.9所示。源程序代码如下：
//程序文件名为UseDate.java
import java.util.Date;
public class UseDate
{
public static void main(String[] args)
{
Date dOld = new Date();
long lOld = dOld.getTime();
System.out.println("循环前系统时间为：" +dOld.toString());
180. int sum = 0;
for (int i=0; i<100; i++)
{
sum += i;
}
Date dNew = new Date();
long lNew = dNew.getTime();
System.out.println("循环后系统时间为：" +dNew.toString());
System.out.println("循环花费的毫秒数为：" + (lNew - lOld));
}
}
181. 图3.9 循环时间测试
182. 3.3.5 String类
String类用于操作非数值型字符串，它提供了七类方法操作，分别为字符串创建、字符串长度、字符串比较、字符串检索、字符串截取、字符串运算和数据类型转换。
1. 字符串创建
public String()
构造一个空字符串。
public String(char[] value)
使用字符数组value中的字符以构造一个字符串。
public String(String original)
使用原字符串original的拷贝以构造一个新字符串。
183. 2. 字符串长度
public int length()
返回字符串的长度。
3. 字符串比较
public boolean equals(Object anObject)
比较字符串是否与anObject代表的字符串相同(区分大小写)。
public boolean equalsIgnoreCase(String anotherString)
比较字符串是否与anotherString相同(不区分大小写)。
184. 4. 字符串检索
public int indexOf(String str)
返回一个字符串中str第一次出现所在的位置。
public int indexOf(String str, int fromIndex)
返回从fromIndex开始字符串str出现所在的位置。
185. 5. 字符串截取
public String substring(int beginIndex, int endIndex)
返回benginIndex到endIndex之间的字符串。
6. 字符串运算
运算符为“+”，表示连接运算。下面的行语句输出连接的字符串。
System.out.println("Hashtable：" + hScore.toString());
186. 【例3.11】操作字符串，输出结果如图3.10所示。源程序代码如下：
//程序文件名为TestString.java
public class TestString
{
public static void main(String[] args)
{
String str = new String("The substring begins at the specified beginIndex.");
String str1 = new String("string");
String str2 = new String();
int size = str.length();//字符串长度
189. 7. 数据类型转换
各种原始数据类型与String类型之间可以通过方法相互转换。
valueOf()系列的静态方法用于从其它对象(原始数据类型对象)转换成字符串。例如：
public static String valueOf(Boolean b)
public static String valueOf(char c)
public static String valueOf(int i)
public static String valueOf(long l)
public static String valueOf(float f)
public static String valueOf(double d)
199. (1) append方法系列根据参数的数据类型在StringBuffer对象的末尾直接进行数据添加。
public StringBuffer append(boolean b)
public StringBuffer append(char c)
public StringBuffer append(char[] str)
public StringBuffer append(char[] str, int offset, int len)
public StringBuffer append(double d)
public StringBuffer append(float f)
public StringBuffer append(int i)
public StringBuffer append(long l)
public StringBuffer append(Object obj)
public StringBuffer append(String str)
public StringBuffer append(StringBuffer sb)
200. (2) insert方法系列根据参数的数据类型在StringBuffer的offset位置进行数据插入。
public StringBuffer insert(int offset, boolean b)
public StringBuffer insert(int offset, char c)
public StringBuffer insert(int offset, char[] str)
public StringBuffer insert(int index, char[] str, int offset, int len)
public StringBuffer insert(int offset, double d)
public StringBuffer insert(int offset, float f)
public StringBuffer insert(int offset, int i)
public StringBuffer insert(int offset, long l)
public StringBuffer insert(int offset, Object obj)
public StringBuffer insert(int offset, String str)
201. (3) 下面这个方法用于将stringbuffer对象的数据转换成字符串：
public String toString()
202. 【例3.12】基于例3.11进行修改，使用StringBuffer对象得到如图3.10所示的输出界面。
//程序文件名为TestString.java
public class TestString
{
public static void main(String[] args)
{
StringBuffer str = new StringBuffer("The substring begins at the specified beginIndex.");
StringBuffer str1 = new StringBuffer("string");
String str2 = new String();
int size = str.length();
int flag = str.indexOf("substring");
203. str2 = str.substring(flag,flag + 9);
StringBuffer strOut = new StringBuffer("字符串");
strOut.append(str);
strOut.append("总长度为：");
strOut.append(size);
int f = strOut.indexOf("总");
strOut.insert(f,'\n');
System.out.println(strOut.toString());
if(str1.toString().equals(str2))
System.out.println("截取的字符串为：" + str1.toString());
else
System.out.println("截取的字符串为：" + str2);
}
}
204. 3.3.7 StringTokenizer类
StringTokenizer类是一个实现Enumeration接口的类，它使得应用程序可以将字符串分成多个记号，默认情况下以空格为分隔符，例如将字符串“this is a test”分成四个单词记号。用户也可以指定分隔符。分隔符为false，分割字符串；分隔符为true，则将分隔符自身作为分割后的字符串的一部分。其构造函数和常用方法如下：
StringTokenizer(String str)
以字符串str构建StringTokenizer对象。
206. 【例3.13】使用StringTokenizer类分割字符串，字符串的分割情况如图3.11所示。源程序代码如下：
import java.util.*;
public class UseToken
{
public static void main(String[] args)
{
String str = "数学::英语::语文::化学";
StringTokenizer st = new StringTokenizer(str,"::");
System.out.println(str + "\n课程数为：" +st.countTokens());
207. while (st.hasMoreTokens())
{
System.out.println(st.nextToken("::"));
}
str = "Hello this is a test";
st = new StringTokenizer(str);
System.out.println(str + "\n单词数为：" +st.countTokens());
while (st.hasMoreTokens())
{
System.out.println(st.nextToken());
}
}
}
216. 4.1.3 Applet的编写格式
编写Applet时，首先要引入java.applet包中的类，这个类里包含三个接口和Applet的类：
import java.applet.*;
import java.applet.Applet;
类头定义为：
public class MyApplet extends Applet;
用来声明自定义类是从Applet类扩展而来的。
217. 类体中没有应用程序中必须具备的main方法，取而代之的是下面几个常用方法：
public void init();
初始化——在这个方法中设置一些变量的初始化，像界面布局设置等。
public void start()
启动——Applet开始执行。
public void stop()
停止——Applet停止执行。
public void destroy()
撤消——销毁Applet。
218. 【例4.1】编写Applet，显示系统的当前时间。源程序代码如下：
//程序文件名UseApplet.java
import java.awt.*;
import java.applet.Applet;
import java.util.Date;
public class UseApplet extends Applet
{
String strTime = new String();
public void init()
{
}
219. public void start()
{
Date d = new Date();
strTime = d.toString();
repaint();
}
public void paint(Graphics g)
{
g.drawString("当前时间为：" + strTime,20,30);
}
};
277. (2) 修改后的源程序代码如下：
//程序文件名AppletApp.java
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
import java.util.Date;
public class AppletApp extends Applet
{
String strTime = new String();
public void init()
{
}
278. public void start()
{
Date d = new Date();
strTime = d.toString();
repaint();
}
public void paint(Graphics g)
{
g.drawString("当前时间为：" + strTime,20,30);
}
public static void main(String[] args)
{
279. //创建一个框架
Frame f = new Frame("时间");
//关闭窗口时退出系统
f.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
//创建一个AppletApp对象
AppletApp a = new AppletApp();
287. strUser = new String(args[0]);
//创建一个框架
Frame f = new Frame("时间");
//关闭窗口时退出系统
f.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
//创建一个AppletApp对象
AppPara a = new AppPara();
295. 5.2 Paint方法、Update方法和Repaint方法 1. Paint方法
public void paint(Graphics g)
以画布为参数，在画布上执行画图方法。在Applet中，不显式地调用paint方法。
2. Repaint方法
Applet重画时系统自动调用paint方法。
3. Update方法
public void update(Graphics g)
更新容器，向Repaint发出刷新小应用程序的信号，缺省的Update方法清除Applet画图区并调用Paint方法。
296. 5.3 Graphics类 Graphics类是所有图形上下文的抽象基类，允许应用程序在各种设备上实现组件的画图。图形对象封装了Java支持的基本渲染操作的状态信息，包括画图的组件对象、渲染区域的坐标(coordinates)、区域(clip)、颜色(color)、字体(font)、画图模式等。Graphics类提供画各种图形的方法，其中包括线、圆和椭圆、矩形和多边形、图像以及各种字体的文本等。这些方法具体如下：
public abstract void clipRect(int x, int y, int width, int height)
指定的区域切分。
297. public abstract void drawLine(int x1, int y1, int x2, int y2)
使用当前颜色，在点(x1, y1) 和 (x2, y2) 之间画线。
public abstract void drawOval(int x, int y, int width, int height)
画椭圆。
public abstract void fillOval(int x, int y, int width, int height)
画实心椭圆。
public abstract void drawPolygon(int[] xPoints, int[] yPoints, int nPoints)
画x和y坐标定义的多边形。
298. public void drawRect(int x, int y, int width, int height)
画矩形。
public void drawRect(int x, int y, int width, int height)
画实心矩形。
public abstract void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
使用当前颜色画圆角矩形。
public abstract void drawString(String str, int x, int y)
使用当前字体和颜色画字符串str。
299. public abstract void setColor(Color c)
设置图形上下文的当前颜色。
public abstract void setPaintMode()
设置画模式。
public abstract boolean drawImage(Image img, int x, int y, ImageObserver observer)
画特定图。
public abstract void setFont(Font font)
设置特定的font字体。使用时首先得到font对象的一个实例，Font类常用构造函数为：
public Font(String name, int style, int size)
300. 通过指定的name、style和size创建字体实例。name指字体名，像“隶书”、“TimesRoman”等，字体风格为粗体、斜体，size指字号大小。
例如：
Font f = new Font("TimesRoman",Font.BOLD + Font.ITALIC, 12);
创建了具有粗斜体风格的12磅的TimesRoman字体。
301. 【例5.1】设置Graphics对象画图，显示结果如图5.1所示。源程序代码如下：
//程序文件名SimpleGUI.java
import java.awt.*;
import java.applet.*;
public class SimpleGUI extends Applet
{
Image samImage;
public void init()
{
samImage=getImage(getDocumentBase(),"sample.gif");
302. }
public void paint(Graphics g)
{
//g.clipRect(50,50,180,180);
//画线
g.drawLine(0,0,20,30);
//输出字符串
g.drawString("图形显示",100,30);
//设置颜色
Color c = new Color(255,200,0);
g.setColor(c);
//设置字体
303. Font f = new Font("TimesRoman",Font.BOLD+ Font.ITALIC,24);
g.setFont(f);
g.drawString("图形显示",180,30);
g.drawLine(20,20,100,50);
g.drawLine(20,20,50,100);
//矩形
g.drawRect(40,40,40,40);
g.fillRect(60,60,40,40);
g.setColor(Color.red);
//3D矩形
g.draw3DRect(80,80,40,40,true);
308. 5.4 Color类 Color类是用来封装颜色的，在上面的例子中多次用到。使用Color对象较为简单的方法是直接使用Color类提供的预定义的颜色，像红色Color.red、橙色Color.orange等；也可以使用RGB颜色模式进行定义。所谓RGB颜色模式是指使用三种基色：红、绿、蓝，通过三种颜色的调整得出其它各种颜色，这三种基色的值范围为0～255。例如Color c = new Color(255,200,0);定义橙色。表5.1给出常用颜色的RGB值以及对应的类预定义参数。
309. 表5.1 常用颜色的RGB值以及对应的类预定义参数
310. Color还有一个构造函数，它构造的Color对象用于是否透明显示颜色。
public Color(int red, int green, int blue, int alpha)
其中：前三个分量即RGB颜色模式中的参数，第四个alpha分量指透明的程度。当alpha分量为255时，表示完全不透明，正常显示；当alpha分量为0时，表示完全透明，前三个分量不起作用，而介于0～255之间的值可以制造出颜色不同的层次效果。
311. 【例5.2】测试Color对象，界面如图5.3所示。源程序代码如下：
//程序文件名UseColor.java
import java.awt.*;
import java.applet.*;
import java.awt.geom.*;
public class UseColor extends Applet
{
public void paint(Graphics oldg)
{
Graphics2D g = (Graphics2D)oldg;
319. 在Draw方法中提到Graphics2D的环境设置。所谓的环境设置是指设置画图的笔画和填充属性等，设置方法分别如下：
public abstract void setStroke(Stroke s)
设置笔画的粗细。其中Stroke接口中常用BasicStroke类来实现，一个较简单的构造函数为
public BasicStroke(float width)
创建实线笔画宽度为width。
public abstract void setPaint(Paint paint)
320. 设置Graphics2D环境的填充属性。其中，paint的值可以为渐变填充类java.awt.GradientPaint，也可以为图形填充类java.awt.TexturePaint，后者将在5.5.3节绘制图像中讲到。渐变填充类常用构造函数为
public GradientPaint(float x1, float y1, Color color1, float x2, float y2, Color color2, boolean cyclic)
构建一个渐变GradientPaint对象，在起始坐标点到目标坐标点之间从颜色color1到color2渐变，cyclic为真，循环渐变。
321. 【例5.3】演示了几何形状、笔画变换以及颜色渐变显示。其中直线的笔画宽度为10，其它笔画宽度为5，中间三个图形实现绿色到蓝色的循环渐变，后三个图形实现红色到黄色的循环渐变，如图5.4所示。
//程序文件名GUI2D.java
import java.awt.*;
import java.applet.*;
import java.awt.geom.*;
public class GUI2D extends Applet
{
322. public void paint(Graphics oldg)
{
Graphics2D g = (Graphics2D)oldg;
//设置笔画宽度
BasicStroke stroke = new BasicStroke(10);
g.setStroke(stroke);
//画线
Line2D line = new Line2D.Float(0,0,20,30);
g.draw(line);
line = new Line2D.Float(50,50,100,50);
g.draw(line);
323. line = new Line2D.Float(50,50,50,100);
g.draw(line);
stroke = new BasicStroke(5);
g.setStroke(stroke);
//设置渐变填充
GradientPaint gt = new GradientPaint(0,0,Color.green,50,30,Color.blue,true);
g.setPaint((Paint)gt);
//画矩形
Rectangle2D rect = new Rectangle2D.Float(80,80,40,40);
324. g.draw(rect);
rect = new Rectangle2D.Float(100,100,40,40);
g.fill(rect);
//画椭圆
Ellipse2D ellipse = new Ellipse2D.Float(120,120,30,40);
g.draw(ellipse);
gt = new GradientPaint(0,0,Color.red,30,30,Color.yellow,true);
g.setPaint((Paint)gt);
ellipse = new Ellipse2D.Float(140,140,20,20);
g.fill(ellipse);
325. //画圆角矩形
RoundRectangle2D roundRect = new RoundRectangle2D.Float(160,160,40,40,20,20);
g.draw(roundRect);
roundRect = new RoundRectangle2D.Float(180,180,40,40,20,20);
g.fill(roundRect);
//画几何图形
GeneralPath path = new GeneralPath();
path.moveTo(150,0);
path.lineTo(160,50);
path.curveTo(190,200,240,140,200,100);
g.fill(path);
}
}
326. 图5.4 通过Graphics2D对象绘制形状
327. 5.5.2 绘制文本
Graphics2D类提供一个文本布局(TextLayout)对象，用于实现各种字体或段落文本的绘制。其构造函数为：
public TextLayout(String string, Font font, FontRenderContext frc)
通过字符串string和字体font构造布局。
public void draw(Graphics2D g2, float x, float y)
将这个TextLayout对象画到Graphics2D对象g2上的x，y坐标处。
public Rectangle2D getBounds()
返回TextLayout对象的区域。
328. 【例5.4】测试绘制文本功能，如图5.5所示。源程序代码如下：
//程序文件GUIText.java
import java.awt.*;
import java.applet.*;
import java.awt.geom.*;
import java.awt.font.*;
public class GUIText extends Applet
{
public void paint(Graphics oldg)
{
329. Graphics2D g = (Graphics2D)oldg;
//设置字体
Font f1 = new Font("Courier",Font.PLAIN,24);
Font f2 = new Font("helvetica",Font.BOLD,24);
FontRenderContext frc = g.getFontRenderContext();
String str = new String("这是一个文本布局类的实现");
String str2 = new String("扩充绘制文本的功能");
//构造文本布局对象
TextLayout layout = new TextLayout(str, f1, frc);
Point2D loc = new Point2D.Float(20,50);
332. 5.5.3 绘制图像
绘制图像用到BufferedImage类，BufferedImage类是指存放图像数据的可访问的缓冲。其构造函数为：
public BufferedImage(int width, int height, int imageType)
使用宽度(width)、高度(height)和imageType类型构造BufferedImage对象。
public Graphics2D createGraphics()
334. (2) 用TexturePaint类进行填充：
public TexturePaint(BufferedImage txtr, Rectangle2D anchor)
构造TexturePaint对象，需要一个Rectangle2D对象来存放该对象：
Rectangle2D rect = new Rectangle2D.Float(0,0,h,w);
TexturePaint t = new TexturePaint(buf,rect);
(3) 然后设置填充模式，并进行填充：
g.setPaint(t);
g.fill(new Ellipse2D.Float(100,50,60,60));
336. public class GUIImage extends Applet
{
public void paint(Graphics oldg)
{
Graphics2D g = (Graphics2D)oldg;
try
{
URL imgURL = new URL(getDocumentBase(),"sample.gif");
Image img = getImage(imgURL);
int h = img.getHeight(this);
int w = img.getWidth(this);
337. //构造缓冲图像对象
BufferedImage buf = new BufferedImage(w,h,BufferedImage.TYPE_INT_ARGB);
//放入临时图形类
Graphics tmpG = buf.createGraphics();
tmpG.drawImage(img,10,10,this);
g.drawImage(buf,10,20,this);
//设置透明颜色对象
Color transBlue = new Color(0,0,255,100);
g.setColor(transBlue);
GeneralPath path = new GeneralPath();
338. path.moveTo(60,0);
path.lineTo(50,100);
path.curveTo(160,230,240,140,200,100);
g.fill(path);
transBlue = new Color(0,0,255,240);
g.fill(new Ellipse2D.Float(100,100,50,50));
Rectangle2D rect = new Rectangle2D.Float(0,0,h,w);
//图片填充
TexturePaint t = new TexturePaint(buf,rect);
345. 6.1.1 按钮
Button类创建一个带标签的按钮对象，当按下一个按钮时，可以引发一些事件，包含一系列的动作或操作。例如单击按钮，使得界面颜色发生变化等。它的构造函数以及主要的方法如下：
public Button()
构建一个没有标签的按钮。
public Button(String label)
构建一个显示为label的按钮。
public void setLabel(String label)
设置显示标签为字符串label。
public String getLabel()
获取按钮的标签，返回为字符串。
346. 【例6.1】测试Button类的Applet。用户界面如图6.1所示。源程序代码如下：
//程序文件名UseButton.java
import java.awt.*;
import java.applet.*;
import java.applet.Applet;
public class UseButton extends Applet
{
String str1 = new String();
//声明按钮对象
Button b1;
Button b2;
347. public void init()
{
//构造对象
b1 = new Button();
b2 = new Button("按钮对象2");
//添加到界面
this.add(b1);
this.add(b2);
}
public void start()
{
351. 6.1.2 复选框和单选按钮
复选框是一个图形组件，有两个状态，即“选中”(true)和“未选中”(false)。单击复选框时可以在“选中”、“未选中”之间进行切换。在Java编程语言中，单选按钮没有单独的类，而是作为复选框的特例存在，用户通过把一组复选框放置在同一个复选框组中创建一套单选按钮。它的构造函数和其它方法如下：
public Checkbox()
创建一个没有标签的复选框。
public Checkbox(String label)
创建一个标签为lable的复选框。
352. public Checkbox(String label, boolean state)
创建一个标签为lable的复选框，并设置初始状态。
public CheckboxGroup()
创建一个复选框组，用来放置单选按钮。
public Checkbox(String label, CheckboxGroup group, boolean state)
创建一个标签为lable的复选框，添加到group组中并设置初始状态，作为单选按钮的形式出现。
353. public String getLabel()
获得复选框的标签。
public void setLabel(String label)
设置标签。
public boolean getState()
返回复选框所在的状态，是选中还是未选中。
public void setState(boolean state)
设置状态，用来初始化复选框的状态。
354. 【例6.2】测试复选框和单选按钮的用法，用户界面如图6.2所示。源程序代码如下：
//程序文件名UseCheckbox.java
import java.awt.*;
import java.applet.*;
import java.applet.Applet;
public class UseCheckbox extends Applet
{
String str1 = new String();
boolean b1 = false;
boolean b2 = false;
355. Checkbox c1,c2,c3;
Checkbox cRadio1,cRadio2;
CheckboxGroup c;
public void init()
{
c1 = new Checkbox();
c2 = new Checkbox("复选框对象2");
c3 = new Checkbox("复选框对象3",true);
//构造单选按钮
c = new CheckboxGroup();
cRadio1 = new Checkbox("单选按钮1",c, false);
356. cRadio2 = new Checkbox("单选按钮2",c,true);
//添加到界面
this.add(c1);
this.add(c2);
this.add(c3);
this.add(cRadio1);
this.add(cRadio2);
}
public void start()
{
c1.setLabel("复选框对象1");
359. 6.1.3 组合框
组合框代表一系列选择的弹出式菜单，当前选择显示为菜单的标题。它的构造函数和其它常用方法如下：
public Choice()
构建一个选择项菜单。
public void add(String item)
将item添加到选择菜单中。
public String getItem(int index)
返回选择菜单中index位置的项，注意索引是从0开始的，而项数从1开始。
360. public int getItemCount()
返回选择菜单总的项数。
public String getSelectedItem()
返回当前选中的项。
public int getSelectedIndex()
返回当前选中项的索引。
public void insert(String item, int index)
在index处插入字符串item。
public void remove(int position)
删除position位置的项。
361. public void remove(String item)
删除item项。
public void removeAll()
删除所有的项。
public void select(int pos)
将pos处的项设为选中状态，通常用于初始化。
public void select(String str)
将str项设为选中状态，通常用于初始化。
362. 【例6.3】测试Choice类，用户界面如图6.3所示。源程序代码如下：
//程序文件名UseChoice.java
import java.awt.*;
import java.applet.*;
import java.applet.Applet;
public class UseChoice extends Applet
{
String str1 = new String();
String str2 = new String();
int count = 0;
int i1 = 0;
366. 在上例的基础上添加一个方法operate，并在start方法中调用此方法，程序段如下：
public void operate()
{
c1.insert("英语",3);
c1.remove("生物");
}
public void start()
{
operate();
count = c1.getItemCount();
...
}
367. 图6.4 修改操作后的用户界面
368. 6.1.4 标签
标签对象就是将文本放入一个容器内的组件，显示一行只读文本。文本可以由程序修改，用户无法直接修改。它的构造函数和其它常用方法如下：
public Label()
构建一个空标签。
public Label(String text)
构建一个text内容的标签，默认为左对齐。
public Label(String text, int alignment)
375. 6.1.5 列表
List展示给用户一个滚动的文本项列表。用户可以选择其中一项或多项。它的构造函数和其它常用方法如下：
public List()
构建一个新的空滚动列表。
public List(int rows)
构建一个新的rows可见行的滚动列表。
public List(int rows, boolean multipleMode)
构建一个新的rows可见行的滚动列表，并设置是否可以多项选择。multipleMode为true时，允许用户多项选择。
376. public void add(String item)
在滚动列表最后添加新的一项item。
public void add(String item, int index)
在index位置添加item项。
public String getItem(int index)
返回index位置的项。
public int getItemCount()
返回列表中项的数目。
public String[] getItems()
返回列表中的项，为一个字符串数组。
377. public int getSelectedIndex()
返回列表中选中项的索引。
public String getSelectedItem()
返回列表中选中的项。
public boolean isIndexSelected(int index)
判断index项是否选中。
public void remove(int position)
删除position项。
public void remove(String item)
删除item项。
378. public void removeAll()
删除列表中所有元素。
public void replaceItem(String newValue, int index)
将index位置的项替换为newValue。
public void select(int index)
选中index位置的项，通常用于初始化。
379. 【例6.5】测试List类，用户界面如图6.6所示。源程序代码如下：
//程序文件名UseList.java
import java.awt.*;
import java.applet.*;
import java.applet.Applet;
public class UseList extends Applet
{
String str1 = new String();
String str2 = new String();
int i1 = 0;
int i2 = 0;
380. List l1,l2,l3;//声明对象
public void init()
{
l1 = new List();
l2 = new List(5);
l3 = new List(5,true);
//列表添加内容
l1.add("苹果");
l1.add("香蕉");
l1.add("梨");
l2.add("语文");
l2.add("数学");
385. 它的构造函数和其它常用方法如下：
public Scrollbar()
构建一个新的垂直滚动条。
public Scrollbar(int orientation)
构建一个指定方向的滚动条。Orientation的值为HORIZONTAL(0)表示水平滚动条，值为VERTICAL(1)表示垂直滚动条。
public Scrollbar(int orientation, int value, int visible, int minimum, int maximum)
构建一个指定方向、初始值、可见性、最小值和最大值的滚动条。
386. public int getValue()
返回滚动条的当前值。
public int getMinimum()
返回最小值。
public int getMaximum()
返回最大值。
387. 【例6.6】测试Scrollbar类，用户界面如图6.7所示。源程序代码如下：
//程序文件名UseScrollbar.java
import java.awt.*;
import java.applet.*;
import java.applet.Applet;
public class UseScrollbar extends Applet
{
int i1 = 0;
int i2 = 0;
int i3 = 0;
int i4 = 0;
int i5 = 0;
Scrollbar s1;//声明对象
388. Scrollbar s2;
Scrollbar s3;
public void init()
{
s1 = new Scrollbar();
s2 = new Scrollbar(Scrollbar.HORIZONTAL);
s3 = new Scrollbar(Scrollbar.VERTICAL,50,0,10,500);
this.add(s1);
this.add(s2);
this.add(s3);
}
public void start()
{
392. 6.1.7 文本框
TextField对象用作单行文本的编辑。它的构造函数和其它常用方法如下：
public TextField()
构建一个空的文本框。
public TextField(int columns)
构建一个文本框，columns给出文本框的宽度。
public TextField(String text)
构建一个文本框，用text给出初始化内容。
public TextField(String text, int columns)
393. 构建一个文本框，text给出初始化的内容，columns给出文本框的宽度。
public void setText(String t)
将文本框的内容设置为特定文本t。
public String getText()
返回文本框的内容，返回值为字符串。
public void setEditable(boolean b)
设定文本框内容是否是用户可编辑的，b为false时，表示不可编辑，b为true时，表示可编辑。通常创建一个文本框时默认为用户可编辑的。
public int getColumns()
获取列数。
394. 【例6.7】TextField类的测试，用户界面如图6.8所示。源程序代码如下：
//程序文件名UseTextField.java
import java.awt.*;
import java.applet.*;
import java.applet.Applet;
public class UseTextField extends Applet
{
String str1 = new String();
int i1 = 0;
int i2 = 0;
TextField tf1, tf2, tf3, tf4;
public void init()
{
395. tf1 = new TextField();
tf2 = new TextField(20);
tf3 = new TextField("文本对象3");
tf4 = new TextField("文本对象4", 30);
add(tf1);
add(tf2);
add(tf3);
add(tf4);
}
public void start()
{
398. 6.1.8 文本区域
TextArea对象用于允许多行编辑的文本区域，可以设置为可编辑的，也可以设为只读属性。
public TextArea()
构建一个空文本区域。
public TextArea(int rows, int columns)
构建一个行数为rows、列数为columns的空文本区域。
public TextArea(String text)
构建一个文本为text的文本区域。
399. public TextArea(String text, int rows, int columns)
构建一个文本为text、行数为rows、列数为columns的文本区域。
public TextArea(String text, int rows, int columns, int scrollbars)
构建一个文本为text、行数为rows、列数为columns的文本区域。滚动条的情况由scrollbars参数决定。Scrollbars的取值如表6.3所示。
400. 表6.3 TextArea中的滚动条属性值
401. public void append(String str)
将非空str字符串文本添加到文本区域中。
public void insert(String str, int pos)
在指定位置pos插入非空字符串str。
public void replaceRange(String str, int start, int end)
将start开始位置到end结束位置的字符串替换成非空字符串str，其中start位置的字符被替换，end位置的字符仍保留。
public void setText(String t)
将文本框的内容设置为特定文本t。
402. public String getText()
返回文本框的内容，返回值为字符串。
public void setEditable(boolean b)
设定文本框内容是否是用户可编辑的。b为false时，表示不可编辑。b为true时，表示可编辑。通常创建一个文本框时，默认为用户可编辑的。
public int getColumns()
返回列数。
public int getRows()
返回行数。
403. 【例6.8】测试TextArea类，用户界面如图6.9所示。源程序代码如下：
//程序文件名UseTextArea.java
import java.awt.*;
import java.applet.*;
import java.applet.Applet;
public class UseTextArea extends Applet
{
String str1 = new String();
String str2 = new String();
int i1,i2,i3;
TextArea t1,t2,t3,t4,t5;//声明对象
404. public void init()
{
t1 = new TextArea();
t2 = new TextArea(2,20);
t3 = new TextArea("文本区域对象3");
t4 = new TextArea("文本区域对象4", 3, 10);
t5 = new TextArea("文本区域对象5", 2, 24, TextArea.SCROLLBARS_BOTH);
this.add(t1);
this.add(t2);
this.add(t3);
this.add(t4);
this.add(t5);
}
412. CheckboxGroup c;
TextArea taText;
Choice chJob;
Button btnOk,btnCancel;
Panel p1,p2,p3,p4,p5,p6,p7,p8,p9;
public void init()
{
lblName = new Label("姓名：");
lblNumber = new Label("身份证号：");
lblSex = new Label("性别");
lblJob = new Label("职业");
lblText = new Label("个性化宣言:");
413. tfName = new TextField(23);
tfNumber = new TextField(20);
taText = new TextArea(10,20);
c = new CheckboxGroup();
chMale = new Checkbox("男",c,true);
chFemale = new Checkbox("女",c,false);
chJob = new Choice();
chJob.add("计算机业");
chJob.add("医生");
chJob.add("教师");
chJob.add("军队");
btnOk = new Button("确定");
btnCancel = new Button("取消");
414. p1 = new Panel();
p2 = new Panel();
p3 = new Panel();
p4 = new Panel();
p5 = new Panel();
p6 = new Panel();
p7 = new Panel(new BorderLayout());
p8 = new Panel();
p9 = new Panel(new BorderLayout());
p1.add(lblName);
p1.add(tfName);
p2.add(lblNumber);
p2.add(tfNumber);
p3.add(lblSex);
421. 6.3.2 JTable
JTable是用于显示和编辑的两维表单元。它的构造函数和常用方法为：
public JTable()
构造一个空的JTable对象。
public void setModel(TableModel dataModel)
为表对象设置数据模型dataModel，并将新数据模型进行注册。
DefaultTableModel是一个实现模型，使用一系列Vector对象实现表单元数据的填充。它的构造函数和常用方法为：
public DefaultTableModel()
构造函数。
422. public void addColumn(Object columnName)
添加一列标题。
public void addRow(Vector rowData)
在模型对象的末尾添加一行Vector对象的数据。
构造Jtable对象的步骤如下：
(1) 构造一个空JTable对象。
JTable tblInf = new JTable();
(2) 构造DefaultTableModel对象，用setModel方法将此对象绑定到JTable上。
DefaultTableModel dtm = new DefaultTableModel();
423. (3) 具体实现DefaultTableModel对象(addColomn方法实现列标题设置，addRow方法实现数据行添加)。
① 初始化Vector列表，添加列标题。
Vector vCdata = new Vector();
vCdata.add("姓名");
vCdata.add("身份证号");
vCdata.add("性别");
tblInf.setModel(dtm);
for (int i=0; i
424. ② 初始化Vector列表，添加行数据。
Vector vRdata = new Vector();
vRdata.add("王飞");
vRdata.add("111122197904290902");
vRdata.add("男");
dtm.addRow(vRdata);
③ JTable没有内嵌滚动功能，将之放入JScrollPane对象中并进行显示。
JScrollPane s = new JScrollPane(tblInf);
getContentPane().add(s,BorderLayout.CENTER);
425. 6.3.3 Jtree
JTree控件用于显示一系列分层数据，即树状显示。它的构造函数和常用方法为：
public void setModel(TreeModel newModel)
设置提供数据的TreeModel模型。TreeModel是一个接口，接口内实现的类为DefaultTreeModel类，DefaultTreeModel是一个使用TreeNodes的简单树数据模型，下面给出它的构造函数。
public DefaultTreeModel(TreeNode root)
426. 创建根结点为root的树，其中每个结点都可以有子结点。TreeNode是一个接口，它包含一个DefaultTreeNode类，DefaultTreeNode类表达了一个树型数据结构中具有一般意义的结点。每个树结点至多有一个父结点，0个或多个子结点。其构造函数为：
public DefaultMutableTreeNode(Object userObject)
创建一个无父结点、无子结点的树结点。例如
public DefaultMutableTreeNode f = new DefaultMutableTreeNode("个人信息");
public add(MutableTreeNode newChild)
将newChild结点添加到树结点的末尾，使之称为当前结点的子结点。
427. 创建树结构的步骤如下：
(1) 构建JTree对象。
JTree tree = new JTree();
(2) 构造DefaultMutableTreeModel对象，使用SetModel方法将DefaultMutableTreeModel对象绑定到Jtree对象。
tree.setModel(new DefaultTreeModel(root));
428. (3) 构造树。
① 构造根结点。
DefaultMutableTreeNode root;
② 构造分支结点，添加到根结点。
DefaultMutableTreeNode NodeName, NodeNumber, NodeSex;
NodeName = new DefaultMutableTreeNode("姓名");
NodeNumber = new DefaultMutableTreeNode("身份证号");
NodeSex = new DefaultMutableTreeNode("性别");
root.add(NodeName);
root.add(NodeNumber);
root.add(NodeSex);
429. ③ 添加叶子结点并添加到分支结点。
leafName = new DefaultMutableTreeNode("王飞");
leafNumber = new DefaultMutableTreeNode("111122197904290902");
leafSex = new DefaultMutableTreeNode("男");
NodeName.add(leafName);
NodeNumber.add(leafNumber);
NodeSex.add(leafSex);
430. ④ 使用DefaultMutableTreeModel的构造函数，将根结点作为参数构造树结构中的数据。
DefaultTreeModel dTree = new DefaultTreeModel(root);
⑤ JTree没有内嵌的滚动属性，较大的树状结构可以显示在JScrollPane上。
JScrollPane scroll = new JScrollPane(tree);
getContentPane().add(scroll);
432. import javax.swing.ButtonGroup;
public class TestSwing extends JFrame
{
JLabel lblName = new JLabel("姓名：");
JLabel lblNumber = new JLabel("身份证号");
JLabel lblSex = new JLabel("性别");
JLabel lblJob = new JLabel("职业");
JLabel lblText = new JLabel("个性化宣言");
JTextField tfName = new JTextField(23);
JTextField tfNumber = new JTextField(20);
JTextArea taText = new JTextArea(5,20);
JRadioButton jMale = new JRadioButton("男");
433. JRadioButton jFemale = new JRadioButton("女");
ButtonGroup group = new ButtonGroup();
JComboBox cmbJob = new JComboBox();
JButton btnOk = new JButton("确定");
JButton btnDisplay = new JButton("取消");
JTable tblInf = new JTable();
DefaultTableModel dtm = new DefaultTableModel();
//布局设置
JTree tree = new JTree();
JPanel p1 = new JPanel();
JPanel p2 = new JPanel();
434. JPanel p3 = new JPanel();
JPanel p4 = new JPanel();
JPanel p5 = new JPanel();
JPanel p6 = new JPanel();
JPanel p7 = new JPanel(new BorderLayout());
JPanel p8 = new JPanel();
JPanel p9 = new JPanel(new BorderLayout());
public TestSwing()
{
group.add(jMale);
group.add(jFemale);
496. 7.2.4 调整事件(AdjustmentEvent)
调整事件包含一个事件，即ADJUSTMENT_VALUE_CHANGED事件，当操纵滚动条改变其滑块位置时引发动作。AjustEvent的方法如下：
public Adjustable getAdjustable()
返回引发事件的对象。
public int getValue()
返回调整事件中的当前值。
497. public void addAdjustmentListener(AdjustmentListener l)
添加调整监听者来接收来自对象的AdjustmentEvent实例。
public interface AdjustmentListener extends EventListener
接收调整事件的监听接口，有一个方法：
public void adjustmentValueChanged(AdjustmentEvent e)
可在调整改变时调用这个值。
498. 【例7.5】测试调整事件。设置一个水平滚动条，取值为1～36，随着滑块的变化，滚动条的值将显示在文本区域中，并且字体大小也会跟随变化。源程序代码如下：
//程序文件名UseAdjustmentEvent.java
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.applet.Applet;
public class UseAdjustmentEvent extends Applet implements AdjustmentListener
{
499. Scrollbar s;
TextArea txtValue;
Panel p;
public void init()
{
s = new Scrollbar(Scrollbar.HORIZONTAL,0,1,10,36);
//添加监听者
s.addAdjustmentListener(this);
txtValue = new TextArea(5,25);
//界面布局
p = new Panel(new BorderLayout());
p.add(s,BorderLayout.NORTH);
500. p.add(txtValue,BorderLayout.SOUTH);
add(p);
}
public void start()
{
}
public void adjustmentValueChanged(AdjustmentEvent e)
{
int value;
Font oldF;
if(e.getAdjustable() == s)
{
//得到滚动条的值
505. 监听者中有具体的方法分别针对上述具体的鼠标事件，系统能够自动分辨鼠标事件的类型并调用相应的方法，所以只需编码实现相应的代码就可以了。
public int getButton()
返回哪个按钮发生变化。
public int getClickCount()
返回与这个事件相关的鼠标单击的次数。
public Point getPoint()
返回同源部件相对的事件发生的x、y位置。
public int getX()
返回同源部件相对的事件发生的x位置。
public int getY()
返回同源部件相对的事件发生的y位置。
506. 【例7.6】测试按钮和画布的鼠标事件，包括单击、按下、进入和退出等。鼠标事件的演示如图7.12和7.13所示。源程序代码如下：
//程序文件名UseMouseEvent.java
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.applet.Applet;
public class UseMouseEvent extends Applet implements MouseListener, MouseMotionListener
{
507. Button btn;
public void init()
{
btn = new Button("演示鼠标事件");
add(btn);
//给按钮添加鼠标事件和鼠标移动事件
btn.addMouseListener(this);
btn.addMouseMotionListener(this);
//给画布添加鼠标事件和鼠标移动事件
this.addMouseListener(this);
this.addMouseMotionListener(this);
}
508. //单击事件
public void mouseClicked(MouseEvent e)
{
Point p = new Point();
if(e.getSource() == btn)
{
if(e.getClickCount() == 1)
{
btn.setLabel("单击鼠标");
}
else if(e.getClickCount() == 2)
{
btn.setLabel("双击鼠标");
}
516. 7.2.6 键盘事件(KeyEvent)
键盘事件有三个：键盘按键按下，按键释放，按键被敲击。常用方法如下：
public char getKeyChar()
返回事件中键的字符。
public int getKeyCode()
返回整数键码。
public static String getKeyText(int keyCode)
返回描述这个键码的字符串，例如“HOME”、“F1”或者“A”等。
public interface KeyListener extends EventListener
用来接收键盘事件。使用方法addKeyListener注册。
517. 针对键盘的三个事件接口提供相应的方法进行处理，具体方法如下：
public void keyPressed(KeyEvent e)
按键时引发事件处理。
public void keyReleased(KeyEvent e)
释放键时引发事件处理。
public void keyTyped(KeyEvent e)
键入键时引发事件处理。
527. 2. 实现接口Runnable
public interface Runnable
Runnable接口可以由任意试图实现线程机制的类来实现。接口包含一个run方法。
public void run()
对象实现Runnable接口时，创建一个线程，启动线程导致对象run方法的调用。
实现接口Runnable进行多线程设计的方法较为常用。下面给出一个例子。
528. 【例7.8】编写Applet，实现Runnable接口进行简单的动画演示：三幅图片依次上移，如图7.15所示。源程序代码如下：
//程序文件名为UseRunnable.java
import java.awt.*;
import java.applet.Applet;
public class UseRunnable extends Applet implements Runnable
{
Thread t;
Image imgs[];
int high,h1,h2,h3;
public void init()
{
529. high = getHeight()/3;
h1 = high;
h2 = high * 2;
h3 = high * 3;
imgs = new Image[3];
for (int i = 0; i < 3; i ++)
{
imgs[i] = getImage(getDocumentBase(),"image" + (i+1) + ".gif");
}
}
public void start()
{
530. t = new Thread(this);
t.start();
}
public void stop()
{
t = null;
}
//实现接口的run方法，获得动画效果
public void run()
{
while( t != null)
{
try
{
539. 8.2 基本输入输出流8.2.1 InputStream类
InputStream是抽象类，代表字节输入流的所有类的超类。这个类本身不能使用，只能通过继承它的具体类完成某些操作。它的常用方法如下：
public int available() throws IOException
返回流中可用的字节数。
public void close() throws IOException
关闭流并释放与流相关的系统资源。用户使用完输入流时，调用这个方法。
public void mark(int readlimit) throws IOException
输入流中标志当前位置。
540. public boolean markSupported() throws IOException
测试流是否支持标志和复位。
public abstract int read() throws IOException
读取输入流中的下一个字节。
public int read(byte[] b) throws IOException
从输入流中读取字节并存储到缓冲区数组b中，返回读取的字节数，遇到文件结尾返回-1。
541. public int read(byte[] b, int off, int len) throws IOException
从输入流中读取len个字节并写入b中，位置从off开始。返回写的字节数。
public void reset() throws IOException
重定位到上次输入流中调用的位置。
public long skip(long n) throws IOException
跳过输入流中n个字节，返回跳过的字节数，遇到文件结尾返回-1。
542. 8.2.2 OutputStream类
OutputSteam是抽象类，代表输出字节流的所有类的超类。
public void close() throws IOException
关闭输出流，释放与流相关的系统资源。
public void flush() throws IOException
清洗输出流，使得所有缓冲区的输出字节全部写到输出设备中。
public void write(byte[] b) throws IOException
从特定字节数组b将b数组长度个字节写入输出流。
public void write(byte[] b, int off, int len) throws IOException
从特定字节数组b将从off开始的len个字节写入输出流。
public abstract void write(int b) throws IOException
向输出流写一个特定字节。
543. 8.2.3 系统输入输出对象
Java定义了两个流对象System.in和System.out，允许用户在自己的程序中直接使用。System.in对象允许用户从键盘读取数据，System.out对象可以产生屏幕输出。
【例8.1】使用流对象System.in和System.out，接收用户从键盘上输入的数据并将数据输出到屏幕上。测试情况如图8.1所示。源程序代码如下：
//程序文件名为SystemIO.java
import java.io.*;
public class SystemIO
{
544. public static void main(String[] args)
{
int bytes = 0;
byte buf[] = new byte[255];
System.out.println("\n请输入任意文本：");
try
{
//接收输入字符串
bytes = System.in.read(buf,0,255);
System.out.println("这是你输入的文本行：");
String inStr = new String(buf,0,bytes);
553. 【例8.3】使用FileOutputStream对象，打开一个文件，写入一行文本，然后追加一行从键盘接收的字符串(如图8.3的上部分所示)，文件内容如图8.3的下部分所示。源程序代码如下：
//程序文件名为UseFileOutputStream.java
import java.io.*;
public class UseFileOutputStream
{
public static void main(String[] args)
{
byte buf[] = new byte[255];
byte bufIn[] = new byte[255];
562. 【例8.5】随机访问文件，将文件内容输出，并写入两个字符“O”、“K”。文件内容显示如图8.5的下半部分所示，若文件内容直接输出到屏幕上，则出现如图8.5上半部分所示的乱码问题，添加一个parseChinese方法后，得以修正，输出结果如图8.6所示。源程序代码如下：
//程序文件名为UseRandom.java
import java.io.*;
public class UseRandom
{
public static void main(String[] args)
{
563. try
{
//构建随机访问文件对象
RandomAccessFile f = new RandomAccessFile("Hello.txt","rw");
//得到文件指针和长度
long flag = 0;
long len = f.length();
//字符处理后输出
while(flag
564. String s = f.readLine();
System.out.println(parseChinese(s));
flag = f.getFilePointer();
}
//末尾写入字符
f.writeChar('O');
f.writeChar('K');
}
catch(IOException e)
{
System.out.println(e.getMessage());
}
}
565. //解决中文转换问题
public static String parseChinese(String inStr)
{
String s = null;
byte temp[];
if (inStr == null)
{
return new String("");
}
try
{
temp=inStr.getBytes("iso-8859-1");
566. s = new String(temp);
}
catch(UnsupportedEncodingException e)
{
System.out.println (e.toString());
}
return s;
}
};
567. 图8.5 文件内容及屏幕输出
568. 图8.6 字符处理后的屏幕输出
569. 8.4 对 象 流8.4.1 ObjectInputStream类
ObjectInputStream(对象输入流)可读取使用对象输出流写入的原始数据和类型，与文件输入输出流一起可以实现对象的持久性存储。它的构造函数和一个读对象的方法如下：
public ObjectInputStream(InputStream in) throws IOException
从特定的输入流中读取并创建一个对象输入流。
Public Object readObject()
从对象输入流中读取对象。
571. 【例8.6】将日期对象和向量对象写入文件，然后从文件中读出并输出到屏幕上，输出结果如图8.7所示。要求向量对象含有三个值“语文”、“数学”和“物理”。源程序代码如下：
//程序文件名为UseStream.java
import java.io.*;
import java.util.*;
public class UseStream extends Object
{
public static void main(String[] args)
{
572. //构建Vector对象
Vector v = new Vector();
v.add("语文");
v.add("数学");
v.add("物理");
try
{
//文件处理对象
File f = new File("temp.txt");
FileOutputStream fOut = new FileOutputStream(f);
ObjectOutputStream objOut = new
600. PreparedStatement pstmt = con.prepareStatement("UPDATE EMPLOYEES
SET SALARY = ? WHERE ID = ?");
pstmt.setBigDecimal(1, 10000.00)
pstmt.setInt(2, 111);
pstmt.executeUpdate();
类PreparedStatement提供的常用方法如下：
public boolean execute() throws SQLException
执行PreparedStatement对象中的任一类型的SQL语句。如果返回true，则调用getResultSet方法取得ResultSet集；如果返回false，则调用getUpdateCount方法获得更新数。
601. public ResultSet executeQuery() throws SQLException
执行SQL查询，并返回查询产生的结果集。
public int executeUpdate() throws SQLException
执行对象中的SQL语句。如果是一些更新操作，如插入(INSERT)、修改(UPDATE)和删除(DELETE )等，则返回操作的个数。
602. 常用的设置方法为：
public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException
在第parameterIndex位置设置BigDecimal型x。
public void setBoolean(int parameterIndex, boolean x) throws SQLException
在第parameterIndex位置设置布尔型x。
public void setByte(int parameterIndex, byte x) throws SQLException
在第parameterIndex位置设置字节型x。
603. public void setBytes(int parameterIndex, byte[] x) throws SQLException
在第parameterIndex位置设置字节数组型x。
public void setDouble(int parameterIndex, double x) throws SQLException
在第parameterIndex位置设置双精度型x。
public void setFloat(int parameterIndex, float x) throws SQLException
在第parameterIndex位置设置单精度型x。
public void setInt(int parameterIndex, int x) throws SQLException
在第parameterIndex位置设置整型x。
604. public void setLong(int parameterIndex, long x) throws SQLException
在第parameterIndex位置设置长整型x。
public void setNull(int parameterIndex, int sqlType) throws SQLException
在第parameterIndex位置设置为空x。
public void setObject(int parameterIndex, Object x) throws SQLException
在第parameterIndex位置设置对象x。
public void setShort(int parameterIndex, short x) throws SQLException
在第parameterIndex位置设置短整型x。
605. void setString(int parameterIndex, String x) throws SQLException
在第parameterIndex位置设置字符串型x。
public void setTime(int parameterIndex, Time x) throws SQLException
在第parameterIndex位置设置时间型x。
public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException
在第parameterIndex位置设置时间戳型x。
606. 9.2.6 ResultSet
Result对象是指一张数据表，代表数据库结果集，通常是通过执行查询数据库的语句而产生的。ResultSet对象持有一个游标，该游标指向当前数据行。初始化时游标定位到第一行之前。Next方法将游标移动到下一行，当对象行完时，返回错误。通常使用循环来完成每行的遍历。
public boolean next() throws SQLException
读行，返回true；行数完，则返回false。
609. public BigDecimal getBigDecimal(int columnIndex) throws SQLException
public boolean getBoolean(int columnIndex) throws SQLException
public byte getByte(int columnIndex) throws SQLException
public byte[] getBytes(int columnIndex) throws SQLException
public double getDouble(int columnIndex) throws SQLException
public float getFloat(int columnIndex) throws SQLException
public Int getInt(int columnIndex) throws SQLException
public Long getLong(int columnIndex) throws SQLException
610. public Object getObject(int columnIndex) throws SQLException
public short getShort(int columnIndex) throws SQLException
public String getString(int columnIndex) throws SQLException
public java.sql.Time getTime(int parameterIndex, Time x) throws SQLException
public java.sql.TimeStamp getTimestamp(int columnIndex) throws SQLException
611. 以字段名称为参数的读取方法如下：
public BigDecimal getBigDecimal(String columnName) throws SQLException
public boolean getBoolean(String columnName) throws SQLException
public byte getByte(String columnName) throws SQLException
public byte[] getBytes(String columnName) throws SQLException
public double getDouble(String columnName) throws SQLException
public float getFloat(String columnName) throws SQLException
public Int getInt(String columnName) throws SQLException
612. public Long getLong(String columnName) throws SQLException
public Object getObject(String columnName) throws SQLException
public short getShort(String columnName) throws SQLException
public String getString(String columnName) throws SQLException
public java.sql.Time getTime(String columnName) throws SQLException
public java.sql.TimeStamp getTimestamp(String columnName) throws SQLException
667. 这个默认的java.policy文件对应的源文件如下：
// Standard extensions get all permissions by default
grant codeBase "file:${java.home}/lib/ext/*" {
permission java.security.AllPermission;
};
// default permissions granted to all domains
668. grant {
// Allows any thread to stop itself using the java.lang.Thread.stop()
// method that takes no argument.
// Note that this permission is granted by default only to remain
// backwards compatible.
// It is strongly recommended that you either remove this permission
// from this policy file or further restrict it to code sources
// that you specify, because Thread.stop() is potentially unsafe.
669. // See "http://java.sun.com/notes" for more information.
permission java.lang.RuntimePermission "stopThread";
// allows anyone to listen on un-privileged ports
permission java.net.SocketPermission "localhost:1024-", "listen";
// "standard" properies that can be read by anyone
permission java.util.PropertyPermission "java.version", "read";
permission java.util.PropertyPermission "java.vendor", "read";
permission java.util.PropertyPermission "java.vendor.url", "read";
685. (1) 客户端请求Socket的步骤如下：
① 建立客户端Socket连接；
② 得到Socket的读和写的流；
③ 利用流；
④ 关闭流；
⑤ 关闭Socket。
使用一个服务器端的Socket请求比使用一个客户端Socket请求要麻烦一些。服务器并不是主动地建立连接。相反地，服务器被动地监听客户端的连接请示，然后给它们服务。
686. (2) 服务器端Socket要完成以下的基本的步骤：
① 建立一个服务器Socket并开始监听；
② 使用accept()方法取得新的连接；
③ 建立输入和输出流；
④ 在已有的协议上产生会话；
⑤ 关闭客户端流和Socket；
⑥ 回到②或者转到⑦；
⑦ 关闭服务器Socket。
690. public String getHostAddress()
返回IP地址的字符串格式。
public String getHostName()
返回IP地址的主机名。
public static InetAddress getLocalHost() throws UnknownHostException
以InetAddress类封装的格式返回本机地址。
public String toString()
转换成字符串格式。
691. 【例11.1】InetAddress对象应用的测试。获取本机地址并转换成字符串输出，输出本地主机名和IP地址以及通过局域网内计算机的名字得到它的IP地址。程序源代码如下：
//程序文件名FindHost.java
import java.net.*;
public class FindHost
{
public static void main(String[] args)
{
try
{
695. 11.1.2 Socket类
Socket类用来实现客户端的Socket。常用的构造方法有以下三种：
public Socket()
创建一个无连接的Socket。
public Socket(InetAddress address, int port)
创建流式Socket，将它连接到InetdAdress类指明的主机和port端口上。
public Socket(String host, int port)
创建流式Socket并将它连接到特定host的特定port端口上。
697. (2) 初始化字节流。连接建立后的数据传输通过数据输入输出流实现，写文件又通过文件输入输出流来实现。各种流对象的初始化如下：
DataOutputStream outbound = new DataOutputStream(clientSocket.getOutputStream());
DataInputStream inbound = new DataInputStream(clientSocket.getInputStream());
InputStreamReader inS = new InputStreamReader(inbound);
File f = new File("xjtu.html");
FileOutputStream fOut = new FileOutputStream(f);
PrintStream p = new PrintStream(fOut);
723. 11.2 UDP Sockets 基 础 数据报Socket是包发送服务的接收和发送点，它接收和发送的每个包都是单独访问和路由的。从一个机器发送到另一个机器的包可能有不同的路由，而且可能以任意顺序到达。数据报Socket构造函数有三个，分别如下：
public DatagramSocket()
构建数据报Socket，绑定到本地主机上的任意端口。
public DatagramSocket(int port)
构建一个数据报Socket，将它绑定到指定的port端口。
724. public DatagramSocket(int port, InetAddress laddr)
构建一个数据报Socket，绑定到指定的laddr本地地址和port端口。
数据报可以通过connect方法建立连接，也可以直接使用send方法发送数据，使用receive方法接收数据，方法如下：
public void connect(InetAddress address, int port)
将建立的数据报Socket连接到远程地址address的port端口。
public void receive(DatagramPacket p)
接收数据报包p。
public void send(DatagramPacket p)
发送数据报包p。
725. 11.2.1 DatagramPacket类
从TCP的例子程序可以看出TCP Socket发送的数据是流式数据，而UDP Socket发送的数据是分块的数据包，这就用到DatagramPacket类。数据报Socket传输数据前首先构造数据报包，然后传输这个数据报包。数据报包的构造函数如下：
DatagramPacket(byte[] buf, int length)
构建数据报包，接收length长度的包并放入buf。
DatagramPacket(byte[] buf, int length, InetAddress address, int port)
构建数据报包，发送length长度的包到address指定的主机的port端口。
726. 【例11.4】客户端循环发送数据“Client:Hello”到服务器端，服务器端截取字符串Hello输出，并将源字符串返回给客户端。
1. 程序建立的步骤
(1) 服务器端程序建立的步骤。
●建立数据报Socket。
DatagramSocket mysock = new DatagramSocket(1719);
● 建立数据报包，准备接收。
byte[] buf = new byte[1024];
DatagramPacket p = new DatagramPacket(buf,buf.length);
●接收或者发送。
mysock.receive(p);
...
mysock.send(p);
727. (2) 客户端程序建立的步骤。
● 建立数据报Socket。
DatagramSocket mysock = new DatagramSocket();
● 建立数据报包，准备接收。
DatagramPacket p = new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),1719);
● 接收或者发送。
mysock.receive(p);
...
mysock.send(p);
728. 2. 服务器端源程序
//程序文件名为DatagramServer.java
import java.net.*;
public class DatagramServer extends Object
{
public static String ReadRAS(String str)
{
int indexstart = str.indexOf(':');
int indexend = str.indexOf("o");
String Msg = "Server:" +
729. str.substring(indexstart+1,indexend+1);
return Msg;
}
public static void main(String[] args)
{
try
{
DatagramSocket mysock = new DatagramSocket(1719);
byte[] buf = new byte[1024];
DatagramPacket p = new DatagramPacket(buf,buf.length);
while(true)
{
730. mysock.receive(p);
System.out.println("RECEIVE:"+ new String(p.getData()).trim());
System.out.println(ReadRAS(new String(p.getData()).toString()));
mysock.send(p);
System.out.println("SEND:"+ new String(p.getData()).trim());
}
}
catch(Exception e)
{
System.out.println(e.getMessage());
}
}
}
731. 3. 客户端源程序
//程序文件名为DatagramClient.java
import java.net.*;
import java.io.*;
public class DatagramClient extends Object
{
public static void main(String[] args)
{
try
{
732. DatagramSocket mysock = new DatagramSocket();
byte[] buf = new byte[1024];
String sendData = new String("Client:Hello");
buf = sendData.getBytes();
DatagramPacket p = new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),1719);
while(true)
{
mysock.send(p);
System.out.println("SEND:"+ new String(p.getData()).trim());
744. PlaybackAudio(int RTPPort)
{
this.RTPPort = RTPPort;
}
public void start()
{
thread = new Thread(this);
thread.setName("PlaybackAudio");
thread.start();
}
public void run()
{
AudioFormat format =new
745. AudioFormat(8000,16,2,true,true);//设置音频格式
DataLine.Info info = new DataLine.Info(SourceDataLine.class,format);//设置数据线
try
{
line = (SourceDataLine)AudioSystem.getLine(info);//获得源数据线信息
line.open(format, bufSize);//打开源数据线
}
catch (LineUnavailableException ex)
{
return;
}
746. byte[] data = new byte[MAXBUFFER];
int numBytesRead = 0;
line.start();//启动源数据线
try
{
s = new DatagramSocket(RTPPort);
}
catch (IOException e)
{
return;
}
while (thread != null)
{
748. s.close();//关闭数据报Socket
if (thread != null)
{
line.drain();
}
line.stop();
line.close();
line = null;
}
}
//音频采集类
class CaptureAudio extends Thread implements Runnable
{
749. TargetDataLine line;
Thread thread;
DatagramSocket s;
DatagramPacket p;
String SERVER_NAME;
int RTPPort;
//构造函数：取得远程服务器名和端口，用于发送数据
CaptureAudio(String SERVER_NAME, int RTPPort)
{
this.SERVER_NAME = SERVER_NAME;
this.RTPPort = RTPPort;
}
public void start()
{
750. thread = new Thread(this);
thread.setName("CaptureAudio");
thread.start();
}
public void run()
{
AudioFormat format =new AudioFormat(8000,16,2,true,true);//AudioFormat(float sampleRate,
int sampleSizeInBits, int channels, boolean signed, boolean bigEndian)
DataLine.Info info = new DataLine.Info(TargetDataLine.class,format);
751. try
{
line = (TargetDataLine)AudioSystem.getLine(info);//设置目标数据线信息
line.open(format,line.getBufferSize()); //打开目标数据线
}
catch (Exception ex)
{
return;
}
byte[] data = new byte[MAXBUFFER];
int numBytesRead=0;
line.start(); //启动目标数据线
try
752. {
//构造数据报Socket
s = new DatagramSocket();
}
catch (Exception ex)
{
return;
}
while (thread != null)
{
try
{
numBytesRead = line.read(data, 0, MAXBUFFER);//读取采集数据
753. p = new DatagramPacket(data, numBytesRead,
InetAddress.getByName(SERVER_NAME), RTPPort);
s.send(p);//发送数据
}
catch (Exception ex)
{
break;
}
}
s.close();
line.stop();
line.close();
line = null;
}
}
754. //主函数
public static void main(String args[])
{
SERVER_NAME = new String(args[0]);
TalkSelf t = new TalkSelf();
Frame f = new Frame();
f.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
758. 这里侧重于处理HTML文本的情况，JEditorPane类的构造函数和处理HTML常用到的方法如下：
public JEditorPane()
构建一个空JeditorPane。
public JEditorPane(String url)
构建一个基于URL声明的字符串的JEditorPane。
public JEditorPane(URL initialPage)
构建一个基于特定URL对象的JeditorPane。
public void addHyperlinkListener(HyperlinkListener listener)
添加一个超链接监听者，通知任何变化，例如选中一个链接并进入时。
759. public void setPage(String url)
设置显示的URL页面。
字符串url 表示页面的URL地址。
public void setPage(URL page)
设置显示的URL对象代表的page页面。
public void setText(String t)
设置指定t内容。
public void setEditable(boolean b)
b为true时，可编辑；b为false时，不可编辑，但只有当b为false时，才可以响应超链接事件。
760. 11.3.2 HyperlinkListener和HyperlinkEvent
HyperlinkListener是超链接事件监听者接口，继承于EventListener接口，只有一个事件：超链接更新，当点击链接或者进入链接时引发。这个事件的方法为：
public void hyperlinkUpdate(HyperlinkEvent e)
当更新一个超链接时调用此方法。
HyperlinkEvent是超链接事件，用于通知有关超文本链接的变化，它有两个常用方法，一个方法用来获得事件的类型，另一个方法是获得超链接指向的URL网址。
public HyperlinkEvent.EventType getEventType()
775. URL类用来定位WWW上的资源，从而进行处理，如读取网页等。它的构造函数以及一系列常用的方法如下：
public URL(String spec)
从指定的字符串spec创建一个URL对象。
public URL(String protocol, String host, int port, String file)
从指定的protocol协议、host主机、port端口号和file文件名创建一个URL对象。
public URL(String protocol, String host, String file)
从指定的protocol协议、主机名host和文件名file创建一个URL对象。
776. public Object getContent()
得到URL的内容。
public String getContentType()
返回网页内容类型，普通网页为“text/html”。
public String getFile()
得到URL文件名。
public String getHost()
得到URL的主机名。
public String getPath()
得到URL的路径部分。
public int getPort()
得到URL的端口号。
777. public String getProtocol()
得到URL的协议名。
public String getQuery()
得到URL的查询部分。
public URLConnection openConnection()
返回一个URLConnection对象，代表到URL远程对象的连接。
public InputStream openStream()
打开到URL的连接，返回读取连接的输入流。
public String toExternalForm()
构建代表URL对象的字符串。
public String toString()
转换成字符串，覆盖来自对象的toString()方法。
795. String contentType=conn.getContentType();
//建立文件对象和读取的流对象
File f = new File("result.html");
FileOutputStream fOut = new FileOutputStream(f);
PrintWriter p = new PrintWriter(fOut);
if(contentType.toLowerCase().startsWith("text"))
{
BufferedReader in = new BufferedReader(new InputStreamReader(theData));
String line;
while ((line = in.readLine())!=null)
{
828. 下面的两个方法用来返回选择键值的个数和键值集合。
public abstract int select() throws IOException
返回键值的个数。
public abstract Set selectedKeys()
返回选择器选中的键值集合。
对于一个Socket通道，只有将它本身发生的事件(如监听、连接、读、写等)在选择器上进行注册，才可以被选择器识别，从而进行处理，这个注册就用到SelectionKey类。SelectionKey类包括四个注册值，将通道支持的事件注册到相应的选择器上。它还提供四个判断键值状态的方法，从而进行相应的事件处理，如表12.3所示。
860. PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
Date now = new Date();
out.println("Hello, now time is: " + now);
out.close();
}//End of While
}//End of While
}//End of main
}
861. 为了服务器与客户端能够进行通信，对例12.7的客户端程序进行修改，将InetSocketAddress对象sockAddr中的端口号改成4321，使得客户端请求的端口号与此服务器监听的端口号一致，即将
InetSocketAddress sockAddr = new InetSocketAddress(host, 8080);
改为
InetSocketAddress sockAddr = new InetSocketAddress(host, 4321);
然后重新编译，生成类文件。
启动两个命令提示符，其中一个为运行命令“java Server”，另一个为键入命令“java NBReadURL”，可以看见如图12.6的通信结果。客户端显示服务器发送的一段时间信息。如果希望在服务器端显示内容，还需修改服务器程序，注册服务器通道的读、写事件。
881. 2. 服务器端
服务器端Servlet收集用户界面输入的数据(见图13.3)，然后按行返回这些内容，结果如图13.4所示。注意传输过程中中文字符可能会有出错情况，因此再添加一个转换字段，使得Servlet能够正确打印输出。
//程序文件名：UserServlet.java
package user;
import java.io.*;
import javax.Servlet.*;
import javax.Servlet.http.*;
public class UserServlet extends HttpServlet
{
882. String name,number,sex,job,ta;
public void init() throws ServletException
{
super.init();
name = new String();
number = new String();
sex = new String();
job = new String();
ta = new String();
}
//解决中文转换问题
public String parseChinese(String inStr)
{
883. String s = null;
byte temp[];
if (inStr == null)
{
//System.out.println("Warn:Chinese null founded!");
return new String("");
}
try
{
temp=inStr.getBytes("iso-8859-1");
s = new String(temp);
}
catch(UnsupportedEncodingException e)
{
884. System.out.println (e.toString());
}
return s;
}
public void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException
{
//获取用户界面输入的值
name = req.getParameter("name");
number = req.getParameter("number");
sex = req.getParameter("sex");
job = req.getParameter("job");
885. ta = req.getParameter("ta");
//进行输出
res.setContentType("text/html; charset=GB2312");
PrintWriter out = res.getWriter();
out.println("
904. TextArea taResults;
Button btnExecute;
URL chatURL;
public void init()
{
Panel pa = new Panel();
pa.setLayout(new FlowLayout(FlowLayout.LEFT));
pa.add(new Label("查询串:"));
tfQuery = new TextField("SELECT number,code,score from chengji WHERE code='3001'",50);
905. pa.add(tfQuery);
btnExecute = new Button("查询");
btnExecute.addActionListener(this);
pa.add(btnExecute);
add("North",pa);
taResults = new TextArea(30,60);
add("Center",taResults);
chatURL = getCodeBase();
}
public void actionPerformed(ActionEvent evt)
{
939. 14.3.2 相关类
1. DocumentBuilderFactory类
public abstract class DocumentBuilderFactory extends Object
定义工厂API，使得应用程序得到解析器从XML文档中产生的DOM对象树。
public static DocumentBuilderFactory newInstance() throws FactoryConfigurationError
得到DocumentBuilderFactory的一个实例，这个实例某个时刻只能用于一个线程。
public abstract DocumentBuilder newDocumentBuilder() throws ParserConfigurationException
使用当前配置的方法创建一个新的DocumentBuilder的实例。
940. 2. DocumentBuilder类
public abstract class DocumentBuilder extends Object
定义从XML文档得到DOM文档的API。
public abstract Document newDocument()
得到DOM文档对象的一个新实例，用来构建DOM树。
public Document parse(File f) throws SAXException, IOException
解析给定的XML文档f，返回DOM文档对象。
941. 3. Document类
public interface Document extends Node
Document接口代表整个XML文档。
public Element createElement(String tagName) throws DOMException
创建指定的类型的元素tagName。
public Text createTextNode(String data)
使用给定的data字符串创建节点元素的值。
942. 4. Element类
public interface Element extends Node
Element接口代表XML文档中的一个元素。
public NodeList getElementsByTagName(String name)
返回给定的name元素下面的所有节点列表，以前向遍历的方式给出。
943. 5. NodeList类
NodeList接口给出一个节点集合，有以下两个方法：
public int getLength()
返回节点的个数。
public Node item(int index)
返回第index个节点。
948. //初始化界面对象
lblName = new Label("姓名：");
lblNumber = new Label("身份证号：");
lblSex = new Label("性别");
lblJob = new Label("职业");
lblText = new Label("个性化宣言:");
tfName = new TextField(23);
tfNumber = new TextField(20);
taText = new TextArea(10,20);
c = new CheckboxGroup();
chMale = new Checkbox("男",c,true);
chFemale = new Checkbox("女",c,false);
chJob = new Choice();
949. chJob.add("计算机业");
chJob.add("医生");
chJob.add("教师");
chJob.add("军队");
btnOk = new Button("确定");
btnDisplay = new Button("显示");
p1 = new Panel();
p2 = new Panel();
p3 = new Panel();
p4 = new Panel();
p5 = new Panel();
p6 = new Panel();
950. p7 = new Panel(new BorderLayout());
p8 = new Panel();
p9 = new Panel(new BorderLayout());
//设置界面
p1.add(lblName);
p1.add(tfName);
p2.add(lblNumber);
p2.add(tfNumber);
p3.add(lblSex);
p3.add(chMale);
p3.add(chFemale);
955. DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.newDocument();
//创建元素
Element root = doc.createElement("UserData");
Element eName = doc.createElement("Name");
Element eNumber = doc.createElement("Number");
Element eSex = doc.createElement("Sex");
Element eJob = doc.createElement("Job");
Element eText = doc.createElement("Text");
//添加节点
