应用数学学院专业 1 班、学号__

姓名___ __ 教师评定_________________

实验题目           继承与接口          

一、    实验目的与要求

实验目的：

1、掌握类的继承关系。

2、掌握接口的定义与使用。

实验要求：

    按下列要求编写Java程序：

1、定义接口Printx，其中包括一个方法printMyWay()，这个方法没有形参，返回值为空。

2、编写矩形类，矩形类要求实现Printx接口，有求面积、求周长的方法，printMyWay()方法要能显示矩形的边长、面积和周长。

    3、编写正方形类作为矩形类的子类，正方形类继承了矩形类求面积和周长的方法，新增加求对角线长的方法，重写printMyWay()方法，要求该方法能显示正方形的边长、面积、周长和对角线长。

二、    实验方案

编辑该实验源程序如下:

■LISTEN.java

  interface Printx{           //定义接口

     public abstract void  printMyWay();

 }

  class Rectangle implements Printx{    //矩形类

      double a,b;

      Rectangle(double a,double b){

          this.a=a;

          this.b=b;

      }

      public double getArea(){

          return a*b;

      }

      public double getLength(){

          return (a+b)*2.0;

      }

       public  void printMyWay(){

           System.out.println("该矩形的长a="+a+"宽b="+b);

           System.out.println("面积s="+getArea());

           System.out.println("周长l="+getLength());

       }

 }

  class Square extends Rectangle{  //正方形类

      double c;

      Square(double a,double b){

         super(a,b);

      }

      public double getDiagonal(){

          c=Math.sqrt(a*a+b*b);

          return c;

      }

      public  void printMyWay(){

          System.out.println("该矩形的长a="+a+"宽b="+b);

          System.out.println("面积s="+getArea());

          System.out.println("周长l="+getLength());

          System.out.println("对角线d="+getDiagonal());

       }

  }

   

public class LISTEN {

    public static void main(String[] args) {

       Rectangle rectangle;

       Square square;

       rectangle=new Rectangle(11,5);

       square=new  Square(5,5);

      rectangle.printMyWay();

      square.printMyWay();

    }

}

三、    实验结果和数据处理

         运行上述源程序，可得如下运行结果：

1、矩形长a=11 宽b=5

2、矩形长a=5  宽b=5

  

四、    结论

接口是Java实现部分多继承功能的体现。运用接口编辑程序，可以提高程序的灵活度，，降低了类的冗余度，有效地提高了资源的利用率。程序中，子类Square继承了父类Rectangle的一些方法，省去了对getArea()和getLength()的再次声明定义。

五、    问题与讨论

在编译程序的时候一开始对于知识的掌握不牢固，看了很久的书才有些理解，有些细节过于粗心，导致编译过程浪费太多时间。

 

第二篇：java实验指导书

实验一、安装JDK并熟悉java的运行环境

实验二、基本语法练习

实验三、面向对象编程实验(4)

实验四、异常处理实验

实验五、小应用程序实验

实验六、图形图像实验

实验七、GUI（图形用户接口）实验(4)

实验八、多线程实验

实验九、输入输出流实验(4)

实验十、数据库应用实验(4)

实验一、安装JDK并熟悉java的运行环境

一、实验目的  

熟悉JAVA的运行环境及学习简单的编程。

二、预习内容

安装工具软件的基本方法。

三、实验设备与环境

装有JAVA语言工具软件 (JCreator )的微机若干

四、实验内容 

安装JCreator及JAVA的核心编译程序J2SDK。

1、打开JCreator的安装盘安装JCreator。

2、在相同目录下安装J2SDK。

3、打开JCreator软件对J2SDK文件进行配置。

4、编写一应用程序，在屏幕上显示“HELLO WORLD”。

    Pulic class Hello

     {

        public static void main(String args[])

         {

            System.out.println(“HELLO WORLD”);

}

}

5、编写一小程序实现上述功能：在屏幕上显示“HELLO WORLD”。

五、注意事项  

⒈认真填写实验报告

⒉遵守实验室各项制度，服从实验指导教师的安排

⒊按规定的时间完成实验

六、说明 

 本次实验建议学时数2学时

实验二、基本语法练习

一、实验目的

   ⒈熟悉Java的基本语法

⒉编写应用程序接收命令行参数

⒊编写应用程序接收用户从键盘的输入

⒋掌握字符串与数组的基本方法

二、预习内容

     java编程的基本结构 

三、实验设备与环境

 装有JAVA语言工具软件 (JCreator )的微机若干

四、实验内容

⒈编写一个应用程序求若干个数的平均数，原始数字要求从命令行输入。应用程序中main方法的参数String类型的数组args能接受用户从命令行键入的参数。

(1)编辑Average.java，设保存在D:\myjava目录下。

  class Average

   {

     public static void main(String args[ ])

      {

        double n,sun=0;

        for (int l=0;l<args.legth;l++)

         {

           sum=sum+Double.valueOf(arg[l].doubleValue();)

}

  n=sum/args.length;

  System.out.println(“average=”+n);

}

}

(2)编译。键入如下命令：

  D:\myjava>java Average.java

(3)执行。键入如下命令。注意，命令行参数之间用空格分隔。

  D:\myjava>java Average.java“12.34”“34.45”“21212121”

注意：

1）  参数的个数可以利用args.length来取得。

2）  参数“12.34”“34.45”“21212121”分别赋给了main方法的参数arges[0]、arges[1]  和arges[2]。

3）  由于arges[0]、arges[1]和arges[2]是String类型的，所以要利用Double.valueOf（String s）方法将String类型转化成Double类型，再用double Value（）方法求出double类型的值。

⒉编写一个应用程序，接受用户从键盘输入的摄氏温度，然后将其转化成等效的华氏度温度。

方法一：利用System .in.read（）方法可以接受从键盘输入的unicode码，编写一个循环取键值，循环出口为当输入回车时，即判断键值是否为13，若是，则退出循环。

(1)    编辑Accept.java，设保存在D:\myjava目录下。

import java.io.*;
import java.io.*;

class Accpet

 {

   public static void main(String [ ] args)

{

  int c=0;

  String s=“”;

  System.out.println(“输入摄氏度：（0<数值<100）”);

  //System.in.read()语句需要加try/cacth（）捕获异常

  tyr

  {

    while (c!=13)        //当输入的不是回车

     {

       c=Sytem .in.read();

       s=s+(char)c;      //将int型转化成char型，再连接成字符串

}

}

catch (Exception e){}

int celsius=Intgeer.parseInt(s.trim());

double fahre=1.8*celsius+32;

System.out.println(“转化成华氏度为：”+fahre)；

}

}

注意：

1）in是System类的一个属性，System.in的返回类型是InputStream类型。输入字节流的父类，InputStream类中的read（）方法可以读取一个用户从键盘上输入的键值。System.im.read（）的返回值是整型，因此需要先转化成字符型后再连接成字符串。

2) System.im.read（）需要用try/catch机制来捕获异常。

3)将字符串转化成响应的整型数值后再利用公式计算出华氏温度。

方法二：由于InputStream类中的read（）方法只能读取一个键值，所以需要利用循环才能读出用户从键盘输入的一串字符，有没有读取一行字符的命令呢？我们可以利用Java中类的嵌套来实现。由于BuffereReaser类有读取一行字符串的方法，所以可以这样去定义对象：

BuffereReaser br=new BuffereReaser(new InputStreamReader(System.in));

(1)    编辑Accpe1.java，设保存在D:\myjava目录下。

Class Accpt1

 {

   publib static void main(String args[ ])

{

 String s=“”;

 System.out.println(“输入摄氏度：（0<数值<100）”)；

 BuffereReaser br=new BuffereReaser(new InputStreamReader(System.in));

try

{

  s=br.readLine();

}cath(Exception e){}

int cel=Integer.parseInt(s.trim());

double f=cel*1.8+32;

System.out.println(s+“摄氏度转化成华氏度为：”+f)；

}

}

⒊编写应用程序，按升序顺序输出一维数组中的元素。

排序的方法有很多，常用的有选择发和冒泡法，在此使用选择法。

(1)    编辑Sort.java，设保存在D:\myjava目录下。

class Sort

 {

   public static void main(String args[ ])

{

  int a[ ]={1,3,5,6,0,2,7,9,8};

  int temp;

  int k;

  int len=a.length;

  for (int i=0;i<len-1; i++)

   {

     k=i;

     for(int j=i+1;j<len;j++)

      {

        if (a[k]>a[j]) k=j;

}

 temp=a[i]; a[i]=a[k];a[k]=temp;

}

for(int i=0;i<len;i++)

System.out.print(a[i]+“”)

}

}

五、注意事项

⒈认真填写实验报告

⒉遵守实验室各项制度，服从实验指导教师的安排

⒊按规定的时间完成实验

六、说明 

⒈建议学时数2学时

实验三、面向对象编程实验

一、实验目的  

⒈掌握接口的编写及使用

⒉理解继承、多态

⒊掌握包的编写以及如何使用包中的类

二、预习内容   

java的基本语法知识

三、实验设备与环境

装有JAVA语言工具软件 (JCreator )的微机若干

四、实验内容 

⒈接口的编写

(1)    编辑Interfaceclass.java，设保存在D:\myjava目录下。

interface Interfaceclass

 {

   int i=4;

   int k=5;

   void func1();

   int func2(int x);

}

(2)    编辑UseInterface.java，设保存在D:\myjava目录下。

  class UseInterface implements Interfaceclass

   {

int j;

public void func1()  //在使用接口的类中一定要实现接口中的所有抽象方法

 {

  System.out.println(“func1=”+1);

}

          public int func2(int i)

           {

System.out.println(“func2=”+1);

ieturn i;

}

          public static void main(String srgs[ ])

           {

//Interfaceclass.class x=new Interfaceclass.class();不能对接口进行实例化

UseInterface x=new UseInterface();

x.func1();

x.func2(k);

}

}

⒉多态在工资系统中的应用

下面给出一个根据雇员类型利用abstract方法和多态性完成工资单计算的程序。      Employee是抽象类，Employee的子类有Boss（每星期发给他固定工资，而不计工作时间）、      CommissionWorker（除基本工资外还根据销售额发放浮动工资）、PieceWorker（按其生产的产品数发放工资）、HourlyWorker（根据工作时间长短发放工资）。该例的Employee的每个子类都声明为final，因为不需要再继承它们生成子类。

对所有雇员类型都使用earnings()方法，但每个人挣的工资按他所属的雇员类计算，所有雇员类都是从超类Earnings()派出生的。所有在超类中声明earnings()为抽象方法，并且对于每个子类都提供恰当的earnings()的实现方法。为了计算雇员的工资，程序仅仅使用雇员对象的一个超类引导 并调用earnings()方法。在一个实际的工资系统中，各种Employee对象的引用可以通过一个Employee引用数组来实现。程序依次使用数组的每个元素（Employee引用）调用每个对象的employee()方法。

（1）编辑Test.java，设保存在D:\myjava目录下。  

//Employee超类的定义

abstract class Employee

{

 private String firsrName;

 private String lastName;

 public Employee(String first,String last)

 {

  firstName=first;

  lastName=last;

  }

 public String getEmployeeName()

  {

return firstName;

}

publicString getLastName()

{

  return lastName:

}

public String toString()

 {

return firstName+lastName;

}

public absteac double earnings();

}

//定义Boss类，为Employee的子类

final class Boss extends Employee

{

 private double weeklySalary;

 public Boss(String frist,string lasr,double s)

 {

super(first,last);

setWeeklySalary(s);

}

 public woid setWeeklySalary(double s)

 {

  weeklySalary=(s>0?s:o\0);

  }

 public double earnings()

 {

return “Boss”+super.roString();

}

}

//定义CommissiomWorker类，为Employee的子类

final class CommissionWorker extends Employee

{

 private double salary;

 private double commission;

 private int quantity;

 public CommissionWorker(String first,String last,double s,double c,int q)

 {

  super(frist,last);

  setSalary(s);

  setCommission(c);

  setQuantit(q);

 }

public voids setQusntily(double s)

{

   salary=(s>0?q:0);

}

public double setCommission(double c)

{

   commission=(c>0?c:0);

}

 public double earnings()

 {

  return salsry+commission+quantity;

  }

  pulic String toString()

  {

   return“CommissionWorker”+super.tostring();

   }

}

//定义PieceWorker类，为Employee的子类  

final class PieceWorker extends Employee

 {

private double wagePiece;

private int quantity;

public PieceWorker(String first,String last,double w,int q)

{

 super(first,last);

 setWage(w);

 setQuantity(q;)

  }

 public void setWage(double w)

  {

wagePerPiece=(w>0?w:0);

  }

 public void setQuantity(int q)

 {

return quantity+wafePerPiece;

}

 public String toString()

  {

   return “PieceWoeker”+super.toString();

  }

}

定义HourlyWorker类，为Employee的子类  

class HourlyWorker extends Employee

{

 private double wage;

 prvate double hours;

 public HourlyWorker(String first,String last ,double w,double h)

 {

  super(first,last);

  setWage(w);

  serHouts(h);

  }

 public void setWage (double w)

 {

  wage=(w>0?w:o);

 }

public void setHours(double h)

 {

  hours=(h>=0&&h<168?h:0);

  }

public double earnings()

 {

  return “HourlyWorker”+super.toString();

 }

}

class Text

{

 public static void main(string args[ ])

 {

//使用超类声明ref  

  Employee ref;

  String output=“”;

//分别定义各子类

  Boss b=new Boss(“Hohn”,“Smith”,800.00);

  CommissionWorker c=new CommissionWorker(“Sue”,“Hones”,400.00,3.0,150);

  PieceWorker p=new PieceWorker(“Bob”,“Lewis”,2.5,200);

  HourlyWorker h=new HourlyWorker(“Karen”,“price”,13.75,40);

//使用子类分别实例化

ref=b;

out+=ref.toString()+“earned $”+ref.earnings+“\n”+b.toString()+“earned $”+b.earnings+“\n”;

System.out.print(output);

ref=c;

out+=ref.toString()+“earned $”+ref.earnings+“\n”+c.toString()+“earned $”+c.earnings+“\n”;

System.out.print(output);

ref=p;

out+=ref.toString()+“earned $”+ref.earnings+“\n”+p.toString()+“earned $”+p.earnings+“\n”;

System.out.print(output);

ref=h;

out+=ref.toString()+“earned $”+ref.earnings+“\n”+h.toString()+“earned $”+h.earnings+“\n”;

System.out.print(output);

}

}

⒊ 包的建立与使用

（1）       编辑Calculate.java，设保存在D:\myjava目录下。

package mypackage;

public class Calculate

{

 private int a;

 public Calculate(int a)

 {this.a=a;

System.out.printl(“from constrartion”+this.a);

}

 public double volume(double height,double width,doule depth)

 {

  return height*width*depth;

  }

 int add(int x, int y)

 {

  return x+y;

  }

 protected void a()

 {

  System .out.println(“from constration”+a);

 }

}

编译，查看D:\myjava目录下是否生成了myoackage文件夹，在该文件夹中是否有Calculate.class文件。

 

（2）       编辑Interfaceclass.java，设保存在D:\myjava目录下。

    import mypackage.Calculate;

class PackageDemo

{

 public static void main(string ags[ ])

 {

  Calculate c=new Calculate(10);

  double s=c.volume(5,6,7);

  System.out.println(s);

  //int b=c.add(5,6);

  //c.a();

 }

}

五、注意事项

⒈认真填写实验报告

⒉遵守实验室各项制度，服从实验指导教师的安排

⒊按规定的时间完成实验

实验四、异常处理实验

一、实验目的  

⒈异常的生产及捕获

⒉自定义异常及其使用

二、预习内容   

面向对象的基本知识

三、实验设备与环境

装有JAVA语言工具软件 (JCreator )的微机若干

四、实验内容 

⒈异常的捕获

计算两数相除并输出结果。使用两个catch子句，分别捕捉除数为0的异常和参数输入有误异常。

编辑Ex1.java，保存在D:myjava目录下。

Import  java.io.*;

Class  Ex1

{

public  static  void  main(string  args[ ])

{

     try{

     BufferedReader  strin=new  BufferedReader (

     new  InputStreamReader(System .in);

     System .out .print(“请输入除数：”)

     String  cl=strin .readLine();

     int  a=Integer .parseInt(cl);

     System .out .print(“请输入被除数：”)

     cl=strin .readLine();

     int  b=Integer .parseInt(cl)

     int  c=b/a;

     System .out .println(“商为：”+c);

 }

 //捕获与I/O有关的异常

 catch(IOException  e){eprintStackTrace();}

 //捕获数值转化时的异常，如不能将字符转化成数值

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

 //捕获数值转化时的异常，如不能将字符转化成数值

 catch(NunberFormatException  e){

 System .out .println(“请输入整数！”)；

 //e .printStackTrace();

 }

 //捕获除数为0的异常

 catch(ArithmeticException  e){

          System .out .println(“除数不可以0！”)；

          //e .printstackTrace();

          }

          }

}

     编译并运行，当输入除数为0时，将有异常出现，当输入的不是整数时，如将30输成了3o，出现的是另一种异常。

⒉定义异常

编写程序包含自定义异常，当输入数值为13和4时抛出该异常。

编辑Ex2.java，设保存在D:\myjava目录下。

  class Ex2 extends Exception

{

 Ex2(String msg)

 {

  super(msg);

  }

}

class MyEx

{

 private int x;

 void setX(int x)

 {

  this.x=x;

 }

 void f1() throws Ex2

 {

  if(x==13)

   throw new Ex2(“I don’t like 13!”);

 else if(x==4)

   throw new Ex2(“I don’t like 4!”);

 else

   system .out.println(100/x);

}

public static void main(Sstring args[ ])

{

 MyEx a=new MyEx();

 try

 {

  a.steX(5);

  //a.setX(13);

//a.setX(4);

//a.setX(0);

a.f1();

}

 catch(Ex e)

 {

  Sytem .out.println(“get message:”+e.getMessage());

 }

}

编译并运行，分别取消注释上面程序中被注释的语句。当释放a.setX（13）语句后，查看运行结果，当释放a.setX（4）语句后，查看运行结果。

五、注意事项

⒈认真填写实验报告

⒉遵守实验室各项制度，服从实验指导教师的安排

⒊按规定的时间完成实验

六、说明

  ⒈建议学时数2学时

实验五、小应用程序实验

一、实验目的  

⒈掌握小应用程序的结构及生命周期

⒉掌握带参数小应用程序的编写

二、预习内容   

网页制作的相关知识

三、实验设备与环境

装有JAVA语言工具软件 (JCreator )的微机若干

四、实验内容 

⒈小应用程序生命周期

小应用程序有init()、start()、stop()和detroy()方法，当小应用程序初次加载时，先执行init（），再执行stop()方法。当小应用程序的窗口从后台恢复到前台时，如当小应用程序的窗口被最小化时，会执行stop()方法，窗口还原时会执行start()方法，这时不执行init()和detroy()方法。当小应用程序被关闭时，再执行detroy()方法。

编辑AppLife.java，设保存在D:\myjava目录下。

Import  java .applet .*;

import  java .awt .*;

Public  class  AppLife  extends  Applet

{

   static  int  a,b,c,d;

   int  xl=150,yl=50,x2=300,y2=50;

   putlic  void  paint  (Graphics  g)

   {

g.drawLine(x1,,y1,x1,y2);                         

g.drawLine(x1,y1,x1,y1+a);

g.drawString (“init”,x1,y1);

g.drawLine(x1+50,y1,x1+50,y1+b);

g.drawString(“start”,x1+50,y1);

g.drawLine(x1+100,y1,x1+100,y1+c);

g.drawString(“stop”,x1+100,y1);

g.drawLine(x1+150,y1,x1+150,y1+d);

g.drawString(“destory”,x2,y2);

   }

public  void  init()

   {

         a+=50;

         repaint();

   }

   public  void  start()

   }

         b+=50;

         repaint();

   }

   public  viod  stop()

   {

         c+=50;

         repaint();

   }

   public  viod  destroy()

   {

         d+=50;

         repaint();

   }

}

注意问题：

（1）       编译AppLife.java。

（2）       编辑AppLife.htm，要求存放在与AppLife.class相同的目录下。

<applet code=“AppLife.class” height=300 width=400>

</applet>

（3）       运行AppLife.htm。

⒉带参数的小应用程序

编写一个小应用程序，由htm文件向其传递参数。

编写App.java，设保存在D:\myjava目录下。

import java.applet.*;

import java.awt.*;

public class App extends Applet

{

 String name;

 public void init()

 {

  name=getParameter(“name”);

  }

 public void paint(Graphics g)

 {

  g.drawString(“Welcome”+name,120,50);

 }

}

执行步骤：

（1）       编译App.java。

（2）       编辑App.htm，要求与App.class在同一目录下。

<applet code=“App.java” height=300 width=400>

<param name=“name” value=“Suesan”>

</applet>

执行App.htm。

五、注意事项  

⒈认真填写实验报告

⒉遵守实验室各项制度，服从实验指导教师的安排

⒊按规定的时间完成实验

六、说明

⒈建议学时数2学时

实验五、小应用程序实验

实验六、图形图像实验

一、实验目的  

⒈了解Java.awt包中提供的Font类、Color类、Graphics类和Image类

⒉掌握设置控制GUI组件字体和颜色的一般方法

⒊掌握使用Graphics绘制线条、矩形、圆角矩形、椭圆、弧等基本图形

⒋掌握使用Graphics绘制图象

二、预习内容   

绘制图形的基本方法

三、实验设备与环境

装有JAVA语言工具软件 (JCreator )的微机若干

四、实验内容 

⒈绘制图形

编辑Gra.java，保存在D:\myjava目录下。

import java.applet.*;

import class paint(Graphicds g)

{

 Font f1=new Font(“Helvetica”,Font.PLAIN,28);

 public void paint(Graphicds g)

 {

  g.setFont(f1);

  g.setCorol(Corcol,blue);

  g.drawString(“我是美丽的大气球！”,120,50);

  g.setCorol(Corol.green); 

  g.drawOval(100,20,200,100); 

g.setCorol(Corol.black);

g.fillOval(180,60,10,10);

g.fillOval(180,60,10,10);

g.setCorol(Cotol.red);

g.drawArc(130,50,50,180,180);

g.setColor(Color.yellow);

g.drawLine(150,120,150,250); }}

（1）       编译Gra.java。

（2）       编辑Gra.java，要求与Gra.class在同一目录下。

<applet code=“Gra.class” height=300 width=400>

</applet>

（3）       运行Gra.htm。

五、注意事项

⒈认真填写实验报告

⒉遵守实验室各项制度，服从实验指导教师的安排

⒊按规定的时间完成实验

六、说明

  ⒈建议学时数2学时

实验七、GUI（图形用户接口）实验

一、实验目的  

⒈掌握用MouseListener和MouseMotionListener接口处处理鼠标事件Mouse Event的方法。

⒉掌握制作菜单及处理菜单事件的方法

⒊掌握创建对话框及定位、显示、激活和关闭对话框的方法

二、预习内容   

图形用户接口编程所需的基本类及使用方法

三、实验设备与环境

装有JAVA语言工具软件 (JCreator )的微机若干

四、实验内容 

⒈制作一个简单的画板

编辑Mou.java，设保存在D:\myjava目录下。

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

public class Mou extends Applet implements MouseMotionListener

{

 int x= -1,y= -1;

 public void init()

 {

  setBackground(Color.cyan);

  addMouseMotionListener(this);

  }

 public void paint(Graphics g)

 {

  if(x!= -1&&y!= -1)

  {

   g.setColor(Color.red);

   g.drawLine(x,y,x,y);

   }

  }

  public void mouseDragged(MouseEvent e)

  {

   x=(int)e.getX();

   y=(int)e.gety();

  }

 public void mouseMoved(MouseEvent e){} //由于使用的是Listener，需要将其他不重载的方//法，列举在这里

 public void update(Graphics g)

 {

  paint(g);

  }

}

编译并运行查看结果.

⒉菜单的编写

编辑TestMenu.java，设保存在D:\myjava目录下。

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

public class TestMenu //定义主类

{

 public static void main(String args[ ])

 {

  MyMenhFrame mf=new MyMenhFrame();

  mf.setSize(new Dimension(300,200));  //指定窗口初始大小

  mf.setVisible(ture);  //使窗口可见，默认为不可见

  }

 }

//定义窗口

class MyMenhFrame extends Frame implements ActionListener,ItemListener

{

 MenuBar m_MenuBar;

 Menu menuFile,menuEdit,m_Edit_Pasete;

 MenuItem mi_File_Open,mi_File_Close,mi_File_Exit,mi_Edit_Copy;

 MenuItem pi_New,pi_Del,pi_Pro,mi_Paste­_All,mi_Paste_Part;

 CheckboxMenuItem mi_Edit_cut;

 PopupMenu popM;

 TextAre ta;

 MyMenuFrame()

 {

  super(“拥有菜单的窗口”);  //指定窗口标题

  ta=new TextArea(“no choice”,5,20);

  ta.addMouseListener(new HandleMouse(this));  //文本域响应鼠标事件

  add(“Center”,ta);

  //创建弹出式菜单

  popM=new PopuoMenu();

  pi_New=new MenuItem(“新建”);

  pi_new.addActionListener(this);

  popM.add(pi_New);

  pi_Del=new MenuItem(“删除”);

  pi_Del.addActiomListener(this);

  opoM.add(pi_Del);

  pi_Por=new MenuItem(“属性”);

  pi_Por.addActionListener(this);

  popM.add(pi_pro);

  //将弹出式菜单加在文本域上

  ta.add.(popM);

  m_MenuBar=new MenuBar();  //创建菜单栏

  menuFile=new Menu(“文件”);  //创建菜单项、菜单自项并指定快捷键

  mi_File_Open=new MenuItem(“打开”,new MenuShortcut(‘o’));

  mi_File_Close=new MenuItem(“关闭”);

  mi_File_Exit=new MenuItem(“退出”);

  mi_File_Exit,setShortcut(new MenuShrotcut(‘x’));

 

  mi_File_Open.setActionCommand(“打开”);

  mi_File_Close.setActionCommand(“退出”);

  mi_File_Open.addActiomListener(this);

  mi_File_Close.addActiomListener(this);   //自身作为监视器

  mi_File_Exit.addActionListener(this);

  menuFile.add(mi_File_Open);

  menuFile.add(mi_File_Close);

  menuFile.addSeparator();

  menuFile.add(mi_File_Exit)

  m_MenuBar.add(menuFile);

  menuEdit=new Menu(“编辑”);

  mi_ Edit _Copy=new MenuItem(“复制”);

  mi_ Edit _Cut=new CheckboxMenuItem(“剪切”);

 

  m_Edit_Paste=new Menu(“粘贴”);

 

  mi_Paste_All=new MenuItem(“全部粘贴”);

  mi_Paste_Part=new MenuItem(“部分粘贴”);

  mi_ Edit _Copy.addActionListener(this);

  mi_ Edit _Cut.addItemListener(this);

  m_Edit_Paste.add(mi_Paste_Part);

  m_Edit_Paste.addItemListener(mi_Paste_All);

 

  mi_Paste_Part .addActionListener(this);

  mi_Paste_All.addActionListener(this);

  menuEdit.add(mi_Edit_Copy);

  menuEdit.add((mi_Edit_Cut);

  menuEdit.addSpeparator();

  menuEdit.add(mi_Edit_Paste);

  m_MenuBar.add(menuEdit);

  this.setMenuBar(m_MenuBar);  //在窗口中添加菜单栏

 }

 public void actionPerformed(ActionEvent e)

 {

  if(e.getActionCommand()==“退出”)

  {

   dispose();

   System.exit(0);

   }

   else

ta.setText(e.getActionCommand());

 }

 public void itenStateChanged(ItemEvent e)

 {

  if(e.getSource()==mi_Edit_Cut)

if(((ChenckboxMenuItem)e.getSource()).getState())

  ta.setText(“choose”+((CheckcoxMenuItem)e.getSource()).getLabel());//将时间小时在文

//本框中显示

else

   ta.setText(“no choose”+((CheckboxMenuItem)e.getSource()).getLabel());

}

 }

 class HandleMouse extends MouseAdpter  //处理鼠标事件类

 {

  MyMenuFrame m_Parent;

  HandleMouse(MyMenuFrame mf)

  {

   m_oarent=mf;

   }

   public void mouseReleased(MouseEvent e) //鼠标按键松开事件弹出菜单

   {

if(e.isPopuoTrigger())//检查鼠标事件是否是由弹出菜单引发的

m_Parent.popM.show((Component)e.getSource(),e.getX(),e.getY());

}

}

编译并运行TestMenu.class查看结果。

⒊使用Dialog实验消息对话框和一般对话框

编辑TestDialog.java，设保存在D:\myjava目录下。

 import java.awt.*;

import java.awt.event.*;

public clsaa TestDialog

{

 public static void main(String args[ ])

 {

  MyDialogFrame df=new MyDialogFrame();

  }

}

class MyDialogFrame extends Frame

implements ActionListener,ComponetListener

{

 Dialog MegDlg,InOutDlg;

 Button btn1,btn2,bnY,btnN,btnR;

 TextFile tf=new TextField(“no imformation”,45);

 TextFile gerMeg=new TextField(“inout imformation”,10);

 MyDialogFrame()

 {

  super(“use dialog”);

  btn1=new Button(“隐藏”);

  btn2=new Button(“询问”);

  btnY=new Button(“是”);

  btnN=new Button(“否”);

  btnR=new Button(“返回”);

  setLayout(new FlowLayout());

  add(tf);

  add(btn1);

  add(btn2);

  btn1.addComponentListener(this);

  this.addWindowsListener(new WinAdpt());//Frame响应窗口关闭事件

  btn1.addActionListener(this);

  btn2.addActionListener(this);

  btnY.addActionListener(this);

  btnN.addActionListener(this);

  btnR.addActionListener(this);

  setSize(350,150);

  show();

}

 public void actionPerformed(ActionEvent e) //实现Action Listener中的方法

 {

  if(e.getActionCommand()==“隐藏”)

  {

   MegDlg=new Dialog(this, “true?”,true);

 Panel p1=new Panel();

 p1.add(new Label(“continue?”));

 MegDlg.add(“Center”.pl);

 Panel p2=new Panel();

 p2.add(btnY);

 p2.add(btnN);

 MegDlg.add(“Douth”,p2);

 MegDlg.setSize(200,100);

 MegDlg,show();

}

else if(e.getActionCommand()==“响应”)

{

 InOutDlg=new Dialog(this, “input the imformation”);

 InOutDlg.add(“Center”,getMeg);

 InOutDlg.add(“South”,btmR);

 InOutDlgsetSize(200,100);

 InOutDlg.addFocusListener(this);

 InOutDlg.show();

 }

 else if(e.getActionCommand()==“是”)

 {

  MegDlg.dispose();

  btn1.setVisible(false);

  }

  else if(e.ge “否”)

  {

   MegDlg.dispose();

  }

  else if(e.get tActionCommand()==“返回”)

  {

   tf.setText(getMeg.getText()+“是对话框的输入”);
   ImOutDlg.dispose();

   }

 }

//列举Component Listener中未重载的方法

public void componentShown(componentEvent e) {}

public void componentResized(componentEvent e) {}

public void componentMoved(componentEvent e) {}

public void componentHidden(componentEvent e) {}//实现ComponentListener中的方法

{

   tf.setText(“按钮”+((Button)e.getComponent()).getLabel()+“获得了注意的焦点”);

}

  public void fousGained(FocusEvent e) //处理FocusListener中的方法

  }

  {

   gerMeg.setText(“对话框”+((Dialog)e.getComponent()).getTitle()+“获得了注意的焦点”);

   }

   public void focusLost(FocusEvent e) {}

 }

 class WinAdpt extends WindowAdapter

 {

  public void windowClosing(WindowEvent e) //处理关闭窗口事件

  {

   ((Frame)e.getWindow()).dispose();

System.exit(0);

}

}

编译并运行查看结果

五、注意事项

⒈认真填写实验报告

⒉遵守实验室各项制度，服从实验指导教师的安排

⒊按规定的时间完成实验

六、说明

⒈建议学时数6学时

实验八、多线程实验

一、实验目的  

⒈掌握多线程的实现方法

⒉学会利用多线程来显示动画

二、预习内容   

线程与进程的基础知识

三、实验设备与环境

装有JAVA语言工具软件 (JCreator )的微机若干

四、实验内容

⒈使用Runnable接口的方法实现多线程

编辑TestRunnable.java，保存在D:\myjava目录下。

import java.applet.*;

import java.awt.*;

public class TestRunnable extends Applet implements Runnable

{

 Label prompt1=new Lable(“the first thread”);

 Label prompt2=new Lable(“the second thread”);

 TextField threadFirst=new TextField(14);

 TextField threadSecond=new TextField(14);

Thread Thread1, Thread2;

int count1=0,count2=o0;

public void inin()

{

 add(prompt1);

 add(threadFirst);

 add(prompt2);

 add(threadSecond);

 }

public void start()

{

 thread1=new Thread(this, “FirstThread”);

 thread2=new Thread(this, “SecondThread”);

 thread1.start();

 thraed2.start();

 public void run()

 {

  String currentRunning;

  While(true)

  {

   try{

      Thread.sleep((int)(Math.random()*10000));

   }

   catch(Exception e) {}

   currentRunning=Thread.currebtTheard().getName();

   if(currentRunning.equals(“FirstTheard”))

   {

    count1++;

    threadFirst.setText(“the first thread”+count1+“use”);

    }

   else if(currentRunning.equals(“SecondThread”))

   {

    count2++;

    threadSecond.setText(“the second thread”+count2+“use”);

    }

  }

（1）       编译TestRunnable.java。

（2）       编辑TestRunnable.htm，要求与TestRunnable.class在同一目录下。

<applet code=TestRunnable.class height=300 width=400>

</applet>

（3）       运行TestRunnable.htm。

⒉ 实现简单动画

实现一个简单动画，效果为一个球由小到大，从屏幕左侧滚动到右侧。

编辑TestRunnable.java，设保存在D:\myjava目录下。

import java.applet.*;

import java.awt.*;

public class Mov extends Applet

{

 int x1=50,x2=5,y1=25,y2=5;

 public void paint(Graphics g)

 {

  int w=this.getWhidth();

  int h=this.get.height();

  if(x1>=w)

  {

   x1=50;

  }

  if(x2>h)

  {

   x2=5;

   }

  g.setColor(Color.BLUE);

  g.fillOval(x1,y1,x2,x2);

  g.drawOval(x1,y1,x2,x2);

  x1+=50;

  x2+=5;

  try{

  Thread.sleep(500);

   }

  catch(Exception e) {}

  repaint();

}

（1）       编译Mov.java

（2）       编辑Mov.htm，要求与Mov.class在同一目录下。

       <applet code=“Mov.class” height=300 width=400>

</applet>

（3）       运行Mov.htm。

五、注意事项

⒈认真填写实验报告

⒉遵守实验室各项制度，服从实验指导教师的安排

⒊按规定的时间完成实验

六、说明

⒈建议学时数2学时

实验九、输入输出流实验

一、实验目的  

⒈了解文件的概念和文件对象的创建方法

⒉了解FileInputStream和FileOutoutStream的基本概念

⒊学会创建文件输入输出流

⒋掌握使用文件输入输出流读写文件的方法

二、预习内容   

输入输出类的使用方法

三、实验设备与环境

装有JAVA语言工具软件 (JCreator )的微机若干

四、实验内容 

⒈编写程序读取文本文件内容

编辑TestFileDialog.java，设保存在D:\myjava目录下。

import java.io.*;

import java.awt.*;

import java.awt.event*;

public class TestFileDialog

{

 public static void main(String args[ ])

 {

  new FileFrame();

  }

}

class FileFrame extends Frame implements ActionListener

{

 TextArea ta;

 Button open,quit;

 FileDialog fd;

 FileFrane()

 {

  super(“获取显示文本文件”)；

  ta=new TextArea(10,45);

  open=new Button(“打开”)

  quit=new Button(“关闭”)

  open.addActionListener(this);

  quit.addActionListener(this);

  setLayout(new FlowLayout());

  add(ta);

  add(open);

  add(quit);

  show();

 }

 public void actionPerformed(ActionEvent e)

{

 if (e.getActionCommand()==“打开”)
  {

  fd=new FileDialog(this, “打开文件”,FileDialog.LOAD;)

  fd.setDirectory(“d:”);

  fd.show();

  try

  {

   File myfile=new File(fd.getDirectory(),fd.getFile());

   System.out.print(myfile);

   FileReader inB=new BufferedReaser(inFile);

   String fileCountent=“”,ste=“”;

   While((fileContent-inB.teadLine())!=null)

   {

  str=srt+fileContent+“\n”;

  ta.append(fileContent+“\n”);

}

    }

    catch(TOException ie)

    {

     System.out.println(ie.tostring());

     }

    }

    if (e.getActionCommand()==“关闭”)

    {

     dispose();

     System.exit(0);

    }

   }

}

（1）       编译并运行。

（2）       选择a.txt查看应用程序。

⒉ 读取图像文件

编辑ReadPic.java。设保存在D:myjava目录下。设该目录下已经存在一个run.gif文件（可以在此目录下放置一个本机已有的图像文件名字为run.gif。）

import java.io.*;

import ReadPic

{

 //*此程序将当前目录下的run.gif文件复制到copyrun.gif中

 ReadPic()

 {

 try{

    File f=new File(“run.gif”);

    File f1=new File(“copyrun.gif”);

    FileInputStream inFile=new FileInputStream(f);

    BufferedInputStream inB=new BufferedInputStream(f1);

    FileOutPutStream outFile=new FileOutputStream(f1);

    BufferedOutputStream putB=new BufferedOutputStream(outFile);

   

    Byte b[ ]=new byte[int f.length()];

    while(inB. read(b)!=-1)

    {

     outB. Write(b);

    }

    outB.flush();

    inB.close();

    outB.close();

   }

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

}

public static void main(Srting args[ ])

{

 new ReadPic();

}

}

（1）       编译并运行ReadPic..class。

（2）       打开copyrun.gif与run.gif进行对比。

⒊将内容写入文件

编辑UseStream1.java，设保存在D:\myjava目录下。

 import java.io.*;

class UseStream1

{

 UseSream1(string path)

 {

  try{

     Fole f=new File(path, “test1.txt”);

     //向文件test1.txt中写入数据

     FileWrite putFile=new FileWriter(f);

     BuffereWrite OutB=new BuffereWrite(OutFile);

     String s=“你们好，这是一个测试写入数据的文件。”；

     outB.write(s);

     //插入一行

     outB.newLine();

     outB.write“这是利用FileWrite与 BuffereWrite的例题。”

     //需要调用flush（）方法

     outB.flush();

     //写入完毕要关闭流

     outB.close();

     //从text.txt中读取数据

     FileReader inFile=new FileReader(f);

     BuffereReader inB=new BufferedRearder(inFile);

     /*inB中含有能够直接读取一行数据的方法raesLine()供我们使用，当然返回值null时，意味着读取结束*/

     String fileContent=“”,str=“”

while((fileContenr=inB.readLine())!=null)

{

 str=str+fileContent+“\n”;

}

System.out.println(str);

inB.close;

    }

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

   }

   public static main(String args[ ])

   {

    new UseStream1(“d:\\myjava”);

   }

}

编译并运行UseStream1.class。

五、注意事项

⒈认真填写实验报告

⒉遵守实验室各项制度，服从实验指导教师的安排

⒊按规定的时间完成实验

六、说明

⒈建议学时数4学时

实验十、数据库应用实验

一、实验目的  

⒈掌握Java应用程序连接数据库

⒉掌握Java小应用程序连接数据库

二、预习内容  

数据库表的应用

三、实验设备与环境

装有JAVA语言工具软件 (JCreator )的微机若干

四、实验内容 

⒈Java应用程序连接数据库

（1）   建立数据库，使用Access或SQL Server均可，建立数据表person。

（2）   建立数据源指向该数据库，数据源名为stu。

（3）   编辑Db.java，设保存在D:\myjava目录下。

import java.awt.*;

mport java.applet.*;

import java.awt.event.*;

import java.sq1.*

public class Db implements ActionListener

{

 static TextField t1,t2;

 public static void main(String args[ ])

 {

  Frame f=new Frame(“用户身份验证”);

  //定制窗口大小

  f.setSize(500,160);

  //窗口适配器，用于处理窗口关闭事件

  f.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e){

Syetem.exit(0)

}

});

t1=new TextField(10);

t2=new TextField(10);

Button b=new Button(“submit”);

    //按钮b的监听器为当前类的对象

    b.addActionListener(new Db());

  //布局设计

  f.setLayout(new GridLayout(5,7));

  for(int i=0;i<7;i++)

  {

   f.add(new Label());

  }

  f.add(new Labe1());

  f.add(new Label(“username:”));

  f.add(t1);

  f.add(new Label());

  f.add(new Label(passwors:));

  f.add(t2);

  f.add(new Label());

  for(int i=0;i<7;i++)

  {

   f.add(new Label());

  }

  f.add(new label());

  f.add(new label());

  f.add(new label());

  f.add(b);

  f.add(new label());

  f.add(new label());

  f.add(new label());

  for(int i=0;i<7;i++)

  {

   f.add(new Label());

  }

  f.setVisible(true);

}

public void actionPerformed(ActioneEvevt e)

{

 Srting username=t1.getText(); //取得用户名

   String.password=t2.getText(); //取得密码

   //从数据库中查找有无此用户名，并验证其密码

   Dbcom user=new Dbcon()

   User.test(username,passwora);

  }

}

//显示登陆信息正确与否窗口

class Dbcon extends Frame

{

 public Dbcon()

 {

  addWindowListener(new WindowAdapter() {

public void windowCloseing(WindowEvent e) {

dispose();

System.exit(0);

}

});

}

public void test(String username,String password)

{

 System.out.println(“Starting Dbcon…”);

 Dbcon mainframe=new Dbcon();

 mainFrame.setSize(400,200);

 mainframe.setTitle(“Dbcon”);

 ExecDb db=new ExecDb(“stu”);

 TextArea t=new TextArea();

 String str=“ ”

 try

 {

  ReaultSet rs=db.getRs(“select*from person wher name= “+username+”and password= ”password);

  if(rs!=null)

  {

   rs.last();

   int l=rs.getRow(); //取得满足条件的记录数

   //如果为0，证明无此记录，否则输出记录

   if(l==0)

   {

    t.append(“no result”);

   }

   else

   {

    rs.beforeFirst();

    while(rs.next())

    {

     t.append(“用户名为：”);

     str=rs.getString(“name”);

     t.append(str);

     t.append(“，密码为：”)

     str=rs.gerString(“password”);

     t.append(str);

    }

       }

}

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

db.close();

mainFrame.add(t);

mainframe.setVisible(true);

 }

}

//连接数据库，对数据库进行操作

class ExecDb

{

 Connection con;

 Statement st;

 ResultSet rs;

 ExecDb(string source)

 {

  try

  {

   Class.dorName(“sun.jabc.odbc.JdbcOdbcDriver”);

   con=DriverManager.getConnection(“jdbc:odbc:”+source);

   st=con.creatStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);

  }

  catch(Excepting e)

  {

   e.printStackTrace();

  }

}

//执行对记录的增、减、改时可以用到此方法

String exec(String sq1)

{

 try

 {

  st.executUpdate(sq1);

  return“success”;

 }

 catch(Exception ex)

 {

  ex.printStackTrace();

  return“error”;

 }

}

//执行查询

ResuleSet getRs(String sq1)

{

 try

 {

  rs=st.executeQuery(sq1);

  return rs;

 }

 catch(Excrption e)

 {

  e.printStackTrace();

  return null;

 }

}

void close()

{

 try

 {

  if(rs!=null) rs.close();

  if(st!=null) st.close();

if(con!=null) con.close();

 }

catch(Exception ex)

 {

  ex.printStackTrace();

 }

}

}

（4）   编译Db.java

（5）   运行Db.class，在username后的文本框中输入“李明”，在password后的文本框中输入密码，查看程序的结果。

（6）   当单击stbmit按钮时，将查找person表中有无此记录。

五、注意事项

⒈认真填写实验报告

⒉遵守实验室各项制度，服从实验指导教师的安排

⒊按规定的时间完成实验

六、说明

⒈建议学时数4学时