《Java语言程序设计实验指导书》实验指导书

《Java语言程序设计实验指导书》实验指导书

高川翔 2012年2月

一、实验的地位、作用

Java语言程序设计实验作为课程实践性环节之一，是教学过程中必不可少的重要内容。通过计算机实验和案例分析，使学生加深理解、验证巩固课堂教学内容；增强高级语言程序设计的感性认识；掌握程序设计的基本方法；培养学生理论与实践相结合的能力。

二、实验开设对象

本实验开设对象为《Java语言程序设计》课程的学习者（信息与计算科学专业本科生），实验为必修内容。

三、基本原理及课程简介

Java语言程序设计是必修基础课程。本课程以BlueJ为工具，主要介绍面向对象的程序设计方法，Java面向对象程序设计语言和面向对象程序设计工具。使学生掌握面向对象的思想方法，是后续专业课程的基础。

四、指导教师

原则上由Java语言程序设计讲授教师负责，由年轻教师担任主要的实验指导教师，实验室人员配合指导。指导教师应在每次实验前讲清实验目的、基本原理、实验要求等，指导学生在规定的时间内完成相关课程实验。

五、实验设备配置

每人配置1台电脑，安装有JDK，以及Blue J、Eclipse或者JBuilder。

六、考核与报告

1．实验后，学生将实验结果等内容写出实验报告，符合实验教学的要求，并得到指导教师的认可。

1

2．指导教师对每份实验报告进行审阅、评分。

3．该实验程依附于理论课，实验课的成绩记入课程平时成绩，占总成绩的25%

2

实验一 Java运行环境的安装、配置与运行

一、实验课时

3课时。

二、实验目的

1． 掌握下载并安装 JDK 软件包的方法。

2． 掌握在BlueJ环境下编写、编译与运行 Java 程序的方法。 3． 了解 Java 语言的概貌。

4． 了解设置环境变量，命令行编译java程序的方法。

三、实验内容和要求 内容：

1．安装 JDK 软件包和BlueJ开发环境并进行配置。

（1） 配置JDK运行环境：

a) 配置windows的path环境变量。将安装的J2SDK（注意：必须安装J2SDK）的

bin文件夹的完整路径添加到path系统变量中，如图3－4所示。

图1－1 path系统变量的配置

b) 配置CLASSPATH系统变量。如果系统变量中不存在classpath，则“新建”之。

将J2SDK的lib文件夹的完整路径写入。如图3－5。

图1－2 CLASSPATH系统变量的配置

3

（2） （3） （4） （5） 进入DOS虚拟环境；

将实验1的程序保存在d：\\example文件夹下； 使用javac命令编译程序；（如图3－6）

使用java运行程序。注意包中程序的编译与运行方法。

图1－3 利用JDK环境编译运行Java应用程序

(以下实验前请仔细阅读BlueJ教程的电子文档)

2．在BlueJ环境下新建一个工程，在工程中编写一个简单的 Java 程序，在屏幕上输出”hello,java!”。 public class Hello {

public static void main(String args[]) {

System.out.println(\ } }

3．编译运行 Java 程序。

4．设置环境变量，在命令行下编译运行Java程序。 5．浏览运行JDK 自带的 Applet 应用小程序。 6．在程序中设置断点、单步执行、查看变量值。

4

要求：

1、独立完成；并以实际上机操作计成绩；

2、所有上机实验必须在下一次实验之前完成，否则此次实验成绩算0分； 3、编写实验报告（按照报告模板编写，必须写出详细的实验步骤及必要的屏

幕截图）。

5

实验二 创建一个Applet

一、实验课时

3课时。

二、实验目的

了解Applet与Application的区别，学会设计Applet程序。

三、实验内容和要求

已知JButton类有一个构造函数原形为： public JButton(String text,Icon icon)。

其中参数text为显示在按钮上的文本、参数icon为显示在按钮上的图标。下面的例子就是利用此构造函数产生一个带有文本、图标的按钮，并且当按一下按钮，图标就切换一次。此图标切换是在两个图标中循环进行的。程序如下： import javax.swing.*; import java.awt.*; import java.awt.event.*;

public class ButtonExample extends JApplet{ int imageNum=1; public void init( ){

Container con = getContentPane( );

final JButton jb_ok=new JButton(″按我″,new ImageIcon(″sun1.gif″)); con.setLayout(new FlowLayout()); con.add(jb_ok);

jb_ok.addActionListener(new ActionListener( ){ public void actionPerformed(ActionEvent e){ if(imageNum = =1){

6

jb_ok.setIcon(new ImageIcon(″sun2.gif″)); imageNum=2; } else{

jb_ok.setIcon(new ImageIcon(″sun1.gif″)); imageNum=1; } } }）； } }

此程序中还用到了JButton类的setIcon( )方法，用以设置按钮的新的图标。 Html文件代码： （文件名为Appcounter.htm）

将该文件与ButtonExample.class保存在同一个目录中，使用appletviewer appconmter.htm命令就可以运行这个applet。 要求：

1、独立完成；并以实际上机操作计成绩；

2、所有上机实验必须在下一次实验之前完成，否则此次实验成绩算0分； 3、编写实验报告（按照报告模板编写，必须写出详细的实验步骤及必要的屏

幕截图）。

7

实验三 数据类型及表达式

一、实验课时

3课时。

二、实验目的

1．掌握Java语言的基本数据类型，了解数据类型包装类的概念。 2．掌握变量和表达式的用法。 3．理解类型转换的概念。

三、实验内容和要求

1． 输入并运行下面的程序，体会各种基本数据类型的变量的声明、初始化及使用。

public class BasicTypes{

public static void main(String args[]) { byte b = 0x88; short s = 0200; int i = 111111; long l = 0x111111111; char c ='A'; float f =.33f; double d =.00001001; boolean bl= true;

System.out.println(″byte b =″+b); System.out.println(″short s =″+s); System.out.println(″int i =″+i); System.out.println(″long 1 =″+1); System.out.println(″char c =″+c); System.out.println(″float f =″+f); System.out.println(″double d =″+d); System.out.println(″boolean bl =″+bl);

8

} } 思考：

（1）上述程序中定义了哪些变量？每个变量的变量名、数据类型和作用域分别是什么？

（2）查看程序的运行结果，分析为什么有些变量最后输出的结果和初始化时的不同？

2． 输入并运行下面的程序并分析结果，体会各种表达式的使用方法。（1）public class ArithmaticOp{

public static void main(String args[ ]){ int a =5, b=3,c; double d=2.5; c=a/b+a%b;

System.out.println(″c=″+c); d=c*b+a/b*d;

System.out.println(″d=″+d); } }

（2） public class ArithmaticOp2{

public static void main(String args[ ]) { int a,b,c; a=b=c=5; a=++b－++c;

System.out.println(″a=″+a+″b=″+b+″c=″+c); a=b+++c++;

System.out.println(″a=″+a+″b=″+b+″c=″+c); a=b――+c――；

System.out.println(″a=″+a+″b=″+b+″c=″+c; } }

9

（3） public class LogicOp{

public static void main(String args[ ]){ boolean x, y;

x=5>3‖3*4<6&&!(5<3); y=2= =6&&9>8+4||5+6<7+4&&!x;

Systeme.out.println(″x=″+x+″,y=″+y); } } 思考：

（1）上述程序中用到了哪些运算符？运算符的优先级如何？

（2）增一和减一运算符（++和－－）放在变量和放在变量之后，其用法有何不同？

（3）将你分析程序得到的结果与实际的运行结果相比较，如果有不同，原因在哪里？

3． 输入并运行下面的程序，分析结果，了解并掌握自动类型转换用法。 public class Promotion{

public static void main(String args[ ]){ byte b=10; char c=′a′; int i =90; long l=5551; float f =3.5f; double d = 1.234;

float f1=f*b; //float*byte―>float int i1 = c+i; //char+int―>int long l1 = 1+i1; //long+int―>long

double d1 =f1/i1－d; //float/int―>float,float―double―>double System.out.println(″f1=″+f1); System.out.println(″il=″+il); System.out.println(″l1=″+l1);

10

System.out.println(″d1=″+d1); } } 思考：

（1）上面的程序用到了哪些自动类型转换？分别是如何实现的？

（2）何时需要用到强制类型转换？强制类型转换可能会造成什么不良后果？ 提高：

1．在Java中，数据类型包装类（type wrapper class）用于封装基本数据类型的有关信息和操作。虽然我们经常直接使用Java的基本数据类型，但由于它本身不具备任何操作，无法扩充自身功能，因此，为确保Java语言的纯面向对象特性，Java的语言基础包为数据类型提供了一些对象封装。

数据类型包装类是由多个类组成的一个集合，每种数据类型均存在相应的对象封装类。

下表列出了Java的数据类型包装及其对应的基本数据类型。 基本数据类型 数据类型包装类

byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean

每一个类都提供了一些属性和方法，用户可以根据需要来灵活使用。

注意：数据类型包装类与相应的基本数据类型名字几乎相同，请不要混淆。前者的显著特点是第一个字母应为大写。

11

2．输入并运行下面的程序，了解并掌握数据类型包装类的属性和用法。 public class MaxVariables{

public static void main(String args[ ]){ //integers

byte largestByte =Byte.MAX_VALUE;

//MAX_VALUE是Byte类的属性（表示Byte类所能达到的最大值） short largestShort = Short.MAX_VALUE; int largestInteger = Integer.MAX_VALUE; long largestLong = Long.MAX_VALUE; //real numbers

float largestFloat = Float.MAX_VALUE; double largestDouble = Double.MAX_VALUE; //other primitive types char aChar=′S′; boolean aBoolean =true; //display them all

System.out.println(″The largest byte value is″+largestByte); System.out.println(″The largest short value is″+largestShort); System.out.println(″The largest integer value is″+largestInteger); System.out.println(″The largest long value is″+largestLong); System.out.println(″The largest float value is″+largestFloat); System.out.println(″The largest double value is″+largestDouble); //Character类有一个方法boolean isUpperCase(char ch)是用来判断一个字符是 //否是大写

if(Character.isUpperCase(aChar)){

System.out.println(″The character″+aChar+″is upper case. ″); }else{

System.out.println(″The character″+aChar+″is lower case. ″); }

12

System.out.println(″The value of aBoolean is″+aBoolean); } }

（1）修改上面的程序，让它能输出每种整型数据类型能表示的最小值。（提示：Byte类型的最小值属性是MIN_VALUE）

（2）Character类有另一个方法boolean isLowerCase(char ch),可以来判断一个字符是否为小写。修改适当的语句，使程序完成相同的功能。 （3）修改上面的程序，使布尔型变量aBoolean具有一个不同的值。 要求：

1、独立完成；并以实际上机操作计成绩；

2、所有上机实验必须在下一次实验之前完成，否则此次实验成绩算0分； 3、编写实验报告（按照报告模板编写，必须写出详细的实验步骤及必要的屏幕截图）。

13

实验四 控制流程

一、实验课时

3课时。

二、实验目的

1．充分掌握流程控制语句的格式和功能。 2．熟练运用流程控制语句进行程序设计。 3．学会进行简单的程序调试。

三、实验内容和要求

1．输入并运行下面两个程序： （1）public class WhileDemo2{

public static void main (String[ ]args){ int i =100; while(i＜100{

System.out.println(″Print″+i); i++; } } }

(2) public class DoWhileDemo2{

public static void main (String[ ]args){ int i =100; do{

System.out.println(″Print″+i); i++

} while(i<100); } } 思考：

14

运行上面两个程序，比较While和DoWhile语句的执行过程有何不同。 2．输入并运行下面的程序： public class lxsum{

public static void main (String[ ]args){ int i =1,sum; sum=0;

while(i<=100){ sum+=i; i++ }

System.out.println(″sum=″+sum); } } 思考：

（1）循环一般适用于什么情况？

（2）请用for循环和do-while循环为实现上面的程序的功能。 3．输入并运行下面的程序，体会switch语句的使用。 public class lxswitch{

public static void main (String [ ]args){ int x=1,y=2,i=0,j=0; switch(x){

case 1: switch(y){ case 1: i+ +; break; case 2:j++; break; default: i+ +; j++; }

case2: i+ +;j++;break; default: i++;j++; }

15

System.out.println(″i=″+i); Sysem.out.printin(″j=″+j); } } 思考：

（1）将你分析程序得到的结果与实际的运行结果相比较，看看有没有什么不同。如果有不同，原因在哪里？

（2）break语句在switch语句中起到了什么作用？

4． 输入并运行下面的程序，判断某一年是否是闰年。闰年的条件是符合下面二者之一：

（1）能被4整除，但不能被100整除； （2）能被4整除，又能被400整除。

public class JudgeLeapYear{

public staic void main (String args[ ]){ //方法1 int year=1800;

if((year%4= =0 && year0!=0)||(year@0= = 0)) System.out.println(year+″年是闰年″)； else

System.out.println(year+″年不是闰年″); //方法2 year = 1997; boolean leap; if(year%4!=0) leap=false;

else if (year0!=0) leap = true; else if(year@0!=0) leap = false;

16

else

leap = true; if (leap = = true)

System.out.println(year+″年是闰年″)； else

System.out.println(year+″年不是闰年″) //方法3 year=2000; if (year%4= = 0){ if (year0= =0){ if (year@0= =0) leap=true; else

leap=false; }else

leap = false; }else

leap = false; if (leap = = true)

System.out.println(year+″年是闰年″)； else

System.out.prinln(year+″年不是闰年″)； } } 思考：

（1）程序中是如何判断一个数能被另一个数整除的？

（2）请说出程序中用了哪三种方法来判断是否闰年，并体会其中的联系和区别。 提高：

17

在输入程序的过程中难免要出错。一般说业，程序中的错误有两种：语法错误和逻辑错误。程序调试就是要找出程序中的错误，编出正确的程序。

下面的程序用来输出5次\！\，请更正程序中的错误，并上机调试运行。 public class Hello {

public static void main(String[ ]args){ for(i=1;i<5;i++); {

System.out.println(″time″+i+″:Hello! ″); } } }

在MS-DOS下编译该程序，输入javac Hello. java,屏幕上会出现如下错误信息： Hello.java:5:Undefined variable:i for (i=1;i<5;i++); ?

Hello.java:5:Undefined variable:i for(i=1;i<5;i++);

Hello.java:5:Undefined varable:i for (i=1;i<5;i++) ?

Hello.java:7:Undefined variable:i

System.out.println(″time″+i+″:Hello″); 4errors

可以看到，Java中的错误信息包含如下内容： （1）源程序文件名； （2）出错那一行的行号； （3）出错的类型； （4）出错那一行的内容。

18

根据系统给出的错误信息，可以进行相应的修改。如上面的几个错误，类型都是\也就是说，变量i尚未定义。于是就可以分析出出错的原因是程序中没有声明变量i就直接使用了它，就是一个语法错误，在源程序中进行相应的修改。修改过的程序内容如下: public class Hello{

public static void main (String[ ]args) { int i; //新添的变量说明 for (i=1;i<5;i + +){

System .out. println(″time″+i+″:Hello! ″) } } }

对上面的程序再进行编译，顺利通过（屏幕没有出现任何信息）后生成相应的.class文件。运行该文件，结果为： time 5:Hello!

只输出了一次\与题目的要求（输出5次\）不符，这是一个逻辑错误。分析结果，发现它只执行了i为5的那一次输出。再次检查程序，发现在for语句的圆括号后面多了一个分号，造成了for语句的循环体实际为空语句。从源程序中将\；\去掉，重新存盘、编译、运行。结果如下： time1:Hello! time2:Hello! time3:Hello! time4:Hello!

发现还少输出一次\！\，将循环变量的结束条件为\，重新存盘、编译，运行正确。 思考：

（1）变量i在程序中起到什么作用？

（2）如果将i的初值改设为0，那么应如何改写终止循环的条件？ （3）如果将i的初值改设为3，那么应如何改写终止循环的条件？

19

要求：

1、独立完成；并以实际上机操作计成绩；

2、所有上机实验必须在下一次实验之前完成，否则此次实验成绩算0分； 3、编写实验报告（按照报告模板编写，必须写出详细的实验步骤及必要的屏幕截图）。

20

实验五 数组

一、实验课时

3课时。

二、实验目的

1．掌握Java中数组的声明、创建、初始化和使用。 2．了解Java中提供的对数组排序的常用方法。 3．了解在数组中查找一个特定的值的常用方法。

三、实验内容和要求

1．数组元素的排序是一个经常会遇到的问题，冒泡（起泡）排序法（bubble sort）是一种常用的排序方法。它的基本思想是：对一个具有n个元素的数组，首先将第一个元素的值和第二个元素的值进行比较，若为逆序（即第一个元素的值大于第二个元素的值），则将两个元素交换之，然后比较第二个元素和第三个元素的值，依次类推，直到第n－1个元素和第n个元素进行比较、交换为止。如此经过一趟排序，使得值最大元素被安置到最后一个元素的位置上。然后，对前n－1个元素进行同样的操作，则具有次大值的元素被安置在第n－1个元素的位置上。重复以上过程直到没有元素需要交换为止。此过程可图示如下： 初始数组元素： [49 38 65 97 76 13 27] 第1趟排序之后：[38 49 65 76 13 27] 97 第2趟排序之后：[38 49 65 13 27] 76 97 第3趟排序之后：[38 49 13 27] 65 76 97 第4趟排序之后：[38 13 27] 49 65 76 97 第5趟排序之后：[13 27] 38 49 65 76 97 第6趟排序之后：13 27 38 49 65 76 97

在此过程中，值小的数组元素好比水中气泡逐趟向上飘浮，而值大的数组元素好比石块沉入水底。下面的代码是冒泡排序法的程序实现，请输入并运行之:

public class BubbleSort{

21

public static void main (String args[ ]){ int i,j;

int intArray[ ] ={30,1,-9,70,25}; int 1=intArray .length; for(i=1;i<1;i++) for(j=0;j<1-i-1;j+ +)

if(intArray[j]>intArray[j+1]){ int t =intArray[i]; intArray[j]=intArray[j+1]; intArray[j+1]=t; }

for(i=0;i<1;i++)

System.out.println(intArray[i]+″″)； } } 思考：

（1）什么情况下使用数组比较合理？

（2）为什么要用双重循环来实现此算法？循环变量i和j是如何来确定范围的？

（3）如何来交换两个数组元素的值？

2．试着修改上面的程序，改为对一维数组中的元素按值从大到小进行排序，并输出最终结果。

3．我们经常需要在数组中查找一个特定的值。对于已排好序的数组来说，二分查找法（折半查找法）是一种比较快捷的方法。二分查找法的基本思路是：先将整个数组作为查找区间，用给定的值与查找区间的中间元素的值相比较，若相等，则查找成功；若不等，则缩小范围，判断该值落在区间的前一部分还是后一部分，再将其所在的部分作为新的查找区间。继续上述过程，一直到找到该值或区间大小小于0表明查找不成功时为止。请输入并运行下面的程序，体会二分查找法的算法的实现方式。 public class arrayBinary{

22

public static int bsearch(int array[ ],int value){ boolean found = false; int high =array.length-1; int low =0; int cnt =0;

int mid =(high+low)/2;

System.out.println(″Looking for″+value); while (!found &&(high> =low)){

System.out.println(″Low″+low+″Mid″+mid+″High″+high); if(value= =array[mid]) found=true; else

if(value

low =mid+1; mid= (high+low)/2; cnt + +; }

System.out.println(″Steps″+cnt); retrun ((found)?mid:-1)； }

public static void main(String args[ ]){ int a[ ]=new int [100]; for (int i=0;i

System.out.println(″Result″+bsearch(a,32)); System.out.println(″Result″+bsearch(a,1)); System.out.println(″Result″+bsearch(a,1031)); }

23

} 思考：

（1）程序中整型变量high、low、mid、cnt分别起什么作用？布尔型变量found又起到什么作用？

（2）该程序是如何确定查找区间范围的？

（3）该程序先定义了一个bsearch方法，然后在main（）中多次调用该方法，请说出这样做有什么优点。

4．编程实现在无序数组中顺序查找一个特定的值，找到则返回该值在数组中的位置（下标），找不到则返回-1。（想想，为什么用负值用为返回标志？）

提示：数组中的元素是无序的，因此搜索范围一定要是整个数组。 5．输入并运行下面的程序，体会二维数组的用法。 class MaxMatrix{

public static void main(String args[ ]){ int row =0;

int col=0; //放行号和列号 int max;

int m[ ] [ ] ={{6,2,3,24},{-5，8，7，6}，{-3，18，-4，1}}； max =m[0] [0];

for (int i=0;i<=2;i++){ if(m[ i] [j ]>max){ max =m[i] [j]; row =i ; col = j; } }

System.out.println(″最大的元素的值为：″+max)；

System.out.println(″该元素的位置在：″+row+″行，″+col+″列″)； }

24

}

6．修改上面的程序，改为求矩阵中最小的那个元素的值，以及其所在的行号和列号。 提高：

1．在Java中对数组进行排序，可以使用如下步骤：

（1）使用import java.util.*语句，可以让java.util包中的所有的类在程序中都可以使用； （2）创建一个数组；

（3）使用Arrays类的sort( )方法来重新调整一个数组的数据。 用Arrays类的sort( )方法排过序的数组元素将被调整为按升序排列。 import java.util.*; //让java.util包中的所有的类在程序中都可以使用

class SortName{

public static void main(String args[ ]){

String names[ ]= {″Akbar″，″Umberto″，″Peter″，″Zemo″，″Digo″}；

System.out.println(″数组元素原来的顺序是：″)； for (int i =0;i

Arrays.sort(names); //使用Arrays类的sor（）方法为数组names排序

System.out.println(″数组元素现在的顺序是：″)； for (int i =0;i

System.out.println(i+″： ″+names[i]); } }

2.建立一个字符串数组并按升序进行排序。 3.建立一个浮点型数组并按升序进行排序。 要求：

25

1、独立完成；并以实际上机操作计成绩；

2、所有上机实验必须在下一次实验之前完成，否则此次实验成绩算0分； 3、编写实验报告（按照报告模板编写，必须写出详细的实验步骤及必要的屏幕截图）。

26

实验六 类

一、实验课时

3课时。

二、实验目的

1．掌握如何定义类。

2．掌握如何定义类的成员变量、成员方法。 3．掌握如何创建对象。 4．掌握关键字static的用法。 5．掌握类成员的访问权限。

三、实验内容和要求

1．下面是一个教师类Teacher，用于学校某个系部的管理。系部在管理教师时，所关心的信息主要有教师编号、姓名、性别、年龄、家庭住址、电话号码等，于是抽取这些属性来描述\教师\这个实体。考虑到教师年龄、家庭住址、电话号码等不宜对无关人员公开，于是将这些数据设为私有的成员变量（即实行保护）。要获得这些数据，必须使用类所提供的一组方法，并给出口令。检查口令是否正确是由私有方法checkPasswork完成的。阅读并编译这一程序，体会类的成员变量、类的方法以及访问权限的设计。 class Teacher { //定义教师类 //声明成员变量

String tCode; //教师编号 String tName; //教师姓名 String tSex; //教师性别

private String tAge; //教师年龄 private String tAddr; //家庭住址 private String tTelenmb; //电话号码 private String tPassword;访问口令 //声明构造方法

Teacher(String password){

27

tPassword = password; }

//声明成员方法

private int checkPassword(String password) { //私有方法：检查口令是否正确

if(tPassword= =password) return 1; else return 0; }

void setAge(String passwork,String age) //置年龄 {

if(checkPassword(passwork)= =1){ tAge =age; } }

String getAge(String password) //取年龄 {

if(checkPassword(password) = =1) return tAge;

else return″Wrong password! ″; }

void setAddr(String password,String addr) //置家庭地址 {

if(checkPassword(password)==1) { tAddr =addr; } }

String getAddr(String passwork) 取家庭地址 {

if(checkPassword(password)==1)

28

return tAddr;

else return″Wrong password! ″; }

void setTelenmb(String passwork, String telenmb) //置电话号码 {

if(checkPassword(password)= =1){ tTelenmb =telenmb; } }

String getTelenmb(String password) //取电话号码 {

if(checkPassword(password) = =1) return tTelenmb;

else return″Wrong password! ″； } }

2．下面的程序定义了一个学生类。上机编译并运行此程序，观察运行结果，体会类的定义方法、类的成员变量的定义方法、对象的声明及其使用的方法。 class Student //Student是类名 {

//声明成员变量 int sNumber; //学号 String sName; //姓名 String sClass; //班号 }

public class Check0 //主类Check0 {

public static void main(String args[ ]) //主方法main {

Student x= new Student( ); //创建Student类的对象x

29

//访问成员变量 x．sName=″myname″; x．sNumber=900001;

System.out.println(x．sName); System.out.println(x．sNumber); } }

3．上面的Student类抽取了学号、姓名和班号来描述\学生\这个实体，但未对其实行保护。请仿照教师类的定义对其进行修改，使得你认为重要的不宜公开的数据得到一定的保护。

4．若要使Student类可用于一个全校同学的通信录程序，请为此设计一具更完善的Student类，设计时应考虑抽取哪些属性来描述\学生\这个实体，哪些数据需要保护，应提供哪些方法，等等。 提高：

1．在学习计算机语言时，对于语法中的难点或疑点，可以通过编写一些测试程序加以澄清或验证，从而加深对语言的理解。请将上面程序中Student类的成员变量sClass修饰为static,在下面的程序中填入适当的语句（创建几个Student类的对象，对其中的一个对象的sClass赋值，输出其他对象的sClass）,验证成员变量sClass为学生类的不同对象所共享，加深对static变量的理解。 public class Check1{

public static void main (String args[ ]) {

//在下行填入适当的语句，验证成员变量sClass为学生类的不 //同对象所共享 } }

2．关键字static也可用来修饰方法和类。调用static方法（称为静态方法）时，不必先创建该类的对象再用\对象名.方法名\调用，而可直接用\类名.方法

30

名\来调用。请设计一个测试程序。Static类也有类似的情形吗？再设计一个测试程序。 要求：

1、独立完成；并以实际上机操作计成绩；

2、所有上机实验必须在下一次实验之前完成，否则此次实验成绩算0分； 3、编写实验报告（按照报告模板编写，必须写出详细的实验步骤及必要的屏幕截图）。

31

实验七 继承和多态

一、实验课时

3课时。

二、实验目的

1．掌握如何创建子类。

2．掌握关键字this和super的用法。 3．体会方法重写和重载的区别。 4．体会抽象和抽象方法的用法。

三、实验内容和要求

1．下面程序中定义了汽车类Car和垃圾车类TrashCar。其中垃圾车类由汽车类继承而来。注意汽车类中声明了抽象方法powerType（动力类型），在垃圾车类中重写了这一方法。上机编译、运行此程序，体会此程序中创建子类的方法和抽象类、抽象方法的用法。请在此程序基础上利用继承声明一个客车类Bus，该类比汽车多一个属性：座位数（int seat_num）。动力类型为柴油发动机；在主类的主方法中增加一些语句来创建客车类的对象并对这些对象进行一些操作。调试并运行你的程序。 abstract class Car { //定义抽象类Car private int carNumber;

abstract void power( ); //声明抽象方法 void setNumber(int carNum) //置车号 {

carNumber =carNum; }

void showNumber( ) //显示车号 {

System.out.println(″我的车号是：″+carNumber)； }

32

}

class TrashCar extends Car {//定义TrashCar类，它继承Car类 private int capacity;

void power( ) //重写父类Car的抽象方法 {

System.out.println(″汽油发动机驱动″)； }

void setCapacity(int trashCarCapacity) {

capacity =trashCarCapacity; }

void showCapacity( ) {

System.out.println(″我的容量是：″+capacity+″″); } }

class CarDemo //主类 {

public static void main(String args[ ]) //主方法 {

TrashCar DemoTrashCar =new Trash Car( ); DemoTrashCar.setNumber(4949); DemoTrashCar.setCapacityr(20); DemoTrashCar.showNumber( ); DemoTrashCar.showCapacity( ); } }

2．编译并运行下面的程序，观察分析运行结果，体会程序中super和this的用法，进一步理解变量隐藏和方法重写的概念。 class SuperClss {//定义父类

33

int x;

SuperClss( ) //父类的构造方法 { x=10; }

void doClss( ) {

System.out.println(″SuperClss.do Class( ) ″); } }

class SubClss extends SuperClss { //定义子类 int x;

SubClss( ) //子类的构造方法 {

super( ) ; //调用父类的构造方法 x =100; }

void doClss( ) //重写父类的doClss方法 {

System.out.println(″subClss.doClss()″); }

void doDemo( ) //演示super和this的用法 { int x; x=1000;

super.doClss( ); //调用父类的doClss方法 doClss( ); //调用本类的doClss方法

System.out.println(″super.x=″+super.x); //父类的x System.out.println(″this.x=″+this.x); //本类的x System.out.println(″x=″+x); //本方法的x

34

} }

public class SuperDemo{

public static void main(String args[ ]) //主方法 {

SubClss s = new SubClss( ); s.doDemo(); } }

3．编译并运行下面的程序，分析运行结果，体会其中方法重载的用法，进一步理解方法重载的概念。

class Father {//本类中的speak方法重载了两次 void speak( ) 无参的speak方法 {

System.out.println(″I am Father! ″); }

void speak(String s) //有参的speak方法

System.out.println(″I like″+″″+s+″. ″); } }

public class OverLoadingDemo {

public static void main (String args[ ]){ Father x = new Father( ); x.speak(); //调用无参的speak方法

x.speak(″music″) //调用有参的speak方法 } } 提高：

35

现实世界中有很多可以用继承描述的关系，如dog 有 name、color、weight等属性以及bark、run等行为，而pekinese(哈巴狗)可以描述为dog的子类。结合你知识背景，举一个继承的例子，其中涉及抽象方法、方法重写、方法重载等概念。画出类继承的层次图，并用Java语言描述之，再编译运行你的程序。 要求：

1、独立完成；并以实际上机操作计成绩；

2、所有上机实验必须在下一次实验之前完成，否则此次实验成绩算0分； 3、编写实验报告（按照报告模板编写，必须写出详细的实验步骤及必要的屏幕截图）。

36

实验八 方法和构造

一、实验课时

3课时。

二、实验目的

1．掌握方法参数传递的过程。 2．掌握方法返回值的用法。 3．掌握构造方法的设计。 4．掌握对象初始化的过程。 5．掌握对象作为参数的用法。

三、实验内容和要求

1．下面给出了一个计算阶乘的类Fact和使用该类计算阶乘的程序Check1。编译并运行该程序，观察运行结果，体会方法的参数的传递和返回值的用法。在调用时改变参数的个数和类型，看看编译时会得到什么信息。 class Fact{

float fact (int n) //定义计算n!的方法 { int i; float x =1; for(i=1;i

public class Check1{

public static void main (String args[ ]) {

Fact x =new Fact( );

System.out.println(x.fact(10)); //计算10！

37

System.out.println(x.fact(15)); //计算15！ } }

2．下面给出了一个矩形类Rectangle,其中含有多个构造方法。上机编译并运行此程序，观察运行结果，体会其中不同构造方法的设计和使用。 class Rectangle{ private int width; private int length;

//下面是类Rectangle的三个构造方法

Rcectangle（） //此构造方法无参数，缺省地给出长（30）和宽（20）{

length=30;width=20; }

Rectangle(int 1,int w) //此构造成方法给出长和宽 {

length=1;width=w; }

Rectangle(Rectangle r) //此构造方法以另一个Rectangle作为参数 {

width=r.width(); length=r.length(); }

int width() //返回宽度 {

return width; }

int length() //返回长度 {

return length; }

38

}

public class CRctngle{

public static void main (String args[ ]){ Rectangle x1=new Rectangle(); Rectangle x2=new Rectangle(50,40); Rectangle x3=new Rectangle(xl); System.out.println(x1.length()); System.out.println(x1.width()); System.out.println(x2.length()); System.out.println(x2.width()); System.out.println(x3.length()); System.out.println(x3.width()); } }

3.参照上面的程序，自己编写一个包含圆类的程序，并为圆类设计几个构造方法，编译并运行你的程序。 提高：

1．编译运行下面的程序，观察分析运行结果，注意对象作为方法参数的用法。 Class Int { int n; }

class SetValue{

void setValue(Int n1,int n2)

//n1是对象作为参数，n2是基本数据类型作为参数 //本方法中试图改变这两个参数的值 {

n1.n=2*n1.n; n2.n=2*n2;

39

} }

class ObAsPDemo{

public static void main (String args[ ]) {

Int n1=new Int( ); int n2;

SetValue Demo=new SetValue( ); n1.n=10; n2=10;

System.out.println(″Before setValue″); System.out.println(″n1.n=″+n1.n); System.out.println(″n2=″+n2); Demo.setValue(n1,n2);

System.out.println(″After setValue″);

System.out.println(″n1.n=″+n1.n); //此值改变了 System.out.println(″n2=″+n2); //此值未改变 } }

2．对上面Fact方法作相应的修改，利用对象作为参数，得到阶乘的值。 （提示：将上面Fact方法的参数个数增加为两个，其中一个参数的类型设为类类型；方法的返回值类型改为void。） 要求：

1、独立完成；并以实际上机操作计成绩；

2、所有上机实验必须在下一次实验之前完成，否则此次实验成绩算0分； 3、编写实验报告（按照报告模板编写，必须写出详细的实验步骤及必要的屏幕截图）。

40

实验九 组件的创建和安放

一、实验课时

3课时。

二、实验目的

1．掌握Swing组件的创建过程。

2．了解组件不能直接安入在frame上，而应放在其内容窗格中。3．学会组件属性的设置。

三、实验内容和要求

1． 编译运行给出的程序段（简单图形界面） /*Exam 9.1*/

import javax.swing.*; import java.awt.*; import java.awt .event.*; public class FrameDempl{

public static void main (String args[ ]) { //创建一个容器类组件 frame

Jframe frame = new Jframe(″Exam10.1″)； //获得其内容窗格

Container c =frame.getContentPane( ); c.setLayout(new FlowLayout()); //创建几个组件

Jlabel 1b =new JLabel(″FrameDemo″); //标签

JTextField tf = new JTextField(″TextField″); //文本框 JButton bt1 = new JButton(″Button″); //按钮1

41

/*这里可以加一些语句设置组件的属性以改变其外观等*/ JButton bt2 = new JButton(″Button″); //按钮2 //将组件依次放入 c.add(1b); c.add(tf); c.add(bt1); c.add(bt2);

//以像素为单位设定frame的大小 frame.setSize (400，100);

/*也可用frame.pack( )；语句让frame根据需要自动调整大小*/ //显示该窗口 frame.show( );

/*以下程序用于捕获并响应窗口的关闭事件，以后的实验单元将详细介绍，这里加入该程序段主要是为了方便程序调试，大家照原样输入即可。*/ frame.addWindowListener(new WindowAdapter( ) {

public void windowClosing(WindowEvent e) {

System.exit(0); } }); } }

42

试在程序中\/*这里可以加一些??外观等*/\的位置加入下列语句，查看运行结果。

bt1.setBackground(Color.pink);

bt1.setBorder(BorderFactory.createRaisedBeve1Border()); bt1.setToolTipText(″click me″); bt1.setText(″I′ve been changed″); 提高：

已知方法setForeground用于设置标签的前景色，setText用于设置标签显示的文字，请参照上题将标签改成\颜色设置成红色（red）。有兴趣的同学还可以试着设置其他组件一些属性以改变整个界面的外观。 要求：

1、独立完成；并以实际上机操作计成绩；

2、所有上机实验必须在下一次实验之前完成，否则此次实验成绩算0分； 3、编写实验报告（按照报告模板编写，必须写出详细的实验步骤及必要的屏幕截图）

43

实验十 布局管理器

一、实验课时

3课时。

二、实验目的

掌握布局管理器的使用。

三、实验内容和要求

1．BorderLayout是容器类组件的默认布局管理器，运行下面的程序查看结果。 import javax.swing.*; import java.awt.*; import java.awt.event.*; public class LayoutDemo{

public static void main (String args[ ]); {

JFrame frame = new JFrame (″Exam11.1″); Container c =frame.getContentPane( ); c.setLayout(new BorderLayout()); //可有可无 JButton bt1= new JButton1(″Button1(NORTH) ″); JButton bt2= new JButton2(″Button2(SOUTH) ″); JButton bt3= new JButton3(″Button3(EAST) ″); JButton bt4= new JButton4(″Button4(CENTER) ″); JButton bt5= new JButton5(″Button1(WEST) ″); c.add(bt1,BorderLayout.NORTH); c.add(bt2,BorderLayout.SOUTH); c.add(bt3,BorderLayout.EAST); c.add(bt4,BorderLayout.CENTER); c.add(bt5,BorderLayout.WEST); frame.pack( ); frame.show( );

44

frame.addWindowListener(new WindowAdapter( ) {

public void windowClosing(WindowEvent e) {

System.exit(0); } }); } }

试将程序中注释为可有可无的那行删除，再查看运行结果。从中可以体会到容器类组件的布局管理器为BorderLayout，程序中可以不显式说明。将上述程序的下列语句

c.add(bt1,BorderLayout.NORTH); c.add(bt2,BorderLayout.SOUTH); c.add(bt3,BorderLayout.EAST); c.add(bt4,BorderLayout.CENTER); c.add(bt5,BorderLayout.WEST); 修改为： c.add（bt1）; c.add（bt2; c.add（bt3; c.add（bt4）; c.add（bt5）;

再查看运行结果。可以看出BorderLayout管理组件时将容器分成块：东、西、南、北、中。添加组件时必须指明安放的位置，否则默认为添加中间位置（CENTER），上述几条语句使得几个按钮叠加互相同的位置，最终只能看到最后加入的组件Button5，由于其他位置没有内容，所以它流满了整个空间。

2．GridLayout将一系列组件按指定的行、列数排列，各组件占用空间的大小相同。下面的程序使用GridLayout，将六个button按两行三列的方式排列。 import java.awt.*;

45

import java.awt.event.*; public class LayoutDemo4{

public static void main (String args[ ]) {

JFme fram =new JFrme(″Exam11.2″); Container c= frame.getContentPane( ); c.setLayout(new GridLayout(2,3,5,5))；

//2列3行，水平和垂直方向组件之间的间距都为5个像素 JButton bt1 =new JButton(″Button1″); JButton bt2 =new JButton(″add″);

JButton bt3 =new JButton(″LongCharButton3″); JButton bt4 =new JButton(″Button4″); JButton bt5 =new JButton(″*″); JButton bt6 =new JButton(″=″); c.add(bt1); c.add(bt2); c.add(bt3); c.add(bt4); c.add(bt5); c.add(bt6); frame.pack( ); frame.show( );

frame.addWindowListener( new WindowAdapter( ) {

public void window Closing(WindowEvent e){ System.exit(0); } } ) ; }

46

} 提高：

1．设计程序测试出panel的默认布局管理器。 要求：

1、独立完成；并以实际上机操作计成绩；

2、所有上机实验必须在下一次实验之前完成，否则此次实验成绩算0分； 3、编写实验报告（按照报告模板编写，必须写出详细的实验步骤及必要的屏幕截图）。

47

实验十一 事件处理

一、实验课时

3课时。

二、实验目的

掌握事件的侦听和处理过程。

三、实验内容和要求

要响应一个事件，首先必须创建一个事件侦听者（即Listener,专门用于捕获和处理各种事件的对象，Java中有很多种类的Listener,分别用于处理不同类型的事件），然后为可能发生该事件的组件添加侦听者，这样当该组件上发生事件侦听者可捕获到所姓的事件，事件的处理则完全由事件侦听者负责。 1．运行程序，用鼠标点击按钮观察（GUI的变化，体会事件的侦听和处理过程，注意响应窗口事件的按钮事件采用不同的事件侦听者。 import java.awt.*; import.javax.swing.*; import.java.awt.event.*;

public class actonlistenerDemo extends Jframe{ BorderLayout borderLayout1=new BorderLayout(); JtexField jTextFieldl=new JtextField();

Jpanel jPanell=new Jpanel(); JButton jButtonl=new JButton(); JButton jBtton2=new JButton();

Public actonlistenerDemo(){ try{ jbInit(); }

48

catch(Exception e){ e.printStackTrace(); } }

public static void main(String[] args){

actonlistenerDemo actionIistenerDemol=new actionIlistenerDemo(); JtexField jTextFieldl=new BorderLayout(); Public actionlistenerDemo(){ try { jbInit(); }

catch(Exception e){ e.prinStackTrace(); } }

public static void main (String[ ]args){

actionlistenetDemo actionlistenerDemol=new actionlistenerDemo(); actionlistenerDemol.pack(); actionlistenerDemol.show(); }

private void jbInit()throws Exception{ jTextFieldl.setText(″jTextFieldl″);

jTextFieldl.setHorizontalAlignment(SwinConstants.CENTER); this.getContentPane().setLayout(bordeLayoutl); jButtonl.setText(″jButtonl″);

jButtonl.addActionListener(new java.awt.event.ActionListener(){ public void actionPerfomed(ActionEvent e){ jButtonl_actionPerformed(e); }

49

});

jButton2.setTxet(″jButton2″);

jButton2.addActionListenet(new java .awt .event.ActionListener(){ public void actionPerformed(ActionEvent e){ jButton2_actionPerformed(e); } });

this .addWindowListener(new java.awt.event.windowAdapter(){ public void windowClosing(WindowEvent e){ this_windowClosing(e); } });

this .getContentPane().add(jTextFieldl,BorderLayout.CETER); this .getContentPane().add(jpanell,BorderLayout.SOUTH); jPanell.add(jButton1,null); jPanell.add(jButton2,null); }

void jButton1_actionPerformed(ActionEvent e){ jTextField1.setText(″1″)

jTextField1.steBackground(Color.pink); }

void jBotton2_actionPerformed(ActionEvent e){ jTextField1.setText(″2″);

jTextField1.setBackground(Color.red); }

void this _WindowClosing(WindowEvent e){ System.exit(0); } }

50

本文来源：https://www.bwwdw.com/article/pu7r.html