第二次实验: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实现数据报通信的基本工作过程。