Java程序设计实训指导书

②在浏览器里打开HTML文件，查看Java Applet在图形界面下的输入输出。

（2）回答问题：在文本框中输入文字并按回车观察程序的输出，如果不回车，是否有输出，为什么？在文本框中输入多个字符并回车，输出是什么？在文本框中输入多个汉字（例如：输入你的名字）并按回车，输出是什么？

①把程序里原来的语句：

prompt=new Label(“Enter a character please:”); //创建提示标签 分别先改写为下面的语句：

prompt=new Label(\请输入一个或一串字符：\ //创建提示标签

保存修改后的.java文件，重新编译(javac)并运行，程序的样子有什么改变如果显示输出也是中文，如何修改程序？

②把程序里原来的语句：

input=new TextField(3); //创建输入区域 分别改写为下面的语句：

input=new TextField(6); //创建输入区域 和input=new TextField(\在这里输入\创建输入区域

并分别运行两次修改后的程序，程序的界面有何变化？体会TextField的用法。

7.编写图形界面的Java Application，完成与第（2）项任务相同的功能。 （1）键入并运行如下Java Application程序：

//图形界面下的Application程序：GraphicsAppInOut.java

import java.awt.*; //引入ava.awt包中的所有类 import java.awt.event.*;

public class GraphicsAppInOut //定义主类GraphicsAppInOut {

//创建对象MyFrame,形成图形界面

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

//创建对象MyFrame，形成图形界面

ApplicFrame MyFrame=new ApplctFrame(); } }

class ApplctFrame extends Frame//定义Frame类的子类ApplctFrame implements ActionListener {

Label prompt; //定义提示标签对象

TextField input; //定义输入单行文本区域对象 Label output; //定义输出标签对象

ApplctFrame() //对ApplctFrame对象初始化 {

super(\调用父类方法指定图形界面窗口标题 setLayout(new FlowLayout()); //指定图形界面窗口中各部件的排列方式 input=new Label(\创建提示标签对象 input=new Label(\ \创建输出标签对象 add(prompt); //将提示标签加入窗口 add(input); //将输入区域加入窗口 add(output); //将输出标签加入窗口 input.addActionListener(this);//响应输入的结束

this.addWindowListener(new WindowAdapter()//响应关闭窗口的命令 {

public void windowClosing(WindowEvent we) {

system.exit(0); } });

setSize(500,100); //指定窗口大小 setVisible(true); //使窗口可见 }

public void actionPerformed(ActionEvent e) {

output.setText(\}

}

（2）回答问题：这是一个Java Application程序，在命令行运行它，界面会发生什么变化，为什么？

①把程序里面原有的语句：

super(\调用父类方法指定图形界面窗口标题 改为下面的语句：

super(\图形界面窗口\ //调用父类方法指定图形界面窗口标题 重新运行程序，有何变化？试着把窗口的标题改成你希望的内容。

②这个Applicaton程序输入输出功能与上面的Applet的输入输出功能是否完全相同？其输入输出功能与第一个Applicaton有何不同？体会字符界面与图形界面输入输出程序和操作的不同。本实验的三个输入输出方法，你最喜欢那一种方法？为什么？

实训三 分支语句

一、实训目的

1.掌握if语句，if-else-if结构的使用，掌握if语句的嵌套编程特点。 2.掌握条件的表达技巧； 3.掌握switch语句的使用。 4.了解从键盘获取数据的方法 二、实训要求

1.编写使用不同选择结构的程序。

2.理解Java 程序语法结构，掌握选择结构语法的程序设计方法。 三、实训内容

1.使用if...else 语句 （1）程序功能：使用if...else 语句构造多分支，判断某一年是否为闰年。闰年的条件是符合下面二者之一：能被4 整除，但不能被100 整除；能被4 整除，又能被100 整除。

（2）编写源程序文件，代码如下。 public class LX3_1 {

public static void main(String args[]) {

boolean leap; int year=2005;

if ((year%4==0 && year0!=0) || (year@0==0)) // 方法1

System.out.println(year+\年是闰年\else

System.out.println(year+\年不是闰年\year=2008; // 方法2 if (year%4!=0)

leap=false;

else if (year0!=0)

leap=true;

else if (year@0!=0)

leap=false; else

leap=true;

if (leap==true)

System.out.println(year+\年是闰年\else

System.out.println(year+\年不是闰年\year=2050; // 方法3 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.println(year+\年不是闰年\}

}

（3）编译运行程序，并写出结果。 2.使用switch 语句

（1）程序功能：在不同温度时显示不同的解释说明。 （2）程序源代码如下。 class LX3_2{

public static void main(String args[]) {

int c=38;

switch (c<10?1:c<25?2:c<35?3:4) {

case 1:

System.out.println(\℃ 有点冷。要多穿衣服。\case 2:

System.out.println(\℃ 正合适。出去玩吧。\case 3:

System.out.println(\℃ 有点热。\default:

System.out.println(\℃ 太热了!开空调。\

} } }

（3）编译运行程序，并写出结果。

3.编写图形界面的Java Applet，接受用户输入的正整数，若用户输入的不是正整数则利

用一个标签提示错误并要求重新输入，直至得到符合要求的数据。

4.编写字符界面的Java Application，将用户输入的小写字符转化成大写字符打印在屏幕上，若用户输入的不是小写字符则打印信息说明无法完成指定的操作。

5.编写图形界面的Java Application，接受用户输入的一个0~100之间的分数，将其转化成1~5的5分计方法。

90~100： 5 75~89： 4 60~74： 3 40~59： 2 其他： 1

实训四 循环语句

一、实训目的

1. 掌握三种循环语句的使用，能分析循环的执行过程 2. 掌握break和continue语句的使用；。 3. 掌握累加、累乘的处理方法。

4. 掌握计数问题的编写技巧，如何控制每行输出元素个数及了解如何利用求余和整除操作获取和删除一个整数的最低位 二、实训要求

1.编写使用不同循环结构的程序。

2.理解Java 程序语法结构，掌握循环结构语法的程序设计方法。 三、实训内容

1.for 循环语句练习 （1）程序功能：按5 度的增量打印出一个从摄氏温度到华氏温度的转换表。

（2）程序源代码如下。 class LX4_1{

public static void main (String args[]) {

int h,c;

System.out.println(\摄氏温度 华氏温度\for (c=0; c<=40; c+=5) {

h=c*9/5+32;

System.out.println(\} } }

（3）编译并运行程序，并写出结果。 2.while 循环语句练习

（1）程序功能：运行程序后从键盘输入数字1/2/3 后，可显示抽奖得到的奖品；如果输入其它数字或字符显示“没有奖品给你!”。

（2）程序源代码如下。 import java.io.*; class LX4_2 {

public static void main(String args[]) throws IOException {

char ch;

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）编译源程序。

（4）在命令提示符窗口运行程序，然后分别按1、2、3、r 观察输出结果。 3.do?while 循环语句练习

（1）程序功能：求1＋2＋?+100 之和，并将求和表达式与所求的和显示出来。 （2）程序源代码如下。 class LX4_3 {

public static void main(String args[]) {

int n=1, sum=0; do {

sum+=n++; }

while (n<=100);

System.out.println(\＋...+100 =\} }

（3）编译并运行程序，并观察结果。 4.多重循环练习

（1）输出九九乘法表的程序，源代码如下。 public class LX4_4{

public static void main(String args[]){

int i,j,n=9;

System.out.print(\for (i=1;i<=n;i++)

System.out.print(\

System.out.print(\for (i=1;i<=n;i++)

System.out.print(\System.out.println(); for (i=1;i<=n;i++){

System.out.print(\for (j=1;j<=i;j++)

System.out.print(\System.out.println(); } }

}

（2）编译并运行程序，并观察结果。 3.编写程序，根据考试成绩的等级打印出百分制分数段。设A 为90 分以上、B 为80 分以上、C为70 分以上、D 为60 分以上、E 为59 分以下。要求在程序中使用开关语句。

4.完整下面的程序，利用break 语句和带标号的break 语句分别退出一重循环和二重循环。

for (i=0; i<10; i++) {

int j=i*10 while(j<100) {

if (j= = 10) break; j=j+5; } }

实训五 数组

一、实训目的

掌握一维数组的概念，定义和使用。 二、实训要求

1.掌握Java 数组的使用方法。 2.编写一个使用Java 数组的程序。

3.编程采用选择排序法实现对数组元素由小到大排序。 三、实训内容

1.建立使用数组的程序，本程序建立了一个长度为5 的1 维数组，一个长度为12 的2 维数组，源代码如下。

public class LX5_1 {

public static void main(String args[]) {

int a[]=new int[5];

int arr1[][]=new int[3][4]; a[0]=10;

a[1]=10+a[0];

a[2]=30; a[3]=40;

a[4]= a[1]+ a[2];

arr1[0][0]=0; arr1[0][1]=1; arr1[0][2]=2; arr1[1][0]=3; arr1[1][1]=4; arr1[1][2]=5; arr1[2][0]=6; arr1[2][1]=7; arr1[2][2]=8; System.out.println(\System.out.println(\System.out.println(\System.out.println(\System.out.println(\

System.out.println(\System.out.println(\System.out.println(\System.out.println(\System.out.println(\System.out.println(\}

}

2.编译并运行程序，写出运行结果。 1）回答问题：

Java语言中的数组的使用要经过哪三个过程？它们是如何实现的？ 2）.编程实现Fibonacci数列。Fibonacci数列的定义为: F1=1, F2=1, ?

Fn=Fn-1+Fn-2 (n>=3) 提示：关键代码如下： f[0]=f[1]=1;

for(i=2;i<10;i++)

f[i]=f[i-1]+f[i-2];

3.编程采用冒泡法实现对数组元素由小到大排序。

提示：冒泡法排序对相邻的两个元素进行比较，并把小的元素交换到前面。关键代码如下：

for(i=0;i

for(j=i+1;j

if(intArray[i]>intArray[j]){

t=intArray[i];intArray[i]=intArray[j];intArray[j]=t; }

4．试用数组实现一个10到20的平方表，打印输出这个平方表。

实训六 类与对象

一、实训目的

1.掌握类的定义和使用。

2.掌握对象的声明和使用。 3.掌握构造函数的概念和使用。 4.掌握类极其成员的访问控制符。 二、实训要求

1.编写一个体现面向对象思想的程序。

2.编写一个创建对象和使用对象的方法的程序。 3.编写一个显示当前日期和时间的程序。 4.编写不同成员变量修饰方法的程序。 5.编写不同成员方法修饰方法的程序。 三、实训内容

1.创建对象并使用对象

（1）程序功能：这个Applet 程序要在页面上输出两个矩形，并伴有文字输出，见上图。程序的源代码如下。

import java.awt.*;

import java.applet.Applet;

public class LX6_1 extends Applet {

MyBox b1=new MyBox();//创建对象b1

MyBox b2=new MyBox(170,20,60,60); //创建对象b2 public void paint(Graphics g) {

b1.setPosition(20,20); b1.setSize(60,60); b1.draw(g);

g.drawString(\矩形 1 的 X 位置: \g.drawString(\矩形 1 的 Y 位置: \b2.draw(g);

g.drawString(\矩形 2 的 X 位置: \g.drawString(\矩形 2 的 Y 位置: \} }

class MyBox {

private int x, y, width, height; MyBox() {

x=0;

y=0; width=0; height=0;

}

MyBox(int xPos, int yPos, int w, int h) {

x=xPos; y=yPos; width=w; height=h; }

public void setPosition (int xPos, int yPos) {

x=xPos; y=yPos; }

public void setSize (int w, int h) {

width=w; height=h; }

public int getX() {

return x; }

public int getY() {

return y; }

public void draw(Graphics g) {

g.drawRect(x, y, width, height); }

}

（2）编写一个浏览Applet 应用程序的页面文件LX6_1.HTML

（3）将LX6_1.java 源程序编译为LX6_1.class 文件

（4）使用浏览器或使用小程序查看器浏览LX6_1.HTML 文件（即在命令提示符下输入：appletviewer LX6_1.HTML），观察运行结果。

（5）思考：程序的结构。类与对象的关系。对象创建、使用、销毁的过程。 2.编写显示当前日期和时间的程序 （1）程序功能：该程序通过使用一个自定义类Time，实现显示当前日期和时间的功能，程序运行结果应与图6.1 类似

（2）LX6_2.java 程序源代码如下。 import java.awt.Graphics; import java.applet.Applet; import java.util.Calendar; class Time {

private Calendar t;

private int y, m, d, hh, mm, ss; Time (){

t=Calendar.getInstance(); y=t.get(t.YEAR);

m=t.get(t.MONTH)+1; d=t.get(t.DATE);

hh=t.get(t.HOUR_OF_DAY); mm=t.get(t.MINUTE); ss=t.get(t.SECOND); }

public String getDate() {

return y+\年\月\日\}

public String getTime() {

String s=hh+\时\分\秒\return s; } }

public class LX3_3 extends Applet {

Time t=new Time();

public void paint(Graphics g) {

g.drawString(\当前日期：\g.drawString(\当前时间：\} }

（2）编写浏览LX6_2类的页面文件LX6_2.html

（3）在浏览器中浏览程序运行结果。

注意：本程序中传递了一个Graphics 类的对象g，并调用了g 的方法drawString。 3.使用修饰符

有时需要公开一些变量和方法，有时需要禁止其他对象使用变量和方法，这时可以使用修饰符来实现这个目的。

常用的修饰符如下。

[public] [private] [protected] [package] [static] [final] [transient] [volatile] 不同修饰符的访问控制权限如表6.1 所示。

（1）程序功能：通过两个类StaticDemo、LX6_3说明静态变量、方法与实例变量、方法的区别。

（2）编写类文件LX6_3.java，程序源代码如下。 class StaticDemo {

static int x; int y;

public static int getX() {

return x; }

public static void setX(int newX) {

x = newX; }

public int getY() {

return y; }

public void setY(int newY) {

y = newY; } }

public class LX6_3 {

public static void main(String[] args) {

System.out.println(\静态变量x=\

System.out.println(\实例变量y=\非法，编译时将出错 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=\System.out.println(\实例变量a.y=\System.out.println(\静态变量b.x=\System.out.println(\实例变量b.y=\} } （3）对上面的源程序进行编译，会出现出错提示，请改正错误得到正确的结果。

4.方法中参数传递的练习 在其它语言中，函数调用或过程调用时参数有传值调用和传地址调用之分。在Java 中，

方法中的参数传递可以分为传值调用或对象方法调用等方式。传值调用即传递的参数是基本数据类型，调用方法时在方法中将不能改变参数的值，这意味着只能使用它们。对象调用是指先调用对象，再调用对象的方法，这种方式可以修改允许存取的成员变量。所以，如果不想改变参数的值，可以采用传值调用的方法。如果想改变参数的值，可采用对象调用的方法，间接修改参数的值。

（1）程序功能：程序首先给整型变量x 和y 赋一个初值10，然后使用传值调用方式调用方法ff1对x 和y 做乘方及输出x 和y 的乘方值，最后再输出x 和y 的乘方值。

（2）程序源代码如下。 class LX6_4 {

public static void main(String[] args) {

int x=10, y=10; ff1(x, y);

System.out.println(\}

static void ff1(int passX, int passY) {

passX=passX*passX; passY=passY*passY;

System.out.println(\} } （3）编译LX6_4.java，观察运行结果。

（4）分析其运行结果

这个程序没有实现预期的结果，原因是ff1 方法采用了传值调用。调用ff1 方法时，将产生两个参数passX 和passY，x 和y 的值被传递给这两个参数。尽管在方法中计算了参数的平方，但从ff1方法返回后，参数消失，此时x 和y 的值仍是初值。

（5）编写一个调用对象方法的程序文件LX6_5.java。程序功能：通过调用对象的方法在方法调用后修改了成员变量的值。LX6_5.java 程序源代码如下。

class LX6_5 {

public static void main(String[] args) {

Power p=new Power(); p.ff2(10,10);

System.out.println(\方法调用后 x=\} }

class Power{

int x=10, y=10;

void ff2(int passX, int passY) {

System.out.println(\初始时 x=\x=passX*passX; y=passY*passY;

System.out.println(\方法调用中 x=\} }

（6）编译LX6_5.java，其运行结果如图6.6 所示。

以上两个实验例子仅仅是为了说明Java 编程中参数传递时要注意的问题，在实际编程中是不可取的，因为完全可以采用其它更好的方法来实现参数的传递。例如，前面还使用过传递对象的方式。

思考：方法的参数传递有哪些方式？区别时什么？

5.阅读下面的程序，在main()方法里添加语句完成如下功能： （1）创建一个MyValue类的对象myValue. （2）为myValue对象中的value域赋值10。

（3）使用getVaule()方法获得myValue对象中的数据并将它打印在屏幕上。 class MyValue{

private int value;

public void setValue(int x){

Value = x;

}

public int getValue;{

return value; } }

public class UseValue{

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

6.试编写Java代码实现一个计数器类Computer其中包括： 域counterValue 用来保存计数器的当前值； 方法increment() 计数器加一； 方法decrement() 计数器减一； 方法reset()计数器清零。

对于这个类，你计划定义几个构造函数？

7.编程实现矩形类，其中应包括计算矩形周长和面积的方法。如何使你的定义更好的满足面向对象程序设计中信息隐藏和封装的原则？对于这个类，你计划定义几个构造函数？

8.使用矩形类，编程统计若干块土地的相关信息。由用户输入每块土地的长与宽，程序将计算其面积并显示出来。

实训七 继承与多态

一、实训目的

1.掌握类的继承方法和派生方法。 2.掌握多态的概念与使用。 3.掌握类的继承关系。

4.掌握变量的继承和覆盖。

5.掌握方法的继承,重载和覆盖。

6.掌握接口的定义和使用，了解接口的实现方法。 7.掌握包的概念与使用。 二、实训要求

1.理解成员变量的继承与隐藏。 2.理解方法的继承。 3.理解方法的重载。 4.理解方法的覆盖。

5.定义两个接口，其方法协议分别完成两个数的加法和减法操作，然后创建一个类实现这两个接口的方法。 三、实训内容

1.进一步理解继承的含义 新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。

2.创建公共类LX7_1_P

（1）编写程序文件LX7_1_P.java，源代码如下。 public class LX7_1_P{

protected String xm; //具有保护修饰符的成员变量 protected int xh;

void setdata(String m,int h) //设置数据的方法 {

xm =m; xh = h; }

public void print() //输出数据的方法 {

System.out.println(xm+\} }

（2）编译LX7_1_P.java，产生类文件LX7_1_P.class。 3.创建继承的类 （1）程序功能：通过LX7_1_P类产生子类LX7_2，其不仅具有父类的成员变量xm（姓名）、xh（学号），还定义了新成员变量xy（学院）、xi（系）。在程序中调用了父类的print 方法，同时可以看出子类也具有该方法。

（2）编写LX7_2.java 程序，源代码如下。 class LX7_2 extends LX7_1_P {

protected String xy; protected String xi;

public static void main(String args[]) {

LX7_1_P p1 = new LX7_1_P(); p1.setdata(\帅零\p1.print();

LX7_2 s1 = new LX7_2() ;

s1.setdata(\郭丽娜\调用父类的成员方法 s1.xy=\经济管理学院\访问本类的成员变量 s1.xi=\信息管理系\访问本类的成员变量 s1.print();

System.out.print(s1.xm+\}

}

（3）编译并运行程序，其观察运行结果。

注意：公共类LX7_1_P 与LX7_2类要在同一文件夹（路径）内。 4.了解成员变量的隐藏方式

所谓隐藏是指子类重新定义了父类中的同名变量，在子类Line 中重新定义了x 为x1，y 为y1，隐藏了父类Point 中的两个成员变量x 和y。子类执行自己的方法时，操作的是子类的变量，子类执行父类的方法时，操作的是父类的变量。在子类中要特别注意成员变量的命名，防止无意中隐藏了父类的关键成员变量，这有可能给程序带来麻烦。

5.了解成员方法的覆盖方式 （1）方法覆盖的定义与作用

通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override）。方法覆盖为子类提供了修改父类成员方法的能力。例如，子类可以修改层层继承下来的Object 根类的toString 方法，让它输出一些更有用的信息。下面的程序显示了在子类Circle 中添加toString 方法，用来返回圆半径和圆面积信息。

（2）编写覆盖Object 类toString 方法的程序文件LX7_3.java，源代码如下。 class Circle {

private int radius; Circle(int r) {

setRadius(r); }

public void setRadius(int r) {

radius=r; }

public int getRadius() {

return radius; }

public double area() {

return 3.14159*radius*radius; }

public String toString() {

return \圆半径：\圆面积：\} }

public class LX3_9{

public static void main(String args[]) {

Circle c=new Circle(10);

System.out.println(\} }

（3）编译并运行程序，观察运行结果。 （4）程序结构分析。

程序添加了toString 方法并修改了它的返回值。由于toString 和继承下来的Object 类的方法名相同、返回值类型相同，因此覆盖了超类Object 中的toString 方法。方法覆盖时要特别注意：用来覆盖的子类方法应和被覆盖的父类方法保持同名、相同的返回值类型，以及相同的参数个数和参数类型。

6.This、super 和super()的使用

（1）程序功能：说明this、super 和super()的用法。程序首先定义Point（点）类，然后创建点的子类Line（线）。最后通过LX3_10 类输出线段的长度。程序中通过super(a,b)调用父类Point 的构造方法为父类的x 和y 赋值。在子类Line 的setLine方法中，因为参数名和成员变量名相同，为给成员变量赋值，使用this 引用，告诉编译器是为当前类的成员变量赋值。在length 和toString 方法中使用父类成员变量时，使用super 引用，告诉编译器使用的是父类的成员变量。

（2）使用this、super和super()的程序文件LX7_4.java，源代码如下。 class Point {

protected int x, y; Point(int a, int b) {

setPoint(a, b); }

public void setPoint(int a, int b) {

x=a; y=b; } }

class Line extends Point {

protected int x, y; Line(int a, int b) {

super(a, b); setLine(a, b); }

public void setLine(int x, int y) {

this.x=x+x; this.y=y+y; }

public double length() {

int x1=super.x, y1=super.y, x2=this.x, y2=this.y;

return Math.sqrt((x2-x1) * (x2-x1) + (y2-y1) * (y2-y1)); }

public String toString() {

return \直线端点：[\x + \直线长度：\}

}

public class LX3_10{

public static void main(String args[]) {

Line line=new Line(50, 50);

System.out.println(\} }

（3）编译并运行程序，观察运行结果。 7.理解类的多态性

类的继承发生在多个类之间，而类的多态只发生在同一个类上。在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。这种现象称为类的多态。多态使程序简洁，为程序员带来很大便利。在OOP 中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。类的多态性体现在方法的重载（overload）上，包括成员方法和构造方法的重载。

8.方法的重载

方法的重载是指对同名方法的不同使用方式。 （1）程序功能：对不同的数进行排序输出。 （2）编写LX7_5.java 文件，源代码如下。 import java.awt.Graphics; import java.applet.Applet; class IntSort {

public String sort(int a, int b) {

if (a>b)

return a+\else

return b+\

}

public String sort(int a, int b, int c) {

int swap; if (a

swap=a; a=b; b=swap; }

if (a

swap=a; a=c; c=swap; }

if (b

swap=b; b=c; c=swap; }

return a+\

}

public String sort(int arr[]) {

String s=\int swap;

for (int i=0; i

for (int j=0; j

if (arr[j]>arr[j+1]) {

swap=arr[j]; arr[j]=arr[j+1]; arr[j+1]=swap; }

for (int i=0; i

return s; }

}

public class LX3_11 extends Applet {

IntSort s=new IntSort();

public void paint(Graphics g) {

int a=30, b=12, c=40;

int arr[]={34,8,12,67,44,98,52,23,16,16};

g.drawString(\两个数的排序结果：\g.drawString(\三个数的排序结果：\g.drawString(\数组的排序结果：\} }

（3）编译并运行程序，观察运行结果。 （4）三个同名方法

public String sort (int a, int b)

public String sort (int a, int b, int c) public String sort (int arr[])

（5）编写LX7_5类文件的页面文件LX7_5.html

9.构造方法的重载

构造方法的名称和类同名，没有返回类型。尽管构造方法看起来和一般的成员方法没有

差别，但它不是方法，也不是类的成员。因此，构造方法不能直接调用，只能由new 操作符调用。构造方法对于类是十分重要的，对象的初始化任务要靠构造方法来完成。重载构造方法的目的是提供多种初始化对象的能力，使程序员可以根据实际需要选用合适的构造方法来初始化对象。

（1）编写构造方法RunDemo 的重载程序文件LX7_6，源代码如下。 class RunDemo {

private String userName, password; RunDemo() {

System.out.println(\全部为空!\}

RunDemo(String name) {

userName=name; }

RunDemo(String name, String pwd) {

this(name); password=pwd; check(); }

void check() {

String s=null;

if (userName!=null)

s=\用户名：\else

s=\用户名不能为空！\if (password!=\

s=s+\口令无效！\else

s=s+\口令：********\System.out.println(s); } }

public class LX3_12 {

public static void main(String[] args) {

new RunDemo();

new RunDemo(\刘新宇\new RunDemo(null,\邵丽萍\

new RunDemo(\张驰\} }

（2）编译并运行程序，观察运行结果。 （3）三个构造方法，其中第一个无参构造方法RunDemo() 的实际作用是对成员变量赋缺省初值，由于userName和password都是String 类，所以它们的缺省初值为null。第二个构造方法RunDemo(String) 只有一个参数，用来对成员变量userName 赋初值。第三个构造方法RunDemo(String, String) 有两个参数，并有更多的内容，首先调用this(name)，其实际

作用就是调用当前类的构造方法RunDemo(String name)；然后对成员变量password 赋值；最后调用check 方法来检查userName 和password，类似于一般程序的口令验证。重载构造方法的执行由对象根据实际参数的个数、类型和顺序确定。 四、选做题

1.为实验6中定义的矩形类派生一个子类：正方形类。若正方形类的操作同样是求周长和面积，则这个子类除了从父类那里继承来的方法之外，还需要定义那些方法。列出正方形类的所有域与方法。编程检查、运行所编写的正方形类。

2.定义接口Printable,其中包括一个方法pringtItMyWay()，这个方法没有形参，返回值为空。

3.改写矩形类，使之实现Printable接口，用pringtItMyWay()方法矩形的相关信息（长、宽、高、面积）打印在屏幕上。

4.改写正方形类，重载pringtItMyWay()方法，将正方形的边长、周长、面积

实训八 常用基础类库与工具类库

一、实训目的

1.掌握Math类的使用。

2.掌握String类和StringBuffer类的使用。 3.掌握Java Application命令行参数的使用。 二、实训要求

1.理解Math类的使用。 2.理解String类的使用。

3.理解StringBuffer类的使用。

4.使用Java Aplication的命令行参数读入两个数据,计算它们的和,然后将和输出.如果参数的数目不足,显示相应提示信息并退出程序的执行。 三、实训内容

1.Math 是一个最终类，含有基本数学运算函数，如指数运算、对数运算、求平方根、三角函数、随机数等，可以直接在程序中加Math.前缀调用。

（1）创建使用Math 类的应用程序LX8_1.java，源程序如下。 import java.util.*; class LX8_1 {

public static void main(String args[]) {

Random r1=new Random(1234567890L); Random r2=new Random(1234567890L);

boolean b=r1.nextBoolean(); // 随机数不为0 时取真值

int i1=r1.nextInt(100); // 产生大于等于0 小于100 的随机数 int i2=r2.nextInt(100); // 同上

double i3=r1.nextDouble(); // 产生大于等于0.0 小于1.0 的随机数 double i4=r2.nextDouble(); // 同上

double d1=Math.sin(Math.toRadians(30.0)); double d2=Math.log(Math.E); double d3=Math.pow(2.0, 3.0); int r=Math.round(33.6F);

System.out.println(\的随机数不为0 时 \System.out.println(\的随机数为 \

System.out.println(\的随机数为 \System.out.println(\的随机数为 \System.out.println(\的随机数为 \

System.out.println(\弧度的正弦值：Math.sin(Math.toRadians(30.0))＝ \System.out.println(\的对数值：Math.log(Math.E)＝ \System.out.println(\的3 次方：Math.pow(2.0, 3.0)＝ \System.out.println(\四舍五入：Math.round(33.6F)＝ \}

}

（2）编译并运行程序，并分析运行结果。

2.java.lang 有两个字符串类String 和StringBuffer，封装了字符串的全部操作。其中String 用来处理创建以后不再改变的字符串，StringBuffer 用来处理可变字符串。 String和StringBuffer为最终类，不能派生子类，可以防止用户修改。String 和StringBuffer 类在运行时要经历严格的边界条件检验，可以自动捕获异常，可以提高程序的健壮性。

（1）创建使用String 和StringBuffer 类的程序

（2）程序功能：实现字符串的翻转。源代码如下： import java.applet.Applet; import java.awt.Graphics;

public class LX8_2 extends Applet {

public void paint(Graphics g) {

String str=\这是一个字符串——This is a test string\g.drawString(\正常字符串：\

g.drawString(\翻转字符串：\}

public String reverse(String s) {

int len=s.length();

StringBuffer buffer=new StringBuffer(len); for (int i=len-1; i>=0; i--)

buffer.append(s.charAt(i)); return buffer.toString(); } }

（3）编译LX8_2.java 程序文件。

（4）编写显示LX8_2.class 的页面文件LX8_2.html，源代码如下。

（5）在浏览器打开LX8_2.html 文件，并观察运行结果。 （6）程序分析：

程序在paint 方法中首先定义一个String 类对象str， 将\将字符串常量赋给了str（实际的程序流程为Java 系统先为字符串常量创建一个无名字符串对象，然后再把字符串的引用赋给str）。然后使用Graphics 的对象g，调用drawString 方法输出原始字符串，然后输出翻转后的字符串，对字符串的翻转操作使用自定义的reverse 方法实现。

2.掌握Applet的生命周期与绘图周期。 3.了解Applet与浏览器的通信。 4.掌握在Applet图形界面设计。 三、实训内容 参考教材内容编写、运行下列程序，并得到正确的结果。

1.编写Applet,从HTML文件中获取两个字符串参数,并将它们在浏览器中显示出来。 2.编写Applet,显示http://www.lzptc.edu.cn的页面内容。

3.编写Applet,包含一个文本框和一个按钮,单击按钮时,在浏览器的状态行显示文本框中的内容。

4编写Applet,显示不同大小不同风格,类型的字体

5.编写Applet,绘制直线,各种矩形,多边形,圆和椭圆等图形。 6.编写Applet,显示一排用随机定义的颜色所填充的小方块。

7.编写Applet,在浏览器中显示图片文件,包括原图,缩小一半图,宽扁图和瘦高图。 8.编写Applet播放两段音乐,一段是连续播放的背景音乐,一段是独立的整段音乐。

实训十一 GUI标准组件及事件处理

一、实训目的

1.掌握图形用户界面基本组件窗口、按钮、文本框、选择框、滚动条等的使用方法。 2.了解如何使用布局管理器对组件进行管理，以及如何使用Java 的事件处理机制。 二、实训要求

1.掌握在Applet 容器中添加组件的方法，掌握使用布局管理器对组件进行管理的方法。 2.理解Java 的事件处理机制，掌握为不同组件编写事件处理程序的方法。 3.掌握编写独立运行的窗口界面的方法。 4.了解对话框的使用方法。 三、实训内容

图形用户界面（Graphic User Interface ，简称GUI）是为方便用户使用设计的窗口界面，在图形用户界面中用户可以看到什么就操作什么，取代了在字符方式下知道是什么后才能操作什么的方式。

组件（Component）是构成GUI 的基本要素，通过对不同事件的响应来完成和用户的交互或组件之间的交互。组件一般作为一个对象放置在容器（Container）内，容器是能容纳和排列组件的对象，如Applet、Panel（面板）、Frame（窗口）等。通过容器的add 方法把组件加入到容器中。

1.编写一个图形界面的Java Application，为用户提供三种关闭窗口的方法：使用按扭，使用菜单项，使用窗口关闭图标。

2.编写实现一个模拟手机的图形用户界面，包括一个显示区和一个键盘区，显示区用来显示数字和信息，键盘区包括0～9 10个数字键和“发送”、“清零”、“关机”三个命令键。考虑使用什么样的图形界用户界面布局策略。

3为上题所编写的界面增加事件响应功能：当用户按数字键时，相应的数字回显在显示区上；当用户按“清零”键时，显示区的数字清空；当用户按“发送”键时，显示区中出现当前的号码和“拨号中......”的信息；当用户按关机键时结束程序。

4.编程实现一个学生信息管理系统的图形界面。需要录入的信息包括学生学号、姓名、性别、出生年、月、日、年级以及是否联合培养。根据这些信息的性质选择使用不同图形组件来设计界面。

5.为上题任务所编写的界面增加事件响应功能。当用户选定了某一个出生月份，例如3

月份时，系统自动把日期的选择范围限制到1～31之间；当用户单击“录入”按扭时，系统把所有的学生信息打印在屏幕上。

实训十二 多线程机制

一、实训目的

1.线程的概念，线程的生命周期。

2.多线程的编程：继承Thread类与使用Runnable接口。 3.使用多线程机制实现动画。 二、实训要求

1.理解用创建Thread子类的方法实现多线程。 2.理解用实现Runnable接口的方法实现多线程。 3.利用多线程编程实现一个正在旋转的地球。 三、实训内容

程序（program）是对数据描述与操作的代码的集合，是应用程序执行的脚本。进程（process）是程序的一次执行过程，是操作系统运行程序的基本单位。程序是静态的，进程是动态的。系统运行一个程序就是一个进程从创建、运行到消亡的过程。线程是比进程更小的运行单位，是程序中单个顺序的流控制。一个进程中可以包含多个线程。线程是一种特殊的多任务方式。当一个程序执行多线程时，可以运行两个或更多的由同一个程序启动的任务。这样，一个程序可以使得多个活动任务同时发生。

1．使用线程创建动画的程序（如下图） （1）程序功能：创建一个显示小球不断跳动并显示不同状态的动画程序。要达到无闪烁现象，显示速度快，占用内存较小的要求。即要使用双缓冲技术创建图像的显示方式，清除闪烁现象。使用线程分别解决准备图像、显示图像的任务，解决显示速度慢，占用内存较大的问题。

程序说明：

程序中使用图形双缓冲技术，显示一组图像。程序实现Runnable 接口中的run 方法，这是一个和Applet 同时运行的线程。对线程的控制由Applet 的start 和stop 方法完成，Applet 运行时，就在start 方法中启动线程，Applet 停止时，就在stop 方法中停止线程。

在线程td 的run 方法中的永恒循环当中，实现图像的轮流显示使小球不停的跳动。首先调用绘图对象g1 的drawImage 方法把当前图像画在屏幕缓冲区内，在paint 方法中把屏幕缓冲区拷贝到屏幕上。但paint 方法无法直接调用，因为要传递给它一个图形参数g，故调用repaint 方法间接调用paint方法。repaint 方法无参数，它将调用update 方法，由update 方法调用paint 方法并传递g 参数。这就是曾介绍过的一个线程负责准备图像而另一个线程负责显示图像的动画方法。

（2）准备10 个图像文件（T1.JPG～T10.JPG），它们分别显示小球不同时间的高度和状态，存放在“程序/image”目录下。这是创建动画的基础工作，是动画显示的内容，应用程序只是解决图像“动”即显示的方式。

（3）编写该程序文件，源代码如下。 import java.awt.*; import java.applet.*;

public class LX13_1 extends Applet implements Runnable {

Image img[]=new Image[10]; Image buffer; Graphics g1; Thread td; int index=0;

public void init() {

buffer=createImage(getWidth(),getHeight());//创建图像缓冲区 g1=buffer.getGraphics();//创建绘图区 for (int i=0;i<10;i++)

img[i]=getImage(getCodeBase(),\}

public void start() {

if (td==null) {

td=new Thread(this);//创建线程对象 td.start(); } }

public void stop() {

if (td!=null)

td=null;

}

public void run() {

while(true) {

g1.drawImage(img[index],10,20,this);//画图像到缓冲区 repaint();//画出图像 try {

td.sleep(50);

} catch (InterruptedException e) {}

g1.clearRect(10,20,100,100);//清除缓冲区中的图像 index=++index; } }

public void paint(Graphics g) {

g.drawImage(buffer,0,0,this);//画出缓冲区中图像 }

public void update(Graphics g) {

paint(g);

}

}

（4）编写显示LX13_1.class 的页面文件，在浏览器中显示结果。 2．运行下面的程序，理解用创建Thread子类的方法实现多线程。 class SimpleThread extends Thread {

public SimpleThread(String str) {

super(str); }

public void run() {

for (int i = 0; i < 10; i++) {

System.out.println(i + \try {

sleep((int)(Math.random() * 1000)); } catch (InterruptedException e) {} }

System.out.println(\} }

public class TwoThreadsTest {

public static void main (String[] args) {

new SimpleThread(\new SimpleThread(\} }

3．运行下面的程序，理解用实现Runnable接口的方法实现多线程。 //这是一个时钟Applet，它显示当前时间并逐秒进行更新。 import java.awt.*; import java.applet.*; import java.util.*;

public class Clock extends Applet implements Runnable{

Thread clockThread; public void start(){

if(clockThread==null){

clockThread=new Thread(this,\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()+\}

public void stop(){

clockThread.stop(); clockThread=null; }

}

4．自主设计题

设计一个交通信号灯类：

（1）变量：位置、颜色（红、黄、绿）、显示时间。

（2）方法：切换信号灯。创建并启动两个线程（东西向、南北向）同时运行。 3．实验要求

（1）根据需要设计多个线程。 （2）设计路口信号灯示意图界面。

（3）可将信号灯按方向分为3 种车道灯：左转、直行和右转。 （4）根据车流量进行时间的模糊控制。

实训十三 流式输入输出

一、实训目的

1.了解流式输入输出的基本原理。

2.掌握类File，FileInputStream，FileOutputStream，RandomAccessFile的使用方法。 二、实训要求

1.学习文件和目录的简单操作。

2.创建一个顺序文件，向其中写入部分用户键盘输入的字符，并回显在屏幕上。 3.学习随机文件的读写。 三、实训内容

1．运行下面的程序，学习文件和目录的简单操作。 //运行前先在当前目录中建立一个目录，目录名为test，向其中随意放入几个文件。import java.io.*;

public class FileOperation{

public static void main(String args[]){

try{

BufferedReader din = new BufferedReader(new InputStreamReader(System.in));

String sdir = \String sfile;

File Fdir1=new File(sdir);

if (Fdir1.exists()&&Fdir1.isDirectory()){

System.out.println(\for( int i=0; i< Fdir1.list().length; i++) //列出目录下内容

System.out.println( (Fdir1.list())[i]); File Fdir2=new File(\if(!Fdir2.exists()) Fdir2.mkdir();

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