第二次实验：Java语言基础练习
一、实验目的
1． 了解 Java 的数据类型
2．掌握各种变量的声明方式及其使用范围。
3．理解 Java 程序语法结构，掌握顺序结构、选择结构和循环结构语法的程序设计方法。
二、实验要求
1. 编写一个声明 Java 不同数据类型变量的程序。
2. 编写一个关于变量的使用范围的程序。
3. 编写使用选择结构的程序。
4. 编写使用循环结构的程序。
三、实验内容
（一） 声明不同数据类型的变量
1．编写声明不同数据类型变量的程序文件 KY2_1.java，源代码如下。
public class KY2_1 {
public static void main(String args[]) {
byte b=0x55;
short s=0x55ff;
int i=1000000;
long l=0xffffL;
char c='a';
float f=0.23F;
double d=0.7E-3;
boolean B=true;
String S="这是字符串类数据类型";
System.out.println("字节型变量 b = "+b);
System.out.println("短整型变量 s = "+s);
System.out.println(" 整型变量 i = "+i);
System.out.println("长整型变量 l = "+l);
System.out.println("字符型变量 c = "+c);
System.out.println("浮点型变量 f = "+f);
System.out.println("双精度变量 d = "+d);
System.out.println("布尔型变量 B = "+B);
System.out.println("字符串类对象 S = "+S);
}
}
2． 编译并运行该程序
3. 把程序的输出结果写在实验报告中。如果不给上面程序中的变量赋初始值的话，看看该程序是否还能正确运行？如果不可以，请指出为什么？
4. 试编写数据类型转换程序。讨论自动类型转换和强制类型转换的实例。
（二） 了解变量的使用范围
1．建立 KY2_2.java 文件，通过本程序了解变量的使用范围，源代码如下。
public class KY2_2 {
static int i=10;
public static void main(String args[]) {
{
int k=10;
System.out.println("i="+i);
System.out.println("k="+k);
}
System.out.println("i="+i);
System.out.println("k="+k);
}
}
2．编译 KY2_2.java
看看这个程序是否会出错？为什么会出现编译错误，请在试验报告中给出理由！
3．修改上面的程序，让它能正确运行。
4．把修改后的源程序以及程序的输出结果写在实验报告中。
5. 试着自己编写程序体会局部变量和成员变量初始化的问题。
思考：KY2_2.java 程序说明了什么问题？
（三） 使用选择语句
1. 程序功能：使用 switch 语句在不同温度时显示不同的解释说明。
2. 程序源代码如下。
class KY2_3{
public static void main(String args[]){
int c=18;
switch (c<10?1:c<25?2:c<35?3:4){
case 1:
System.out.println(" "+c+"℃ 有点冷。要多穿衣服。");
case 2:
System.out.println(""+c+"℃ 正合适。出去玩吧。");
case 3:
System.out.println(""+c+"℃ 有点热。");
default:
System.out.println(""+c+"℃ 太热了!开空调。");
}
}
}
3．编译 KY2_3.java
看看这个程序是否会出错？如果出错，请在试验报告中解释为什么？
4．修改上面的程序，让它能正确运行。把修改后的源程序以及程序的输出结果写在实验报告中。
（四） 使用循环语句
1．请编写程序 KY2_4.java，要求程序具有如下功能：求 1＋2＋…＋100 之和，并将求和表达式与所求的和都显示出来，即程序的输出结果应该为：1＋2＋…＋100=5050。
2．编译KY2_4.java
3．运行KY2_4.class
4．把源程序写在实验报告中。
四、实验总结
请在实验报告中对本次实验内容进行总结。
第三次实验：Java面向对象编程
一、实验目的
1. 理解 Java 语言是如何体现面向对象编程基本思想的；
2. 掌握类的声明以及对象的创建；
3. 了解类的成员变量和成员方法的特性以及类的构造方法的使用。
二、实验要求
1． 编写一个长方体类，通过类中的一个成员方法来初始化类中的成员变量，并通过另外一个方法来计算长方体的体积。
2． 编写一个帐户类实现银行帐户的概念，创建帐户类的对象，完成存款与取款等操作。
三、实验内容
1． 编程创建一个Box类(长方体)，在Box类中定义三个变量，分别表示长方体的长(length)、宽(width)和高(heigth)，再定义一个方法void setBox(int l, int w, int h) 对这三个变量进行初始化，然后定义一个方法int volume ()来计算长方体的体积。最后，在main()方法中创建一个Box类的对象b，首先通过调用对象b的setBox()方法来设置长方体的长、宽和高，再通过调用对象b的volume()方法来计算这个给定尺寸的长方体的体积，并输出这个结果。
要求： 将程序的源代码写在实验报告上。并将程序运行结果写在实验报告上。
2． 定义一个银行帐户类BankAccount实现银行帐户的概念，在BankAccount类中定义两个变量："帐号" (account_number) 和"存款余额"(leftmoney)，再定义四个方法："存款" (savemoney)、"取款"(getmoney) 、 "查询余额" (getleftmoney)、构造方法(BankAccount)。
最后，在main()方法中创建一个BankAccount类的对象ba，假设ba的账号为:123456，初始的存款余额为500元。首先向该账户存入1000元，再取出2000元。
要求： 将下面源代码中的空白处填上，并写在实验报告上。将程序运行结果写在实验报告上。源代码的提示如下：
……
public double getleftmoney () { //查询余额
……
}
public void savemoney(double money) { //存款
leftmoney+=money;
}
public void getmoney (double money){ //取款
……
}
public BankAccount(int number, double money){ //构造方法，用来初始化变量
……
}
public static void main(String args[]) {
……
ba.savemoney(1000);
System.out.println("存入1000元后，您的余额为："+ba.getleftmoney());
ba.getmoney(2000);
System.out.println("取款2000元后，您的余额为："+ba.getleftmoney());
}
……
四、思考题
1． 说明什么是构造方法，构造方法有哪些特点？
2． 如果程序中有多个类时，如何来确定源程序文件的名称？
第四次实验：修饰符与继承性
一、实验目的
了解如何使用类及其成员的修饰符，理解类的继承性，掌握方法的继承、重载和覆盖。
二、实验要求
1． 编写如何使用类及其成员的修饰符的程序。
2． 编写如何通过传递参数来调用方法的程序。
3． 编写体现类的继承性（成员变量、成员方法的继承）的程序。
三、实验内容
（一）使用修饰符
有时需要公开一些变量和方法，有时需要禁止其他对象使用变量和方法，这时可以使用修饰符来实现这个目的。常用的修饰符有：public，private，protected，package，static，final，abstract等。
1． 程序功能：通过两个类 StaticDemo、KY4_1 来说明类变量与对象变量，以及类方法与对象方法的区别。
2． 编写源程序 KY4_1.java，程序源代码如下。
class StaticDemo {
static int x;
int y;
public static int getX(){
return x;
}
public static voidsetX(int newX) {
x = newX;
}
public int getY() {
return y;
}
public void setY(intnewY) {
y = newY;
}
}
public class KY4_1 {
public static void main(String[] args) {
System.out.println("类变量x="+StaticDemo.getX());
System.out.println("对象变量y="+StaticDemo.getY());
StaticDemo a= new StaticDemo();
StaticDemo b= new StaticDemo();
a.setX(1);
a.setY(2);
b.setX(3);
b.setY(4);
System.out.println("类变量a.x="+a.getX());
System.out.println("对象变量a.y="+a.getY());
System.out.println("类变量b.x="+b.getX());
System.out.println("对象变量b.y="+b.getY());
}
}
3． 编译并运行程序 KY4_1.java，看看该程序是否有错？如果有错请在实验报告中指出出错的地方，出错的原因，并给出修改意见以及程序正确运行的结果。
（二）方法中参数传递的练习
1． 编写一个程序文件KY4_2.java。
2． 程序功能如下：有一个主方法main() 以及一个求平方和的方法int square(int x, int y)。square方法计算参数x 和y的平方和，并返回该平方和值。在主方法main中定义两个整型变量，并给它们赋一个初值，然后使用这两个变量作为实际参数来调用square方法，求出平方和，最后输出平方和。
3． 请将程序KY4_2.java的源代码写在实验报告中。
（三）类的继承性练习
1． 进一步理解继承的含义
新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类 还可添加新的变量和方法。这种现象就称为类的继承。
当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。
Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。
2．编写两个程序文件KY4_3.java和KY4_4.java，实现类的继承。
3．KY4_3.java的代码如下：
public class KY4_3
{
protected String xm; //姓名
protected int xh; //学号
void setdata(String m,int h) //该方法为姓名和学号赋初始值
{
xm =m;
xh = h;
}
public void print() //输出学生的姓名和学号
{
System.out.println(xm+","+xh);
}
}
4．编译 KY4_3.java，产生类文件 KY4_3.class。注意：暂时不运行程序KY4_3.class。
5．编写一个程序文件KY4_4.java。程序功能如下：子类KY4_4继承父类 KY4_3，其不仅具有父类的成员变量 xm（姓名）、xh（学号），还定义了新的成员变量 xy（学院）、xi（系）。在子类KY4_4中重写了父类的方法print()，在该方法中不仅输出学生的姓名和学号，而且还输出学生的学院和系。另外，在子类KY4_4中还定义了一个主方法main。首先，在主方法中创建一个父类 KY4_3的对象f，设置f的姓名为"帅零"，学号为"12321"，并且调用print()方法输出对象f的姓名和学号。接着，在主方法中创建一个子类 KY4_4的对象s，设置s的姓名为"郭娜"，学号为"12345"，学院为"经济管理学院"，系为"信息管理系"，并且调用print()方法输出对象s的姓名，学号，学院和系。
6．编译并运行程序KY4_4.java。请将KY4_4的源程序以及运行结果写在实验报告中。
注意：父类 KY4_3 与子类 KY4_4要在同一文件夹（路径）内。
四、思考题
1． 说明类的继承和多态都有什么作用？
第五次实验：类的多态性
一、实验目的
理解类的多态性，掌握方法的继承、重载和覆盖，掌握如何从键盘输入数据以及多重循环的使用。
二、实验要求
4． 编写体现类的多态性（成员方法重载）的程序。
5． 编写构造方法重载的程序。
6． 编写使用键盘来输入数据的程序。
7． 编写使用多重循环的程序。
三、实验内容
（一）类的多态性练习
1． 理解类的多态性
类的继承发生在多个类之间，而类的多态只发生在同一个类上。在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。这种现象称为类的多态。
多态使程序简洁，为程序员带来很大便利。在OOP 中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。
类的多态性体现在方法的重载（overload）上，包括成员方法和构造方法的重载。
2． 方法的重载
方法的重载是指对同名方法的不同使用方式。
1) 程序功能：对不同的数进行排序输出。在IntSort 类中定义2 个同名的方法sort。
2) 编写KY5_1.java 文件，源代码如下。
class IntSort {
public String sort (int a, int b) {
if (a>b)
return a+" "+b;
else
return b+" "+a;
}
public String sort (int a, int b, int c) {
int swap;
if (a<b) {
swap=a;
a=b;
b=swap;
}
if (a<c) {
swap=a;
a=c;
c=swap;
}
if (b<c) {
swap=b;
b=c;
c=swap;
}
return a+" "+b+" "+c;
}
}
public class KY5_1 {
public static void main(String args[])
{
int a=30, b=12, c=40;
IntSort s=new IntSort();
System.out.println("两个数的排序结果："+s.sort(a,b));
System.out.println("三个数的排序结果："+s.sort(a,b,c));
}
}
3) 编译KY5_1.java并运行程序
4) 将程序的输出结果记录在实验报告中。
5) 请在实验报告中说明在IntSort 类中出现的下面两个同名的方法各自的功能？
I. public String sort (int a, intb)
II. public String sort (int a, intb, int c)
6） 请在实验报告中指出程序中是哪条语句调用了方法I，哪条语句调用了方法II？
（二）构造方法的重载
构造方法的名称和类同名，没有返回类型。尽管构造方法看起来和一般的成员方法没有差别，但它不是方法，也不是类的成员。因此，构造方法不能直接调用，只能由new 操作符调用。
构造方法对于类是十分重要的，对象的初始化任务要靠构造方法来完成。重载构造方法的目的是提供多种初始化对象的能力，使程序员可以根据实际需要选用合适的构造方法来初始化对象。
1) 编写程序KY5_2.java，将其中的类RunDemo的构造方法进行重载。源代码如下。
class RunDemo {
private String userName, password;
RunDemo(String name) {
userName=name;
}
RunDemo(String name, String pwd) {
this(name);
password=pwd;
}
void check() { //检验用户名和密码
String s=null;
if (userName!=null)
s="用户名："+userName;
else
s="用户名不能为空！";
if (password!="123456")
s=s+" 口令无效！";
else
s=s+" 口令：******";
System.out.println(s);
}
}
public class KY5_2 {
public static void main(String[] args) {
RunDemo r1=new RunDemo("刘新宇");
r1.check();
RunDemo r2=new RunDemo(null, "654321");
r2.check();
RunDemo r3=new RunDemo("张驰","123456");
r3.check();
}
}
2) 编译程序KY5_2.java并运行程序
3) 将程序的输出结果记录在实验报告中。
4) 指出程序中的下面三条语句分别调用了类RunDemo中的哪个构造方法？
I. new RunDemo("刘新宇");
II. new RunDemo(null,"654321");
III. new RunDemo("张驰","12345678");
5) 类RunDemo中有两个构造方法，其中第一个构造方法RunDemo(String) 只有一个参数，用来对成员变量userName 赋初值。第二个构造方法RunDemo(String, String) 有两个参数，并有更多的内容，首先调用this(name)，其实际作用就是调用当前类的构造方法RunDemo(String name)；然后对成员变量password 赋值；最后调用check 方法来检查userName 和password，类似于一般程序的口令验证。重载构造方法的执行由对象根据实际参数的个数、类型和顺序确定。
（三）使用键盘输入
3. 程序功能：运行程序后，从键盘输入数字 1、2或者3 ，可显示抽奖得到的奖品；如果输入其它数字或字符则显示“对不起，没有奖品给你!”。
4. 程序源代码如下。
import java.io.*;
class KY5_3 {
public static voidmain(String args[]) throws IOException {
char ch;
System.out.println("抽奖游戏，祝您好运!");
System.out.println("按 1、2、3 数字键后回车，可得大奖!");
System.out.println("按空格键后回车，可退出本游戏.");
while((ch=(char)System.in.read())!=' ')
{
System.in.skip(2); // 跳过回车键
switch (ch) {
case '1':
System.out.println("恭喜您得大奖，一辆汽车!");
break;
case '2':
System.out.println("不错呀，您得到一台笔记本电脑!");
break;
case '3':
System.out.println("没有白来，您得到一台冰箱!");
break;
default:
System.out.println("对不起，没有奖品给您!欢迎下次光临。");
}
}
}
}
3．编译并运行KY5_3.java
4．运行程序，从键盘输入一下数字或字符，看看程序的输出结果是什么？把这些结果写在实验报告中。
（四） 使用多重循环语句
1．请编写程序 KY5_4.java，要求程序能够输出九九乘法表。
2．程序源代码如下。
public class KY5_4
{
public static void main(Stringargs[])
{
int i, j, n=9;
System.out.print(" * |");
for (i=1; i<=n; i++) { System.out.print(" "+i); } //第一个for循环
System.out.print("\n----------|");
for (i=1; i<=n; i++) { System.out.print("-----"); } //第二个for循环
System.out.println();
for (i=1; i<=n; i++) //第三个for循环
{
System.out.print(" "+i+" |");
for (j=1; j<=i; j++) { System.out.print(" "+i*j); } //第四个for循环
System.out.println();
}
}
}
3．编译并运行KY5_4.java
4．请将程序的运行结果写在实验报告中，并且说明程序中每一个for循环的作用。
四、实验总结
请在实验报告中对本次实验内容进行总结。
第六次实验：包与接口以及常用工具类的使用
一、实验目的
了解 Java 中包（package）和接口（interface）的作用，掌握包和接口的设计方法。掌握Math类，String类和StringBuffer类的使用。
二、实验要求
1． 了解 Java 系统包的结构，创建并使用自定义包。
2． 掌握接口的定义与使用。
3． 掌握Math类的使用。
4． 掌握String类和StringBuffer类的使用
三、实验内容
（一）创建并使用自定义包
1．自定义包的声明方式
<package> <自定义包名>
声明包语句必须添加在源程序的第一行，表示该程序文件声明的全部类都属于这个包。
2．创建自定义包 Mypackage
在存放源程序的文件夹中建立一个子文件夹 Mypackage。例如，在“D:\java\javacode”文件夹之中创建一个与包同名的子文件夹 Mypackage（D:\java\javacode\Mypackage），并将编译过的 class 文件放入到该文件夹中。 注意：包名与文件夹名大小写要一致。
3．在包中创建类
1) 编写程序KY6_1.java，在源程序中，首先声明使用的包名 Mypackage，然后创建KY6_1类，该类具有计算今年的年份，可以输出一个带有年月日的字符串的功能。
2) 源代码如下。
package Mypackage; //声明存放类的包
import java.util.*; //引用 java.util 包
public class KY6_1 {
private int year,month,day;
public static void main(String[] args){}
public KY6_1 (inty,int m,int d) {
year = y;
month = (((m>=1) & (m<=12)) ? m : 1);
day = (((d>=1) & (d<=31)) ? d : 1);
}
public static int thisyear() {
return Calendar.getInstance().get(Calendar.YEAR);//返回当年的年份
}
public int year() {
return year;//返回年份
}
public String toString(){
returnyear+"-"+month+"-"+day;//返回转化为字符串的年-月-日
}
}
3) 编译KY6_1.java 文件，然后将KY6_1.class 文件存放到 Mypackage 文件夹中（D:\java\javacode\Mypackage）。注意：先不运行程序KY6_1.class！
4．编写一个需要使用到包 Mypackage 中的KY6_1 类的程序KY6_2.java。
1) 编写 KY6_2.java 程序：给定某人姓名与出生日期，计算该人年龄，并输出该人姓名，年龄，出生日期。程序使用了KY6_1 的方法来计算年龄。
2) 源代码如下。
import Mypackage.KY6_1; //引用 Mypackage 包中的KY6_1 类
public class KY6_2
{
private String name;
private KY6_1 birth;
public static void main(String args[])
{
KY6_2 a = new KY6_2("张驰",1990,1,11);
a.output();
}
public KY6_2 (Stringn1, int y, int m, int d)
{ //初始化变量与对象
name = n1;
birth = newKY6_1(y, m, d);
}
public int age() //计算年龄
{
return birth.year() - KY6_1.thisyear(); //返回当前年与出生年的差即年龄
}
public void output()
{
System.out.println("姓名 : "+name);
System.out.println("出生日期: "+birth.toString());
System.out.println("今年年龄 : "+age());
}
}
3) 编译KY6_2.java 程序并运行程序KY6_2.java
4) 在实验报告中写出该程序的运行结果。
5) 程序运行的结果有没有问题？问题出在哪里？请在实验报告中指出。
（二）使用接口技术
定义两个接口，其中各包括一个抽象方法分别用来完成两个数的加法和减法操作，然后创建一个类KY6_3来实现这两个接口中的抽象方法。编写程序KY6_3.java，将源程序写在实验报告中。
（三）Math类的使用
1．利用下面的关键代码编写一个完整的程序KY6_4.java，理解Math类的使用。
System.out.println (Math.abs(-5.8));
System.out.println (Math.ceil(3.2));
System.out.println (Math.floor(3.8))
System.out.println (Math.round(3.8));
System.out.println (Math.round(3.2));
System.out.println (Math.min (3, 2));
System.out.println (Math.max (Math.PI, 4));
System.out.println (Math.log(7.0));
System.out.println (Math.pow(7,2));
System.out.println (Math.exp (0.4));
System.out.println ("e is:"+Math.e);
System.out.println ("π is:"+Math.PI);
System.out.println(Math.random());
2．将程序的运行结果写在实验报告中。
（四）String类与StringBuffer类的使用
1．利用下面的关键代码编写一个完整的程序KY6_5.java，理解String类与StringBuffer类的使用。
String s=new String("This is andemo of the String method.");
System.out.println("Length:"+s.length());
System.out.println("SubString:"+s.substring(11,15));
StringBuffer sf=newStringBuffer("Hello World!");
sf.append(" Hello Java!");
sf.insert(12," And");
System.out.println(sf);
System.out.println(sf.charAt(0));
sf.setCharAt(0,''h'');
System.out.println(sf.charAt(0));
System.out.println(sf);
2．将程序的运行结果写在实验报告中。
四、思考题
3． 算术运算应该使用什么类?
4． Java语言中如何表示字符串？
实验七 流与文件
一、实验目的
1． 理解数据流的概念
2． 理解Java流的层次结构
3． 理解文件的概念
二、实验要求
1． 掌握字节流的基本使用方法
2． 掌握字符流的基本使用方法
3． 能够创建、读写、更新文件
三、实验内容
（一）使用标准数据流的应用程序
标准数据流指在字符方式下（如DOS提示符）程序与系统进行输入输出的方式，键盘和显示器屏幕是标准输入输出设备，数据输入的起点为键盘，数据输出的终点是屏幕，输出的数据可以在屏幕上显示出来。
1． 程序功能：将键盘上输入的字符在屏幕上显示出来
2． 编写KY10_1.java 程序文件，源代码如下。
class KY10_1{
public staticvoid main(String[] args) throws java.io.IOException {
bytebuffer[]=new byte[10];
System.out.println("从键盘输入不超过10 个字符，按回车键结束输入：");
int count=System.in.read(buffer);//读取输入的字符并存放在缓冲区buffer 中
System.out.println("保存在缓冲区buffer 中元素的个数为："+count);
System.out.println("buffer中各元素的值为：");
for (inti=0;i<count;i++){
System.out.print(""+ buffer[i]);//在屏幕上显示buffer 元素的值
}
System.out.println();
System.out.println("输出buffer 字符元素：");
System.out.write(buffer,0, buffer.length);
}
}
3． 编译、运行KY10_1.java文件。
（二）使用文件输入输出流的应用程序
1. 程序功能：将保存在本地机当前文件夹中的KY10_2.HTML 文本文件的内容在屏幕上显示出来，然后将其另存为KY10_2.txt文件。
2. 编写KY10_2.java 程序文件，源代码如下
import java.io.*;
public class KY5_4 {
public static void main(String[] args) throws IOException {
FileReader in=new FileReader("KY5_1.HTML");//建立文件输入流
BufferedReader bin=new BufferedReader(in);//建立缓冲输入流
FileWriter out=new FileWriter(" KY5_1.txt",true);//建立文件输出流
String str;
while ((str=bin.readLine())!=null) {
//将缓冲区内容通过循环方式逐行赋值给字符串str
System.out.println(str);//在屏幕上显示字符串str
out.write(str+"\n");//将字符串str 通过输出流写入KY5_1.txt 中
}
in.close();
out.close();
}
}
3. 编译、运行程序
（三）转换流
1．程序功能：从键盘读入一行字符，并将其转换成大写打印在屏幕，当输入exit字符串时退出。
2. 编写KY10_3.java 程序文件，源代码如下
import java.io.*;
public class KY10_3 {
public static void main(Stringargs[]) {
InputStreamReader isr =
newInputStreamReader(System.in);
BufferedReader br = newBufferedReader(isr);
String s = null;
try {
s = br.readLine();
while(s!=null){
if(s.equalsIgnoreCase("exit")) break;
System.out.println(s.toUpperCase());
s = br.readLine();
}
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
3. 编译、运行程序
（四）使用数据输入输出流与文件输入输出流类的应用程序
使用数据输入流DataOutputStream 和数据输出流DataInputStream 可以读取或写入任何Java 类型的数据，不用关心它们的实际长度是多少字节。一般与文件输入流FileInputStream和输出流类
FileOutputStream 一起使用。
1． 程序功能：将整型数据和字符串对象通过数据输出流写到文件中。将文件中的整型数据和字符串对象通过数据输出流读出，并在屏幕上显示文件中的内容。
2． 编写KY10_4.java 程序文件，源代码如下。
importjava.io.*;
public class KY10_4
{
public staticvoid main(String arg[])
{
try
{ //添加方式创建文件输出流
FileOutputStreamfout = new FileOutputStream("KY5_6.txt",true);
DataOutputStreamdout = new DataOutputStream(fout);
dout.writeInt(1);
dout.writeChars("罗马"+"\n");
dout.writeInt(2);
dout.writeChars("北京"+"\n");
dout.close();
}
catch(IOException ioe){}
try
{
FileInputStreamfin = new FileInputStream("KY5_6.txt");
DataInputStreamdin = new DataInputStream(fin);
int i =din.readInt();
while (i!=-1)//输入流未结束时，输入流结束时i 为-1
{
System.out.print(i+" ");
char ch ;
while ((ch=din.readChar())!='\n') //字符串未结束时
System.out.print(ch);
System.out.println();
i = din.readInt();
}
din.close();
}
catch(IOException ioe){}
}
}
3． 编译并运行程序
第八次实验：多线程与异常处理
一、实验目的
了解线程的概念、线程的生命周期，掌握多线程的编程。掌握异常的概念以及如何定义、抛出和捕捉处理异常。
二、实验要求
1． 掌握利用Java语言编写多线程程序的方法
2． 掌握线程的调度方法
3． 编写一个程序，用来捕获各种类型的异常
4． 编写一个程序，用来说明异常处理块中各个语句块的作用
5． 熟悉异常的类型及其产生的原因
三、实验内容
（一）Thread子类的方法实现多线程
1． 编写 TwoThreadsTest.java 程序文件，源代码如下。
class SimpleThread extends Thread {
public SimpleThread(String str) {
super(str);
}
public void run() {
for (int i = 0; i < 10;i++) {
System.out.println(i + "" + getName());
try {
sleep((int)(Math.random() *1000));
} catch (InterruptedException e){}
}
System.out.println("DONE! "+ getName());
}
}
public class TwoThreadsTest {
public static void main (String[] args) {
new SimpleThread("Go to Beijing??").start();
new SimpleThread("Stayhere!!").start();
}
}
2． 编译、运行
3． 请将程序的运行结果写在实验报告中。
（二）实现Runnable接口的方法实现多线程
1． 程序功能：一个时钟Applet，它显示当前时间并逐秒进行更新
2． 编写Clock.java 程序文件，源代码如下。
import java.awt.*;
import java.applet.*;
importjava.util.*;
public class Clock extends Applet implementsRunnable{
ThreadclockThread;
public void start(){
if(clockThread==null){
clockThread=newThread(this,"Clock");
clockThread.start();
}
}
public void run(){
while(clockThread !=null){
repaint();
try{
clockThread.sleep(1000);
}catch(InterruptedException e){}
}
}
public void paint(Graphics g){
Date now=new Date(); g.drawString(now.getHours()+";"+now.getMinutes()+";"+now.getSeconds(),5,10);
}
public void stop(){
clockThread.stop();
clockThread=null;
}
}
3．编译Clock.java 文件。
4．编写Clock.html 文件，源代码如下：
<HTML>
<HEAD>
<TITLE>A Simple Program </TITLE>
</HEAD>
<BODY>
Hereis the output of my program:
<APPLETCODE="Clock.class" WIDTH=150HEIGHT=25>
</APPLET>
</BODY>
</HTML>
5． 在浏览器中打开Clock.html 文件，将你看到的运行结果写在实验报告中。
（三）捕获并处理各种类型的异常
1．编写ExceptionTest.java 程序文件，源代码如下。
import java.io.*;
public class ExceptionTest{
public static void main(Stringargs[]) {
for(int i = 0; i < 4;i++) {
int k;
try {
switch( i ) {
case 0:
int zero = 0;
k = 911 / zero;
break;
case 1:
int b[ ] = null;
k = b[0];
break;
case 2:
int c[ ] = new int[2];
k = c[9];
break;
case 3:
char ch = "abc".charAt(99);
break;
}
}catch(Exception e) {
System.out.println("\nTestcase #" + i + "\n");
System.out.println(e);
}
}
}
}
2． 编译、运行
3． 根据运行结果，请在实验报告中说明程序运行中总共捕捉了几个异常，并指出每个异常各自属于哪种类型的异常？
（四）了解异常处理模块中各个语句块的功能
1．编写TryTest.java 程序文件，源代码如下。
importjava.io.*;
public class TryTest{
public TryTest(){
try{
int a[] = new int[2];
a[4] = 3;
System.out.println("After handling exception return here?");
}catch(IndexOutOfBoundsException e){
System.err.println("exception msg:" + e.getMessage());
System.err.println("exception string:" + e.toString());
e.printStackTrace();
}finally{
System.out.println("-------------------");
System.out.println("finally");
}
System.out.println("No exception?");
}
public static void main(String args[]){
new TryTest();
}
}
2． 编译、运行
3． 根据运行结果，将程序的运行结果写在实验报告中。
4． 请在实验报告中指出程序中的语句System.out.println("Afterhandling exception return here?"); 有没有被执行？
四、思考题
1． 简述并区分程序、进程和线程三个概念。
2． 线程有哪几个基本的状态？Java中线程调度遵循何种原则？
3． 实现多线程可以用哪两种基本方法？将这两种方法进行比较。
4． 异常是如何抛出、捕捉和处理的？
5． 异常处理机制有哪些好处？
第九次实验：GUI标准组件及事件处理
一、实验目的
了解图形用户界面基本组件：框架、面板、按钮、标签、菜单、列表等的使用方法；了解如何使用布局管理器对组件进行管理；理解和掌握 Java 的事件处理机制。
二、实验要求
1. 了解Java图像用户界面的开发，掌握基本组件的使用。
2. 掌握编写独立运行的窗口界面的方法，了解菜单和对话框的使用方法。
3. 理解Java的事件处理机制，掌握为不同组件编写事件处理程序的方法。
三、实验内容
（一）在面板中添加多个组件，并进行合理的布局
¨ 程序功能：在一个框架(Frame)容器中添加一个面板(Panel)容器，并分别在框架和面板容器中添加组件并使用不同的布局管理方式。
¨ 请编写KY7_1.java 程序文件，相关源代码的提示如下。
import java.awt.*;
importjava.awt.Color;
public classKY7_1 {
public static void main(String args[]){
…… //创建一个框架f
…… //创建一个面板p
…… //把面板p添加到框架f中
…… //设置面板p的背景颜色为蓝色
p.setLayout(new FlowLayout()); //设置面板p的布局为流式布局
…… //在面板p中添加一个标签l
…… //在面板p中添加六个按钮
Choice c=new Choice (); // 创建一个下拉列表c，
c.addItem("北京"); // 下拉列表c中有三个选项：北京、上海和天津
c.addItem("上海");
c.addItem("天津");
…… //把列表c添加到面板p中
…… //设置框架f的大小和可见性
}
}
¨ 将上面程序中的空缺部分添加进去，编译并执行该程序。
¨ 将KY7_1.java的完整源程序写在实验报告中。
（二）为窗口添加菜单，并处理由菜单项所引发的事件
¨ 程序功能：在窗口中添加菜单条，在菜单条中添加菜单，并在菜单中添加菜单项和子菜单。通过选择菜单项可以引发不同的事件，从而执行不同操作，例如点击“打开”菜单项可以打开一个“打开文件对话框”。
¨ 编写KY7_2.java 程序文件，源代码如下。
import java.awt.*;
import java.awt.event.*;
public class KY7_2 extendsFrame implements ActionListener {
static Frame f; //声明一个框架
static FileDialog fd1; //声明一个文件对话框对象
static FileDialog fd2;
public static void main(String args[]) {
KY7_2 k = new KY7_2();
f =new Frame(); // 创建一个框架f
…… // 创建一个菜单条 mb
…… // 在菜单条mb中添加两个菜单m1（"文件"）和m2("帮助")
…… /* "文件"菜单m1中有三个菜单项：m11（"打开"）、
m12（"关闭"）和m13（"退出"）*/
…… /* "帮助"菜单m2中有三个菜单项：m21（"目录"）、
m22（"索引"）和m23（"关于"）*/
…… // "文件"菜单m1中还有一个子菜单m3（"编辑"）
…… /* "编辑"子菜单m3 中有三个菜单项：m31（"复制"）、
m32（"剪切"）和m33（"粘贴"）*/
m11.addactionlistner(k); /* 允许菜单项"打开"引发一个事件，该事件的处理者为当前对象 k */
m13.addactionlistner(k); /* 允许菜单项"退出"引发一个事件，该事件的处理者为当前对象 k */
f.setSize(350,200); // 设置框架f的大小
f.setMenuBar(mb); // 设置框架f的菜单条为mb
f.setVisible(true);
}
public voidactionPerformed (ActionEvent e) { /* 处理由菜单项"打开"和"退出" 所引发的事件*/
if(e.getActionCommand() == "打开") { /* 若"打开"菜单项引发事件，则打开“打开文件对话框”*/
FileDialog fd = new FileDialog (f, "open", FileDialog.SAVE);
fd.setVisible (true);
}
if(e.getActionCommand() == "保存") /* 若"保存"菜单项引发事件，则打开“保存文件对话框”*/
…… //创建并打开一个“保存文件对话框”
}
}
¨ 将上面程序中的空缺部分添加进去，编译并执行该程序。
¨ 将KY7_2.java的完整源程序写在实验报告中。
四、思考题
1．构造函数和init()方法谁先被执行？
2．编写Applet，包含两个按钮，一个按钮用于放大Applet上的一串字符串，一个按钮用于缩小；连续点击可不断放大或缩小。
第十次实验(课后自学加分项)：综合练习（一）
一、 实验目的
将所学知识进行综合运用，模仿设计具有实际意义的应用程序。锻炼使用新类（没有介绍的）类的能力。
二、 实验要求
1. 在计算机上实现指导书中应用程序。
2. 分析应用程序中使用了哪些系统类，指出使用该类的变量与方法。说明创建了什么类。包含什么变量与方法。
3. 能根据实际需要使用不同的系统类编写应用程序。
三、 实验内容
（一）幻灯机效果——连续显示多幅图像
1、程序功能：如果 Applet 仅仅是显示一幅图像，没有什么特别的意义，不如直接在HTML文件中显示多幅图像。下面的程序可以像幻灯机那样连续显示多幅图像。在当前目录(D:\java\javacode)中的 images 文件夹中准备了 6 幅花的图像文件(flower1.jpg,……, flower6.jpg)。每隔一秒钟将显示其中的一副图像。
2、编写 KY9_1.java 程序文件，源代码提示如下。
…… //导入需要的包
public class KY9_1 extends Applet {
int index = 0; //指示当前图像的下标（0≤index≤5）
…… //创建一个Image类的对象数组imgs，数组元素个数为6
public void init ( ) { //初始化
…… //将六幅图像文件分别加载进数组imgs中
}
public void paint(Graphics g) { //绘图
…… //绘制当前图形
…… //指示下一幅图像，如果index超过5，则返回0（第一幅图像）
try { Thread.sleep (1000); //暂停一秒钟
}
catch(InterruptedException e) {
e.printStackTrace ( );
}
…… //刷新
}
}
3、在这个程序中，我们加载了 6 幅图像，每隔1秒显示其中一副图像，并且在显示完第 6 幅图像后自动返回第一幅重新开始显示。请对程序进行分析，将完整的源程序写在试验报告中。
（二）使用滚动条改变背景颜色
1． 程序功能：移动滚动条可以引发事件，从而改变Applet的背景颜色。运行结果如下图所示。
2． 编写 KY9_2.java 程序文件，源代码提示如下。
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class KY9_2 extends Applet implementsAdjustmentListener {
//类KY9_2实现了监听器接口AdjustmentListener
Scrollbar r1, r2, r3; //声明三个滚动条对象r1, r2, r3
int red, green, blue;
TextField t; Label a; //声明一个文本框t和一个标签a
public void init ( ) {
setLayout(null);
r1=new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,255); //创建水平滚动条r1
r2=new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,255); //创建水平滚动条r2
r3=new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,255); //创建水平滚动条r3
t=new TextField("0",5); //创建文本框t
…… // 将文本框t设置为不可读
a=new Label("移动滚动条可改变背景颜色", Label.CENTER); //创建一个标签a
add(a); // 将标签a添加到Applet中
a.setBounds(120,10,150,15); // 设置标签a的位置和大小
…… // 将滚动条r1添加到Applet中
r1.setBounds(20,30,100,20); // 设置滚动条r1的位置和大小
…… // 将滚动条r2添加到Applet中
r2.setBounds(140,30,100,20); // 设置滚动条r2的位置和大小
…… // 将滚动条r3添加到Applet中
r3.setBounds(260,30,100,20); // 设置滚动条r3的位置和大小
…… // 将文本框t添加到Applet中
t.setBounds(20,120,220,18); // 设置文本框t的位置和大小
r1.addAdjustmentListener (this); // 将滚动条r1的事件监听器设置为当前对象
…… // 将滚动条r2的事件监听器设置为当前对象
…… // 将滚动条r3的事件监听器设置为当前对象
}
public voidadjustmentValueChanged(AdjustmentEvent e) { //滚动条滚动事件的处理模块
// 重写监听器接口AdjustmentListener中的空方法adjustmentValueChanged ( )
red= r1.getValue(); //将滚动条r1的当前值赋值给变量red
…… //将滚动条r2的当前值赋值给变量green
…… //将滚动条r3的当前值赋值给变量blue
t.setText("red的值" +String.valueOf(r1.getValue()) + ", green 的值" + String.valueOf(r2.getValue()) + ", blue 的值" + String.valueOf(r3.getValue() ));
//将滚动条r1, r2和r3的当前值转换成字符串的形式显示在文本框t中
…… //以red,green和blue作为实际参数，创建一个颜色类Color的对象c
setBackground(c); //将Applet的背景色设置为对象c
} }
3． 请对上述程序进行分析，将完整的源程序写在试验报告中。
四、思考题
1．字符流和字节流的区别是什么？
2．对文件进行读写操作的过程是什么？
第十次实验（课后自学加分项）：综合练习（二）
一、 实验目的
将所学知识进行综合运用，模仿设计具有实际意义的应用程序。锻炼使用新类（没有介绍的）类的能力。
二、 实验要求
1. 在计算机上实现指导书中应用程序。
2. 分析应用程序中使用了哪些系统类，指出使用该类的变量与方法。说明创建了什么类。包含什么变量与方法。
3. 能根据实际需要使用不同的系统类编写应用程序。
三、 实验内容
（一）使用Applet的图形、字体、颜色、图像和声音功能编写一个综合应用程序。
1． 程序功能：
（1） 在Applet中绘制字符串、直线、园、椭圆、矩形、弧、多边形等图形。
（2） 在Applet中显示一些字符串，设置这些字符串的字体的型号、大小以及格式，
（3） 设置Applet的背景色、前景色、图形和字符串的颜色等
（4） 将一个图像文件载入到Applet中，在其中显示原图、缩小一半图、宽扁图和瘦高图。
（5） 在Applet中播放两段音乐，一段是连续播放的背景音乐，一段是独立的整段音乐。具体的素材可以自己找。
2． 编写 KY10.java 程序文件，将完整的源程序写在试验报告中。
四、思考题
1．什么是URL？一个URL地址由哪些部分组成？
2．网络环境下的C/S模式的基本思想是什么？什么是客户机？什么是服务器？它们各自的作用如何？C/S模式的基本工作过程如何？
3．简述流式Socket的通信机制。它的最大特点是什么？
4．数据报通信有何特点？简述Java实现数据报通信的基本工作过程。