Java实验教案

 

 

《Java程序设计》

实验教案

 

 

 

 

 

 

 

 

 

 

 

 

 

第一次实验(课后自学):JDK开发工具的使用

一.实验目的

1.                 掌握使用JDK开发Java程序的步骤。

2.                 掌握JDK开发环境(环境变量)的设置。

3.                 掌握Java程序的基本语法,学会编写简单的Java程序。

二. 实验要求

    1. 下载安装JDK 软件开发包,并设置环境变量。

    2. 掌握使用JDK编写Java程序的步骤。

    3. 编写一个简单的 Java Application程序。

4. 编写一个简单的 Java Applet程序。

三.实验内容

 1.JDK开发环境的设置。

为了能正确方便的使用SDK,需要手工配置一些 Windows 的环境变量,具体步骤如下:

¨        在桌面“我的电脑”图标上单击右键,选择“属性”菜单,将出现“系统属性”设置界面

¨        在“高级”选项卡中单击“环境变量”按钮。将出现“环境变量”设置界面

 

 

¨        在“系统变量”框中单击“新建”按钮,在出现的“新建系统变量”对话框中输入:  变量名(N):   Path

        变量值(V):   C:\Program Files\Java\jdk1.5.0\bin

 

¨        在“系统变量”框中单击“新建”按钮,在出现的“新建系统变量”对话框中输入:  变量名(N):   ClassPath

        变量值(V):   .; C:\Program Files\Java\jdk1.5.0\lib

 

¨       多次点击“确定”按钮,以保存设置。

 

2.熟悉命令行(MS-DOS)的操作方式。

(1)怎样进入DOS界面:

① “开始”菜单---“程序”---“附件”---“命令提示符”
②“开始”菜单---“运行”---“输入命令cmd”

 

(2)掌握下面DOS命令:

        输入    D:    表示进入D盘。

 cd 文件夹的名字          例如:cd  java 将进入java目录

 

3.按下面步骤进行实验

(1)    开机后,创建目录D:\java\javacode。把这个目录作为我们的工作目录。我们的Java源程序、编译后的字节码文件和用来运行Java Applet的html文件都放在这个目录中。

(2)    在Windows XP中启动记事本。

(3)    用记事本编辑如下源程序

              public class HelloWorldApp {

            public static void main(String[] args) {

                 System.out.println("HelloWorld!");

               }

}

   

(4)    保存程序。注意,保存源程序时,程序名要与类名一致。所以用HelloWorldApp.java作为本程序的文件名。记事本默认的扩展名是 .txt,所以要给文件名加引号后保存。把该文件保存到目录D:\java\javacode中。

(5)    编译程序。启动MS_DOS窗口,首先键入如下命令,

       C:\ Documentsand Settings\Administrator>  D:

由当前目录进入D盘。

接着,键入如下命令,

              D:\>  cd \java\javacode

进入源程序所在目录D:\java\javacode。

最后,键入如下命令,把HelloWorldApp.java编译成字节码文件。

       D:\java\javacode> javac HelloWorldApp.java 

如果编译成功,则在D:\java\javacode目录中生成字节码文件HelloWorldApp.class

 

(6)       运行程序

进入HelloWorldApp.class所在目录D:\java\javacode,键入命令

D:\java\javacode>   java HelloWorldApp

就可以运行程序

(7)    观察程序的运行结果

(8) 如果把上面程序中的第二条语句 public static void main( String args[] ) 改成 public void main( Stringargs[] ) 行不行?如果改成public static void main(String arg [] ) 行不行?不行的话把编译时的错误提示信息记录下来。

 

 

 


 4.了解下面的Java Applet的程序结构和开发过程。

 (1)打开Notepad编辑器。
 (2)键入如下程序:
 import java.awt.Graphics;
 import java.applet.Applet;
 public class HelloWorld extends Applet{
     public void paint(Graphics g){
              g.drawString("Hello World!",25,25);
     }
 } 

(3)检查无误后 (注意大小写)保存文件。可将文件保存在"D:\java\javacode "目录中,注意文件名为HelloWorld.java。

(4)进入命令行(MS-DOS)方式,进入当前目录为"D:\java\javacode",键入命令:

D:\java\javacode\Javacode >javac HelloWorld.java
       (5)如果输出错误信息,则根据错误信息提示的错误所在行返回Notepad编辑器进行修改。常见错误是类名与文件名不一致、当前目录中没有所需源程序、标点符号、全角等。
       如果没有输出任何信息或者出现"deprecation"警告,则认为编译成功,此时会在当前目录中生成HelloWorld.class文件。
       (6)打开Notepad编辑器,键入如下程序:
<HTML>

       <HEAD>

              <TITLE> A Simple Program</TITLE>

       </HEAD>

       <BODY>

              Here is the output of my program:

              <APPLET CODE="HelloWorld.class"WIDTH=150 HEIGHT=25>

              </APPLET>

       </BODY>

</HTML>

(7)检查无误后 (注意大小写)保存文件。可将文件保存在"D:\java\javacode "目录中,注意文件名为Hello.html。

(8)进入命令行(MS-DOS)方式,进入当前目录为"D:\java\javacode",键入命令:D:\java\javacode > appletviewer Hello.html

   (9)如果把(2)中的程序的前面两条语句: import java.awt.Graphics; 和
 import java.applet.Applet; 删除的话,程序还能不能正常运行?如果不行请各位同学收集编译时的错误提示信息,并且说明这两条语句的作用。

四、实验总结

请在实验报告中对本次实验内容进行总结。

 

第二次实验: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.    说明类的继承和多态都有什么作用?

 

答:继承,子类继承父类中所以的属性和方法,但是对于private的属相和方法,由于这个是父类的隐私,所以子类虽然是继承了,但是没有可以访问这些属性和方法的引用,所以相当于没有继承到。很多时候,可以理解为,没有继承。
多态:就是父类引用可以持有子类对象。这时候只能调用父类中的方法,而子类中特有方法是无法访问的,因为这个时候(编译时)你把他看作父类对象的原因,但是到了运行的时候,编译器就会发现这个父类引用中原来是一个子类的对像,所以如果父类和子类中有相同的方法时,调用的会是子类中的方法,而不是父类的。

 

 

 

 

 

 

 

 

 

 

 

第五次实验:类的多态性

一、实验目的

理解类的多态性,掌握方法的继承、重载和覆盖,掌握如何从键盘输入数据以及多重循环的使用。

二、实验要求

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(Stringname)然后对成员变量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实现数据报通信的基本工作过程。

 

 

展开阅读全文

没有更多推荐了,返回首页