目 录
实验一、Java程序的编辑、编译和运行 ............................................................ 2 实验二、java控制语法 ......................................................................................... 4 实验三、java的类 ................................................................................................. 6 实验四、Java布局管理和java的事件 .............................................................. 11 实验五、Java Applet的应用 ............................................................................... 15 实验六、Java IO与异常处理 ............................................................................. 18 实验七、多线程和数据库编程........................................................................... 22 实验八、网络Socket编程.................................................................................. 30 实验九、综合实验............................................................................................... 37
计算机实验教学中心 段小林2009年3月修订
实验一、Java程序的编辑、编译和运行
一、实验目的：
1. 掌握使用JDK开发Java程序的步骤（编辑、编译、运行）。 2. 掌握Java程序的基本结构。
3. 掌握Eclipse开发环境的使用方法。 二、实验要求：
编写一个简单的Java应用程序，输出两句话： “Hello, World!”
“This is the first Java program.” 三、实验内容：
1. 创建目录D:\\你的学号。把这个目录作为我们的工作目录。我们的Java
源程序、编译后的字节码文件和用来运行Java Applet的html文件都放在这个目录中。
2. 在命令行窗口下输入java –version 查看JRE的版本。
3. 启动附件中记事本工具。 4. 在记事本编辑如下源程序： public class Ex1 { public static void main( String args[] ) { System.out.println(\"Hello, World!\"); System.out.println(\"This is the first Java program.\"); } }
5. 保存程序。注意，保存源程序时，程序名要与主类名一致。即要用Ex1.java
作为本程序的文件名。（记事本默认的扩展名是*.txt，要改为*.java）。把该文件保存到第一步所建的目录中（即D:\\你的学号）。 6. 编译程序。启动MS_DOS窗口，键入如下命令：（假如你的学号是410808，
即你建的目录为D:\\410808） C:\\WINDOWS>d: D:\\>cd 410808
计算机实验教学中心 段小林2009年3月修订
D:\\410808>javac Ex1.java
如果编译成功，则在D:\\410808目录中生成字节码文件Ex1.class。 7. 运行程序。
D:\\410808>java Ex1 就可以运行程序。
注意：Ex1是上一步编译生成的Ex1.class，文件名有大小写区别。 8. 观察程序输出的结果是否与实验要求相符。 9. 启动Eclipse，重新编写运行Ex1。 10. 在Eclipse中输入和调试一下程序。
import java.text.SimpleDateFormat; import java.util.Date; public class TestDate{
public static void main(String[] args){
Date myDate=new Date(System.currentTimeMillis());
System.out.println(myDate.toString());
SimpleDateFormat sDateFormat=new SimpleDateFormat(\"yyyy/MM/dd HH:mm:ss \"); System.out.println(sDateFormat.format(myDate)); } }
计算机实验教学中心 段小林2009年3月修订
实验二、java控制语法
一、实验目的：
1. 熟练掌握if语句和switch语句。 2. 学会使用合适的表达式描述问题。
3. 熟练使用while、do-while、和for语句实现循环的方法。 4. 掌握在程序设计中用循环的方法实现各种算法。
二、实验要求：
编写一个含有分支控制结构的Java应用程序。 三、实验内容：
3.1 分支控制结构
1. 编写一个成绩转换的java程序。其对应关系如下： 分数 转换后的输出结果 0～59 不及格 60～69 及格 70～79 中 80～89 良 90～100 优 其它 错误
2. 在记事本编辑如下源程序： public class Ex2 { public static void main( String args[] ) { int score =70; if((score>=0)&&(score<=59)) System.out.println(\"不及格\"); else if((score>=60)&&(score<=69)) System.out.println(\"及格\"); else if((score>=70)&&(score<=79)) System.out.println(\"中\"); else if((score>=80)&&(score<=89)) System.out.println(\"良\"); else if((score>=90)&&(score<=100)) System.out.println(\"优\"); else System.out.println(\"错误\"); } }
3. 保存程序Ex2.java，编译程序，并运行程序，查看结果。 4. 修改score变量的初始值（0、59、60、79、80、99、105），重新编
计算机实验教学中心 段小林2009年3月修订
译运行，查看结果是否正确。
5. switch语句替代if-else语句，并重新编译运行程序，再重复第4步，
测试程序是否正确。 3.2循环控制结构
1. 编写一个成绩统计的java程序。先在数组中定义5个学生的成绩，再
求出平均成绩，最后找出最高分。 2. 在记事本编辑如下源程序： public class Ex3 {
public static void main( String args[] ) { int score[]={60,76,90,48,80}; int sum =0; int max =0; for(int i=0;i<5;i++) { sum+=score[i]; if(score[i]>max) max =score[i]; } double average =(double)sum /5; System.out.println(\"Average =\"+average); System.out.println(\"Max =\"+max); } }
3. 保存程序Ex3.java，编译运行程序，观察程序的运行结果，体会for循
环语句的执行流程。
4. 用while语句替代for语句，找出最低分，并重新编译运行程序。 5. 用do-while语句替代for语句，找出最低分，并重新编译运行程序。 6. 用循环语句对5个学生的成绩排序，并按从小到大的顺序输出。
计算机实验教学中心 段小林2009年3月修订
实验三、java的类
一、实验目的：
1. 掌握如何定义类以及类的成员变量、类的方法。 2. 掌握对象的创建、对象属性的引用和方法的调用。 3. 理解成员的访问权限。
4. 掌握如何定义和使用构造方法。 5. 掌握this的使用。
6. 掌握关键字static、final的使用方法。 7. 掌握构造方法的重载。 8. 掌握派生子类的方法。 9. 理解关键字super的含义。
10. 理解继承中属性的隐藏和方法的覆盖机制。 11. 掌握instanceof运算符的用法。 12. 区别重载和覆盖。
13. 理解在继承关系中构造方法的调用过程 二、实验要求：
1.编写一个含有简单类定义的Java应用程序。
2. 编写一个含有多个构造方法的类的Java应用程序。 三、实验内容： 3.1 简单类
1. 定义一个学生类，它包括几个属性：学号（ID）、姓名（Name）、年龄（Age）、
性别（Sex）。在main方法中创建一个学生类的对象，然后给这个对象赋初值，最后输出该学生的属性。 2. 在记事本编辑如下源程序： class Student { public int ID; public String StuName; public int Age; public boolean Sex; }
class Ex4 { public static void main(String[] args) { // TODO: Add your code here Student stu =new Student(); stu.ID =410808; stu.StuName =\"王杰\"; stu.Age =21; stu.Sex =true; System.out.println(\"学号\"+\"\\"+\"姓名\"+\"\\"+\"年龄\"+\"\\"+\"性别\");
System.out.println(stu.ID+\"\\"+stu.StuName+\"\\"+stu.Age+\"\\"+(stu.Sex?\"男\":\"女\"));
计算机实验教学中心 段小林2009年3月修订
} }
3. 保存程序Ex4.java，编译程序，并运行程序，查看结果。
4. 把Student类中所有的成员变量的访问权限由public分别改为private、
private protected、protected，保存并重新编译程序，看会出现什么结果。 5. 改写Student类，把Student类中所有的成员变量的访问权限由public改
为private，并为每个成员变量定义两个方法，（如对于StuName属性，分别定义SetName(String n)、GetName()），使之通过Student类的方法来访问其成员变量。修改main方法的内容，使修改后的程序输出相同的结果 3.2 类的构造
1. 定义一个点（Point）类，它包含横坐标x和纵坐标y两个属性，再给
Point定义两个构造方法。
2. 定义一个圆（Circle）类，它包含圆心（Center）和半径（Radius）两个
属性，再给圆定义4个构造方法和一个打印圆的面积的方法。
3. 在main方法中分别用4种不同的方法构造圆，并打印出圆的面积。 4. 在记事本编辑如下源程序： class Point{ private int x; private int y; Point(){ SetXY(0,0); }
Point(int a,int b) { SetXY(a,b); }
public int GetX() { return x; }
public int GetY() { return y; }
public void SetXY(int a, int b) { x =a; y =b; } }
class Circle{
final double PI =3.1415926; private Point Center; private int Radius; Circle() { Center =new Point();
计算机实验教学中心 段小林2009年3月修订
Radius =5; }
Circle(Point Center) { Radius =5; this.Center =Center; }
Circle(int Radius) { this.Radius =Radius; Center =new Point(); }
Circle(Point Center, int Radius) { this(Center); this.Radius =Radius; }
public void PrintArea() { double area =PI*Radius*Radius; System.out.println(\"**************************************\"); System.out.println(\"Center =(\"+Center.GetX()+\ Center.GetY()+\"), \"+\"Radius =\"+Radius+\ System.out.println(\"**************************************\"); } }
public class Ex5 {
public static void main(String[] args) { // TODO: Add your code here Point center =new Point(2,2); int radius =3; Circle cir1 =new Circle(); cir1.PrintArea(); Circle cir2 =new Circle(center); cir2.PrintArea(); Circle cir3 =new Circle(radius); cir3.PrintArea(); Circle cir4 =new Circle(center,radius); cir4.PrintArea(); } }
5. 保存程序Ex5.java，编译程序，并运行程序，查看分析结果。 6. 分析用4种不同方法构造圆的执行过程。 7. 在main方法中语句“cir1.PrintArea();”后面加入一条语句“cir1.PI =2;”，
保存程序，并重新编译，会出现什么问题？ 8. 将语句“this(Center);”改为“Circle(Center);”，保存程序，并重新编译，
会出现什么问题？理解this关键字的不同用法。
计算机实验教学中心 段小林2009年3月修订
3.3 类的继承
1. 定义一个点（Point）类，它包含横坐标x和纵坐标y两个属性，再给
Point定义两个构造方法和一个打印点坐标的方法（Show()）。 2. 定义一个圆（Circle）类，它继承Point类（它是一个点，圆心（Center）），
除此之外，还有属性半径（Radius），再给圆定义2个构造方法、一个打印圆的面积的方法（PrintArea()）和一个打印圆中心、半径的方法（Show()）。
3. 在记事本编辑如下源程序： class Point{
protected int x; protected int y; Point(){ SetXY(0,0); }
Point(int a,int b) { SetXY(a,b); }
public int GetX() { return x; }
public int GetY() { return y; }
public void SetXY(int a, int b) { x =a; y =b; }
public void Show() { if(this instanceof Circle) System.out.println(\"中心: \"+\"(\"+x+\ else System.out.println(\"点: \"+\"(\"+x+\ } }
class Circle extends Point{ final double PI =3.1415926; protected int Radius; Circle() { Radius =5; }
Circle(Point Center, int Radius) { super(Center.GetX(),Center.GetY());
计算机实验教学中心 段小林2009年3月修订
this.Radius =Radius; }
public void PrintArea() { double area =PI*Radius*Radius; System.out.println(\"**************************************\"); System.out.println(\"面积：\"+area); System.out.println(\"**************************************\"); }
public void Show() { super.Show(); System.out.println(\"半径: \"+Radius); } }
public class Ex6 {
public static void main(String[] args) { Point center =new Point(2,2); center.Show(); int radius =3; Circle cir1 =new Circle(); cir1.Show(); cir1.PrintArea(); Circle cir4 =new Circle(center,radius); cir4.Show(); cir4.PrintArea(); } }
4. 保存程序Ex6.java，编译运行程序，观察并分析程序的运行结果。 5. 去掉语句“super.Show();”，再看看运行结果。理解程序中多太性的运
用。
6. 在语句“SetXY(0,0);”和语句“SetXY(a,b);”添加一条语句
“System.out.println(\"构造点(\"+x+\\"+y+\")\");”，在语句“Radius =5;”和语句“this.Radius =Radius;”添加一条语句“System.out.println(\"构造圆(半径: \"+Radius+\")\");”，重新编译运行程序，观察并理解所得到的结果，从而理解在继承关系中构造方法的调用过程。
计算机实验教学中心 段小林2009年3月修订
实验四、Java布局管理和java的事件
一、实验目的：
1. 掌握Java语言中几种布局管理器。
2. 能熟练综合运用这几种布局管理器设计复杂的图形界面。 3. 理解事件的概念。
4. 能熟练使用Java提供的事件处理方法，进行符合要求的事件处理 二、实验要求：
结合多种布局管理器设计一个复杂的图形界面。 掌握Java提供的各种事件接口，并能灵活使用。 三、实验内容： 3.1 Java布局管理
容器中组件的位置和大小通常由布局管理器决定。每个容器都有一个默认的布局管理器。当容器被创建后，可以通过特定的方法改变容器的布局管理器。
1. 用BorderLayout和GridLayout布局管理器设计一个如下图所示的图形界
面：
2. 在记事本编辑如下源程序： import java.awt.*; public class Ex9_1 { private Frame demoframe; private Button b1; private Button b2; private Button b3; private Button b4; private Panel cpanel; private Button b[]; public void Init() { demoframe =new Frame(\"布局管理器\"); b1 =new Button(\"确定\"); demoframe.add(b1,\"East\"); b2 =new Button(\"取消\"); demoframe.add(b2,\"West\");
计算机实验教学中心 段小林2009年3月修订
} 3.
} b3 =new Button(\"Hello,\"); demoframe.add(b3,\"North\"); b4 =new Button(\"Java!......\"); demoframe.add(b4,\"South\"); cpanel =new Panel();
cpanel.setLayout(new GridLayout(3,3,7,7)); demoframe.add(cpanel,\"Center\"); b =new Button[9]; for(int i=0;i<9;i++) { b[i] =new Button(); b[i].setSize(50,50); b[i].setLabel(Integer.toString(i)); cpanel.add(b[i]); }
demoframe.pack();
demoframe.setVisible(true);
public static void main(String[] args) { Ex9_1 demo =new Ex9_1(); demo.Init(); }
保存程序Ex9_1.java，编译运行程序。理解BorderLayout和GridLayout布局管理器的用法。
4. 结合上述例子，试编写如下图所示的图形界面：
3.2 Java事件
Java中的每种事件类都有一个对应的接口，接口中声明了一个或多个抽象的事件处理方法，凡是需要接收并处理事件对象的类，都需要实现相应的接口。
1. 当用户点击按钮时，AWT事件处理系统将向按钮发送一个ActionEvent
事件对象。如果应该程序需要对此作为反应，那么就需要为按钮注册事件监听程序并实现ActionListenner接口。
计算机实验教学中心 段小林2009年3月修订
在记事本编辑如下源程序： import java.awt.*;
import java.awt.event.*;
public class Ex10_1 implements ActionListener{ private Frame f; private Button b; private Label lb;
public static void main(String[] args) { Ex10_1 demo =new Ex10_1(); demo.Init(); }
public void Init() { f =new Frame(\"Action Event\"); b =new Button(\"确定\"); lb =new Label(\"你好!\ f.add(lb,\"North\"); b.addActionListener(this); f.setSize(150,100); f.add(b,\"South\"); f.setVisible(true); }
public void actionPerformed(ActionEvent parm1) { lb.setText(\"你点击了确认按钮!\"); } }
2. MouseMotionListener接口中提供声明了mouseDragged()和mouseMoved()
两个抽象方法，分别用于处理鼠标的拖动和移动。MouseListener接口声明了mouseEntered()、mouseExited()、mousePressed()、mouseReleased()和mouseClicked()五个抽象方法。
在记事本编辑如下源程序，编译并运行，体会这几种方法的不同之处： import java.awt.*;
import java.awt.event.*;
public class Ex10_2 implements MouseMotionListener,MouseListener{ private Frame f; private Label t1,t2; public static void main(String[] args) { Ex10_2 demo =new Ex10_2(); demo.Init(); } public void Init() { f =new Frame(\"Action Event\"); t1 =new Label(\"Java,\ t2 =new Label(\"你好!\ f.add(t1,\"North\");
计算机实验教学中心 段小林2009年3月修订
} 3. 4.
f.add(t2,\"South\"); f.addMouseListener(this); f.addMouseMotionListener(this); f.setSize(300,200); f.setVisible(true); }
public void mouseClicked(MouseEvent parm1) { t1.setText(\"你点击了鼠标!\"); }
public void mousePressed(MouseEvent parm1) { t1.setText(\"你按下了鼠标!\"); }
public void mouseReleased(MouseEvent parm1) { t1.setText(\"你释放了鼠标!\"); }
public void mouseEntered(MouseEvent parm1) { t1.setText(\"鼠标进入!\"); }
public void mouseExited(MouseEvent parm1) { t1.setText(\"鼠标退出!\"); }
public void mouseDragged(MouseEvent parm1) { t2.setText(\"你在拖动鼠标:X=\"+parm1.getX()+ \" Y=\"+parm1.getY()); }
public void mouseMoved(MouseEvent parm1) { t2.setText(\"你在移动鼠标:X=\"+parm1.getX()+ \" Y=\"+parm1.getY()); }
给程序添加按’ESC’键退出的功能。 根据上述示例，试编写其他实现其他事件接口的程序，如WindowListener、KeyListener等。
计算机实验教学中心 段小林2009年3月修订
实验五、Java Applet的应用
一、实验目的
1. 掌握Applet的主要方法；
2. 掌握Applet的创建方法与运行方式； 3. 掌握Applet参数的传递与使用方法。 二、实验要求
1. 编写Applet测试程序。 三、实验内容
3.1 Applet的生命周期
（1）编辑并编译下列程序：
import java.applet.Applet; import java.awt.*;
public class JLab0901 extends Applet { private int initCnt; private int startCnt; private int stopCnt; private int destoryCnt; private int paintCnt; public LifeCycle() { initCnt = 0; startCnt = 0; stopCnt = 0; destoryCnt = 0; paintCnt = 0; }
public void init() { initCnt ++;
System.out.println(\"init() invoked \" + initCnt + \" time(s).\"); }
public void destroy() { destoryCnt ++;
System.out.println(\"destory() invoked \" + destoryCnt + time(s).\"); }
public void start() { startCnt ++;
System.out.println(\"start() invoked \" + startCnt + \" time(s).\"); }
\" 计算机实验教学中心 段小林2009年3月修订
public void stop() { stopCnt ++;
System.out.println(\"stop() invoked \" + stopCnt + \" time(s).\"); }
public void paint(Graphics g) { paintCnt ++;
System.out.println(\"paint() invoked \" + paintCnt + \" time(s).\"); g.drawLine(20, 200, 300, 200); g.drawLine(20, 200, 20, 20); g.drawLine(20, 170, 15, 170); g.drawLine(20, 140, 15, 140); g.drawLine(20, 110, 15, 110); g.drawLine(20, 80, 15, 80); g.drawLine(20, 50, 15, 50); g.drawString(\"init()\ g.drawString(\"start()\ g.drawString(\"stop()\ g.drawString(\"destory()\ g.drawString(\"paint()\
g.fillRect(25, 200-initCnt*30, 40, initCnt*30); g.fillRect(75, 200-startCnt*30, 40, startCnt*30); g.fillRect(125, 200-stopCnt*30, 40, stopCnt*30);
g.fillRect(175, 200-destoryCnt*30, 40, destoryCnt*30); g.fillRect(235, 200-paintCnt*30, 40, paintCnt*30); } }
（2）编辑下列代码，并保存为JLab0901.html：
（3）使用appletviewer命令运行上述Applet。
（4）随机点击Applet菜单下的“重新启动”、“重新加载”、“停止”、“启动”等菜单项，观察运行结果的变化，并观察命令行方式下的输出信息，对照Applet的生命周期进行理解。
（5）随意缩放Applet窗口大小，“最小化”及“最大化”Applet窗口，观察运行结果的变化，并观察命令行方式下的输出信息，对照Applet的生命周期进行理解。
计算机实验教学中心 段小林2009年3月修订
3.2 Applet的参数传递
（1）编辑、编译及运行下列Applet，并观察结果：
import java.applet.Applet; import java.awt.Graphics;
public class JLab0902 extends Applet { private String s = \"\"; private int x; private int y;
public void init() {
s = getParameter(\"vstring\");
x = Integer.parseInt(getParameter(\"x\")); y = Integer.parseInt(getParameter(\"y\")); }
public void paint(Graphics g) {
if (s!=null) {
g.drawString(s, x, y); }
}
}
JLab0902.html代码：
（2）修改上述代码，使得Applet能够在HTML中给定坐标参数的两点间画一根直线。
计算机实验教学中心 段小林2009年3月修订
实验六、Java IO与异常处理
一、实验目的：
1. 掌握数据流的基本概念。
2. 掌握多种读取/写入数据的方法 3. 掌握异常的基本概念。 4. 理解异常处理机制。
5. 掌握创建自定义异常的方法。 二、实验要求：
1. 编写一个有异常处理的Java应用程序。
2. 编写一个含有读取/写入数据的Java应用程序 三、 实验内容： 3.1 异常处理机制
Java提供了异常处理机制，当程序中发生异常时，程序产生一个异常事件，相应地生成异常对象。系统从生成对象的代码开始，沿方法的调用栈逐层回溯，寻找相应的处理代码，并把异常对象交给该方法处理。 1. 在记事本编辑如下源程序： public class Ex7_1 { public static void main(String[] args) { String output[] ={ \"The \ \"over \ int i =0; while(i<12){ System.out.print(output[i++]); } System.out.println(\"haha...\"); } }
2. 保存程序Ex7_1.java，编译运行程序，观察并分析程序的运行结果。The
quick brown fox jumps over the lazy dog.Exception in thread \"main\" java.lang .ArrayIndexOutOfBoundsException at Ex7_1.main(Ex7_1.java:9)，可以看出，在第9行出现了数组下标越界的异常，导致了程序的中止，而程序的最后一条语句“System.out.println(\"haha...\");”没有执行。
3. 我们修改程序，加入异常处理，当程序发生异常时，经过异常处理后，
程序还可以继续执行。修改代码如下：
public class Ex7_2 {
public static void main(String[] args) { String output[] ={ \"The \ \"over \ int i =0; while(i<12){
计算机实验教学中心 段小林2009年3月修订
try{ System.out.print(output[i++]); } catch(ArrayIndexOutOfBoundsException e) { System.out.println(); System.out.println(\"下标越界异常处理!\"); System.out.println(e.toString()); break; } } System.out.println(\"haha...\"); } }
4. 重新编译运行程序，对比运行结果。在catch后加入：
finally{ System.out.println(\"不管怎样都要执行的语句！\"); }
再重新编译运行，对比运行结果。
5. 除了下标越界的异常外，还有几个常用的异常，如：ArithmeticException、
NullPointerException、NegativeArraySizeException、ArrayIndexOutOfBoundsException
等。试编写一个除数为0的异常处理过程。
6. 除了使用系统定义的异常外，用户还可以自定义异常。其格式为：
public class MyException extends Exception{…}
试自定义一个异常，在计算两个数乘积的方法（Multiply）中，如果结果超过1000则抛出这个异常。方法Multiply定义如下： Static int Multiply(int n,int m) throws MyException{ int re; re =n*m; if(re>1000) throw new MyException(“结果re=”+re+“超过了”+1000); return re; }
完善这个程序，并测试。
3.2 IO处理
1. 编写一个计算器，它从键盘中读取操作数和操作符，经过计算后，在屏
幕上输出结果。
2. 在记事本编辑如下源程序： import java.io.*; class Calculator { public static void main(String[] args) { Calculator cal=new Calculator(); cal.Calculate(); }
计算机实验教学中心 段小林2009年3月修订
public double ReadDouble() { // 从键盘读取一个Double数 double re=0; DataInputStream in =new DataInputStream(System.in); try{ String temp =in.readLine(); re =Double.parseDouble(temp); } catch (IOException e) { System.out.println(\"Error in I/O:\" + e.getMessage()); } return re; }
public void Calculate() { // 计算 byte cmd='q'; do { double op1,op2,re=0; byte op; System.out.print(\"请输入操作数1:\"); op1 =ReadDouble(); System.out.print(\"请输入操作(+、-、*、/):\"); op =ReadByte(); System.out.print(\"请输入操作数2:\"); op2 =ReadDouble(); switch(op) { case '+': re =op1 +op2; break; case '-': re =op1 -op2; break; case '*': re =op1 *op2; break; case '/': re =op1 /op2; break; default: System.out.println(\"操作符错误\"); continue; }
计算机实验教学中心 段小林2009年3月修订
} 3.
System.out.println(\"\"+op1+(char)op+op2+\"=\"+re); System.out.print(\"退出?(Q/q)\"); cmd =ReadByte(); }while(cmd!='Q' && cmd!='q'); }
public byte ReadByte() { // 读操作符 byte cmd[] =new byte[10]; try{ System.in.read(cmd); } catch (IOException e) { System.out.println(\"Error in I/O:\" + e.getMessage()); } return cmd[0]; }
保存程序Calculator.java，编译程序，运行并测试程序。
试编写一个程序完成文件拷贝功能，即从文件A中读取数据，再写到文件A的拷贝——文件B中。
计算机实验教学中心 段小林2009年3月修订
实验七、多线程和数据库编程
一、实验目的：
1. 掌握线程的基本概念。
2. 掌握线程的创建、启动、结束的方法。 3. 理解线程的同步和死锁。 4. 掌握数据库的基本操作。 5. 掌握简单的SQL。 6. 掌握JDBC编程技术。 二、实验要求：
编写一个含有多个线程的程序。
编写一个通过数据库验证用户ID和密码的登录程序。 三、实验内容： 3.1 多线程
多线程允许在程序中并发执行多个指令流，每个指令流都称为一个线程，彼此间互相独立。线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。
Java提供了类 java.lang.Thread 来方便多线程编程，这个类提供了大量的方法来方便我们控制自己的各个线程。有两种方法创建线程：1. 继承 Thread 类，覆盖方法 run();2. 实现 Runnable 接口。
Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。
1. 编写一个有两个线程的程序，一个线程对数据执行加法操作，另外一个
执行减法操作。能控制线程的起停。 2. 在记事本编辑如下源程序： import java.awt.*; import java.util.*;
import java.awt.event.ActionListener; import java.awt.event.ActionEvent; class Data { private int data=100; public int getData(){ return data; } public void setData(int d){ data =d; } }
计算机实验教学中心 段小林2009年3月修订
class AThread extends Thread{ Label dis; Data data; AThread(Label ds,Data dt){ dis =ds; data =dt; } public void run(){ Random ran =new Random(); while(true){ synchronized(data){ String s =\"线程A处理:\"+data.getData()+\"+1= \"; data.setData(data.getData()+1); dis.setText(s+data.getData()); System.out.println(s+data.getData()); } try{ sleep(ran.nextInt(3)*1000); } catch(InterruptedException e){} } } }
class BThread extends Thread{ Label dis; Data data; BThread(Label ds,Data dt){ dis =ds; data =dt; } public void run(){ Random ran =new Random(); while(true){ synchronized(data){ String s =\"线程B处理:\"+data.getData()+\"-1= \"; try{ sleep(2000); } catch(InterruptedException e){} data.setData(data.getData()-1); dis.setText(s+data.getData()); System.out.println(s+data.getData()); } try{
计算机实验教学中心 段小林2009年3月修订
sleep(ran.nextInt(6)*1000); } catch(InterruptedException e){} } } }
class Ex13 extends Frame implements ActionListener{ Label dis; Data data; AThread at; BThread bt; Button b; Ex13(){ dis =new Label(); data =new Data(); b =new Button(\"暂停\"); b.addActionListener(this); add(dis,\"Center\"); add(b,\"South\"); } public void go(){ at =new AThread(dis,data); bt =new BThread(dis,data); at.start(); bt.start(); b.setLabel(\"暂停\"); } public static void main(String args[]) { Ex13 mainFrame = new Ex13(); mainFrame.setSize(300, 200); mainFrame.setTitle(\"Ex13\"); mainFrame.setVisible(true); mainFrame.go(); } public void actionPerformed(ActionEvent parm1) { if(parm1.getActionCommand() ==\"暂停\") { at.suspend(); bt.suspend(); b.setLabel(\"开始\"); } else { at.resume();
计算机实验教学中心 段小林2009年3月修订
保存程序Ex13.java，编译运行程序，观察执行结果，理解程序中的同步机制。
4. 去掉程序中的synchronized(data)，（共有两处），重新编译运行程序，对
比结果有什么不同。
5. 试用创建线程的方法2，即实现 Runnable 接口，改写该程序。 3.2数据库编程
Java数据库连接（JDBC）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一的访问接口，它通常有三方面的用途：(1)与数据库建立连接；（2）向数据库发生SQL语句；（3）处理数据库操作返回的结果。
1. 建立数据库。用Access建立一个名为database.mdb的数据库，在库中添
加一个名为User的表，在表中添加两字段：（1）UserID，文本类型；（2）Passwd，文本类型。
2. 添加数据。在User表中添加几条记录。
3. 配置数据源。打开控制面板的ODBC数据源，如下图：
} 3.
}
}
bt.resume();
b.setLabel(\"暂停\");
添加一个名为LoginInfor的数据源，指定第一步生成的database.mdb数据库为数据源的数据库，如下图：
计算机实验教学中心 段小林2009年3月修订
并在高级中设置登录名称为：sys，密码为：123。如下图：
4. 在记事本编辑如下源程序： import java.awt.*;
import java.awt.event.*; import java.sql.*;
import java.awt.event.ActionListener; import java.awt.event.ActionEvent; class myDialog extends Dialog{ Label tip; myDialog(Frame f,String s,boolean b){ super(f,s,b); tip =new Label(\"用户名或密码不对!\"); add(\"Center\
计算机实验教学中心 段小林2009年3月修订
pack(); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { setVisible(false); } }); } public void setLabelText(String s){ tip.setText(s); } }
class Ex14 extends Frame implements ActionListener { Button b1,b2; TextField ut,pt; Connection con =null; Statement stm=null; myDialog d; public Ex14() { addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { dispose(); System.exit(0); } }); } public static void main(String args[]) { System.out.println(\"Starting Ex14...\"); Ex14 mainFrame = new Ex14(); mainFrame.Init(); mainFrame.pack(); mainFrame.setTitle(\"Ex14\"); mainFrame.setVisible(true); } public void Init() { setLayout(new GridLayout(3,2,7,7)); b1 =new Button(\"登录\"); b2 =new Button(\"添加\"); ut =new TextField(); pt =new TextField(); pt.setEchoChar('*'); add(new Label(\"用户ID:\ add(ut); add(new Label(\"密码:\
计算机实验教学中心 段小林2009年3月修订
add(pt); add(b1); add(b2); b1.addActionListener(this); b2.addActionListener(this); d =new myDialog(this,\"登录\ try{ Class.forName(\"sun.jdbc.odbc.JdbcOdbcDriver\"); } catch(ClassNotFoundException e){} }
public void login(){ String sql =\"select * from user where UserID ='\" +ut.getText()+\"' and Passwd ='\"+pt.getText()+\"'\"; try{
con =DriverManager.getConnection(\"jdbc:odbc:LoginInfor\ stm =con.createStatement(); ResultSet rs =stm.executeQuery(sql); if(rs.next()){ d.setLabelText(rs.getString(\"UserID\")+\登录成功!\"); d.setVisible(true); } else{ d.setLabelText(\"用户名或密码不对!\"); d.setVisible(true); } rs.close(); stm.close(); con.close(); } catch(SQLException ee){} }
public void append(){ String sql =\"insert into user values('\"+ ut.getText()+\"','\"+pt.getText()+\"')\"; try{
con =DriverManager.getConnection(\"jdbc:odbc:LoginInfor\ stm =con.createStatement(); stm.executeUpdate(sql); d.setLabelText(ut.getText()+\添加成功!\"); d.setVisible(true); stm.close(); con.close(); }
计算机实验教学中心 段小林2009年3月修订
} 5. 6.
catch(SQLException ee){ d.setLabelText(ut.getText()+\添加失败!\"); d.setVisible(true); } }
public void actionPerformed(ActionEvent parm1) { if(parm1.getSource()==b1){ login(); } else if(parm1.getSource()==b2){ append(); } }
保存程序Ex14.java，编译运行程序，并测试。 试编写删除和修改记录的操作。
计算机实验教学中心 段小林2009年3月修订
实验八、网络Socket编程
一、实验目的：
1. 了解网络通信的基本原理。 2. 掌握Socket通信的基本步骤。 3. 掌握Socket网络编程的方法。 二、实验要求：
编写包含客户端和服务器的网络通信程序。 三、实验内容：
Java为用户提供了十分完善的网络功能，通过Socket进行网络通信有下面几个个步骤：（1）服务器先打开处于监听状态的Socket，并等待客户端建立连接。（2）客户端打开Socket并和服务器建立连接。（4）服务器接受连接请求。（4）客户端和服务器分别将特定的输入输出流连接到打开的Socket。（5）通过输入输出流进行网络通信。
1. 先编写服务器端的服务程序。在记事本编辑如下源程序： import java.awt.*;
import java.awt.event.*;
import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.net.*; import java.io.*;
class ReceiveThread extends Thread{ DataInputStream in =null; TextArea RecTxt; ReceiveThread(DataInputStream inx,TextArea t1){ in =inx; RecTxt =t1; } public void run(){ while(true){ try{ RecTxt.append(in.readUTF()+\"\\n\"); } catch(IOException e){} } } }
class AcceptThread extends Thread{ ServerSocket s; Socket rs =null; ReceiveThread rt=null; TextArea RecTxt; DataOutputStream out =null;
计算机实验教学中心 段小林2009年3月修订
DataInputStream in =null; AcceptThread(ServerSocket s1,TextArea t1){ s =s1; RecTxt =t1; } public void Close(){ try{ in.close(); out.close(); rt.stop(); rs.close(); } catch(IOException e){} } public DataOutputStream GetOut(){ return out;} public void run(){ while(true){ try{ rs =s.accept(); if(rs!=null){ in =new DataInputStream(rs.getInputStream()); out =new DataOutputStream(rs.getOutputStream()); rt =new ReceiveThread(in,RecTxt); rt.start(); out.writeUTF(\"Hello!\"); RecTxt.append(\"Accept Success!\\n\"); } } catch(IOException e){} } } }
class Server extends Frame implements ActionListener { Panel p1,p2,p3; TextArea smsg,rmsg; Button b2,b3; ServerSocket s; AcceptThread at; public Server() { addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { dispose();
计算机实验教学中心 段小林2009年3月修订
}
} });
System.exit(0);
public static void main(String args[]) { System.out.println(\"Starting Server...\"); Server mainFrame = new Server(); mainFrame.Init(); mainFrame.pack(); mainFrame.setTitle(\"Server\"); mainFrame.setVisible(true); }
public void Init() { p1 =new Panel(); p1.setLayout(new GridLayout(2,2,2,2)); smsg =new TextArea(5,40); rmsg =new TextArea(5,40); rmsg.enable(false); p1.add(rmsg); p1.add(smsg); add(\"North\ p3 =new Panel(); b2 =new Button(\"发送\"); b2.addActionListener(this); p3.add(b2); b3 =new Button(\"断开\"); b3.addActionListener(this); p3.add(b3); add(\"South\ try{ s =new ServerSocket(20000); at =new AcceptThread(s,rmsg); at.start(); System.out.println(\"监听在20000端口...\"); } catch(IOException e){} }
public void actionPerformed(ActionEvent parm1) { if(parm1.getSource() ==b2){ SendData(); }
计算机实验教学中心 段小林2009年3月修订
else if(parm1.getSource() ==b3){ Close(); } } public void Close(){ at.Close(); } public void SendData(){ String msg =smsg.getText(); if(msg!=null){ try{ at.GetOut().writeUTF(msg); } catch(IOException e){}; } } }
2. 保存程序Server.java。
3. 再编写客户器端程序。在记事本编辑如下源程序： import java.awt.*;
import java.awt.event.*;
import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.net.*; import java.io.*;
class ReceiveThread extends Thread{ DataInputStream in =null; TextArea RecTxt; ReceiveThread(DataInputStream inx,TextArea t1){ in =inx; RecTxt =t1; } public void run(){ while(true){ try{ RecTxt.append(in.readUTF()+\"\\n\"); } catch(IOException e){} } } }
class Client extends Frame implements ActionListener { Panel p1,p2,p3;
计算机实验教学中心 段小林2009年3月修订
TextArea smsg,rmsg; TextField host,port; Button b1,b2,b3; Socket s;
DataOutputStream out =null; DataInputStream in =null; ReceiveThread rt=null; public Client() { addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { dispose(); System.exit(0); } }); }
public static void main(String args[]) { System.out.println(\"Starting Client...\"); Client mainFrame = new Client(); mainFrame.Init(); mainFrame.pack(); mainFrame.setTitle(\"Client\"); mainFrame.setVisible(true); }
public void Init() { p1 =new Panel(); p1.setLayout(new GridLayout(2,2,2,2)); smsg =new TextArea(5,40); rmsg =new TextArea(5,40); rmsg.enable(false); p1.add(rmsg); p1.add(smsg); add(\"North\ p2 =new Panel(); p2.add(new Label(\"IP地址:\")); host =new TextField(15); p2.add(host); p2.add(new Label(\"端口:\")); port =new TextField(5); p2.add(port); add(\"Center\ p3 =new Panel(); b1 =new Button(\"连接\");
计算机实验教学中心 段小林2009年3月修订
}
b1.addActionListener(this); p3.add(b1);
b2 =new Button(\"发送\"); b2.addActionListener(this); p3.add(b2);
b3 =new Button(\"断开\"); b3.addActionListener(this); p3.add(b3);
add(\"South\
public void actionPerformed(ActionEvent parm1) { if(parm1.getSource() ==b1){ Connect(); } else if(parm1.getSource() ==b2){ SendData(); } else if(parm1.getSource() ==b3){ Close(); } }
public void Connect(){ try{ s =new Socket(host.getText(),Integer.parseInt(port.getText())); if(s!=null){ in =new DataInputStream(s.getInputStream()); out =new DataOutputStream(s.getOutputStream()); rt =new ReceiveThread(in,rmsg); rt.start(); out.writeUTF(\"Hello!\"); rmsg.append(\"连接成功!\\n\"); } } catch(IOException e){} }
public void Close(){ try{ in.close(); out.close(); rt.stop(); s.close(); } catch(IOException e){}
计算机实验教学中心 段小林2009年3月修订
} 4. 5. 6.
}
public void SendData(){ String msg =smsg.getText(); if(msg!=null){ try{ out.writeUTF(msg); } catch(IOException e){}; } }
保存程序Client.java。
编译运行服务器端的服务程序，等待客户端建立连接。
编译运行客户端程序，输入运行服务程序主机的IP地址（如果客户端的程序和服务器的服务程序在同一台主机上运行，就输入本机的IP地址）和端口号20000，建立连接。
7. 彼此间发送消息相互通信。如下图所示：
计算机实验教学中心 段小林2009年3月修订
实验九、综合实验
一、实验目的：
1. 运用所学Java编程知识，解决实际问题。 2. 综合所学内容，达到灵活运用的目的。 二、实验要求：
编写一个综合应用程序。 三、实验内容：
1. 结合前几次实验的内容（如实验十四的数据库、实验十五的网络等），编
写一个登录验证程序，即把实验十四的本地登录验证程序改写为网络登录验证，它由两部分构成：服务器端和客户端。
2. 服务器端包含一个存储用户资料的数据库，它一直处于监听状态（可以
不用图形界面），等待客户端传送用户的验证资料（用户ID和密码），查找用户资料数据库，并返回验证结果（失败or成功）。 3. 客户端用图形界面接受用户的输入（用户ID和密码），并把输入的数据
（用户ID和密码）通过网络传到服务器端，最后向用户显示登录结果。界面如下图所示：
4. 单击取消按钮或者按ESC键退出程序。 5. 编辑、编译、运行并测试程序。
因篇幅问题不能全部显示，请点此查看更多更全内容