JAVA实验报告分析

更新时间：2024-04-30 23:32:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

学生实验报告

课程名称：

学生学号：

所属院部：

（理工类）

JAVA程序设计专业班级：xxxxxxxxxxxxxxxxxxxxxxx

xxxxxxxxx 学生姓名： xxxxxx

xxxxxxxxxxx 指导教师： xxxxxxxx

20 14 ——20 15 学年第 1 学期

实验报告书写要求

实验报告原则上要求学生手写，要求书写工整。若因课程特点需打印的，要遵照以下字体、字号、间距等的具体要求。纸张一律采用A4的纸张。

实验报告书写说明

实验报告中一至四项内容为必填项，包括实验目的和要求；实验仪器和设备；实验内容与过程；实验结果与分析。各院部可根据学科特点和实验具体要求增加项目。

填写注意事项

（1）细致观察，及时、准确、如实记录。（2）准确说明，层次清晰。

（3）尽量采用专用术语来说明事物。

（4）外文、符号、公式要准确，应使用统一规定的名词和符号。（5）应独立完成实验报告的书写，严禁抄袭、复印，一经发现，以零分论处。

实验报告批改说明

实验报告的批改要及时、认真、仔细，一律用红色笔批改。实验报告的批改成绩采用百分制，具体评分标准由各院部自行制定。

实验报告装订要求

实验批改完毕后，任课老师将每门课程的每个实验项目的实验报告以自然班为单位、按学号升序排列，装订成册，并附上一份该门课程的实验大纲。

实验项目名称：JAVA编程基础实验学时： 4 同组学生姓名： ———— 实验地点： 1318 实验日期： 2014.9.25 实验成绩：批改教师： xxxxx 批改时间：

一、实验目的和要求

（1）熟练掌握JDK1.6及MyEclipse8.5编写调试Java应用程序及Java小程序的方

法；

（2）熟练掌握Java应用程序的结构；

（3）了解Java语言的特点，基本语句、运算符及表达式的使用方法；（4）熟练掌握常见数据类型的使用；

（5）熟练掌握if-else、switch、while、do-while、for、continue、break、return

语句的使用方法；理解和掌握重载方法；（6）熟练掌握数组和字符串的使用；

（7）调试程序要记录调试过程中出现的问题及解决办法；

（8）编写程序要规范、正确，上机调试过程和结果要有记录，不断积累编程及调试

经验；

（9）做完实验后给出本实验的实验报告。

二、实验仪器和设备

奔腾以上计算机，Windows 操作系统，装有JDK1.6和MyEclipse8.5软件。

三、实验过程

（1）分别使用JDK命令行和MyEclipse编译运行Java应用程序；适当添加注释信息，通过javadoc生成注释文档；为主方法传递参数“Hello！”字符串，并输出，记录操作过程。

public class Hello {

public static void main(String args[]) {

System.out.println(\ } }

(2)教材P11页程序调试，改写程序；

(3)编写一个重载方法的程序，调试通过。

要求：

（1）编译调试程序之前应配置好环境变量；

（2）要分别掌握用JDK命令行和MyEclipse集成开发环境调试Java程序；（3）注意Java重载程序：构造方法和成员方法的区别。

程序清单：

（建议程序中适当添加注释信息，增强可读性；较长程序分栏书写，保证报告排版整洁美观。）

（实验一程序清单续1）

(2)教材P11页程序调试，改写程序；

package pack;

import mypackage.Point;

public class Line {

public static Point start; public static Point end;

public Line(Point start,Point end){ this.start=start; this.end=end; }

public String toString() {

return

this.getClass().getName()+\; }

public double length() {

int a=start.x-end.x,b=start.y-end.y; return Math.sqrt(a*a+b*b); }

public static void main(String args[]) { Line l=new Line(start, end); Point start=new Point(100,100); Point end=new Point(100,200);

System.out.println(new Line(start,end).toString()); System.out.println(l.length()); } }

（实验一程序清单续2）

(3)编写一个重载方法的程序，调试通过。 public class dcc {

public void der(){ System.out.println('z');} public int der(int c){ return c;}

public String der(int i,char c){ return c + \

public static void main(String[] args){ dcc y = new dcc();

}

y.der();

System.out.println(y.der(4,'z')); System.out.println(y.der(20)); }

四、实验结果与分析

(1)分别使用JDK命令行和MyEclipse编译运行Java应用程序；适当添加注释信息，通过javadoc生成注释文档；为主方法传递参数“Hello！”字符串，并输出，记录操作过程。运行结果：Hello！

(2)教材P11页程序调试，改写程序；

调试结果：pack.Line(Point(100,100),Point(100,200))

程序改写后的调试结果：pack.Line(Point(100,100),Point(100,200)) 100.0

(3)编写一个重载方法的程序，调试通过。运行结果： z

z=4 20

实验项目名称：面向对象编程实验学时： 8 同组学生姓名： ———— 实验地点：实验日期： 2014-10-23 实验成绩：批改教师： xxxx 批改时间：

一、实验目的和要求

（1）熟练掌握Java语言类定义的基本语法；（2）熟练掌握类成员的访问控制，对象建立的方法；（3）熟练掌握类构造方法、成员方法的定义和重载；（4）熟练掌握类继承、多态和抽象性；（5）熟练掌握接口的定义和实现方法；（6）掌握基本的异常处理方法；

（7）调试程序要记录调试过程中出现的问题及解决办法；

（8）编写程序要规范、正确，上机调试过程和结果要有记录，不断积累编程及调试经验；

（9）做完实验后给出本实验的实验报告。

二、实验仪器和设备

奔腾以上计算机，Windows 操作系统，装有JDK1.6和MyEclipse8.5软件。

三、实验过程

（1）设计复数类，成员变量包括实部和虚部，成员方法包括实现复数加法、减法、比较、字符串描述、比较是否相等等操作。

（2）设计圆柱体类和圆椎体类，继承圆类Circle并实现Volume接口，计算表面积和体积。

（3）设计三角形类，继承图形抽象类，计算三角形面积和周长。

（4）包的建立与使用：设计计算器类Calculator，计算加、减、乘、除和立方体体积，并且打包为mypackage。观察源文件目录下是否生成了mypackage文件夹，在该文件夹中是否有Calculate.class文件。编辑PackageDemo.java，保存在Calculator.java同一目录下，引用计算器类的各方法显示计算结果。

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

提示：对所有雇员类型都使用

earnings()方法，但每个人挣的工资按他所属的雇员

类计算，所有雇员类都是从超类Employee派出生的。在超类中声明earnings()为抽象方法，并且对于每个子类都提供恰当的earnings()的实现方法。为了计算雇员的工资，程序仅仅使用雇员对象的一个超类引用并调用earnings()方法。在一个实际的工资系

统中，各种Employee对象的引用可以通过一个Employee引用数组来实现。程序依次使用数组的每个元素（Employee引用）调用每个对象的earnings()方法。

Employee类定义如下： abstract class Employee {

private String firstName; private String lastName;

public Employee(String first,String last) {

firstName=first; lastName=last; }

public String getEmployeeName() {

return firstName; }

public String getLastName() {

return lastName; }

public String toString() {

return firstName+lastName; }

public abstract String earnings(); }

（6）异常的捕获：计算两数相除并输出结果。使用三个catch子句，分别捕捉输入输出异常、除数为0的异常和参数输入有误异常。 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(\商为：\ }

//捕获与I/O有关的异常（空白处补全捕获语句）

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

//捕获除数为0的异常

} }

编译并运行，当产生输入输出异常时显示异常信息；当输入除数为0时，出现算术异常，提示除数为0，并要求重新输入；当输入的不是整数时，如将30输成了3o，出现数值格式异常，提示输入整数。

（8）编写程序包含自定义异常MyException，当100被13和4除时抛出该异常，其余除数显示商值。

要求：

（1）注意选用适当的类成员修饰符（private、protected、public等），比较它们的使

用情况；

（2）养成良好的编程习惯，严格按照命名规则为包、类及类成员命名，将每个程序打包，

包的命名方式如two.num1表示实验二的第一题；

（3）学会使用MyEclipse的各种调试方法；

（4）学会查阅Java API文档，如查找异常类的使用方法。

程序清单：

（建议程序中适当添加注释信息，增强可读性；较长程序可分栏书写，保证报告排版整洁美观。）

（1）设计复数类，成员变量包括实部和虚部，成员方法包括实现复数加法、减法、比较、字符串描述、比较是否相等等操作。 public class Complex {

private double real,imag;

public Complex(double real,double imag) { this.real=real; this.imag=imag; }

public Complex(){ this(0.0,0.0); }

public Complex(Complex c){ this.real=c.real; this.imag=c.imag; }

//除基本工资外还根据销售额发放浮动工资

final class CommissionWorker extends Employee{ private double salary; private double fsalary;

public CommissionWorker(String first,String last,double s,double f){

super(first,last); setSalary(s); setFsalary(f); }

public void setFsalary(double f){

fsalary=(f>0?f:0); }

public void setSalary(double s){

salary=s; }

public String earnings(){

String salary1 = String.valueOf(salary+fsalary); return salary1; }

public String toString(){

return \ } }

HourlyWorker类

package ss1;

//根据工作时间长短发放工资

final class HourlyWorker extends Employee{

private double wage; private double hours;

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

super(first,last); setWage(w); setHours(h);

}

public void setWage(double w) {

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

public void setHours(double h) {

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

public String earnings() {

String salary1 = String.valueOf(wage*hours); return salary1; }

public String toString() {

return \—— \ }}

PieceWorker类

package ss1;

//按其生产的产品数发放工资

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) {

wagePiece=(w>0?w:0); }

public void setQuantity(int q){

quantity=q; }

public String earnings() {

String salary1 = String.valueOf(quantity*wagePiece); return salary1; }

public String toString() {

return \—— \ }

}

Test类

package ss1;

class Test{

public static void main(String args[ ]) { //使用超类声明ref Employee ref; String out=\ //分别定义各子类

Boss b=new Boss(\

CommissionWorker c=new CommissionWorker(\ PieceWorker p=new PieceWorker(\ HourlyWorker h=new HourlyWorker(\ //使用子类分别实例化 ref=b;

out+=ref.toString()+\父类调用earnings方法得\子类调用earnings方法得：\ ref=c;

out+=ref.toString()+\父类调用earnings方法得\子类调用earnings方法得：\ ref=p;

out+=ref.toString()+\父类调用earnings方法得\子类调用earnings方法得：\ ref=h;

out+=ref.toString()+\父类调用earnings方法得\子类调用earnings方法得：\ System.out.print(out); }

：：：： }

（6）异常的捕获

package ss;

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(\商为：\ }

//捕获异常

catch(IOException e){ //捕获I/O异常

System.out.println(\有关的异常\ }

//捕获数值转化时的异常，如不能将字符转化成数值 catch(NumberFormatException e){

System.out.println(\数值转化有关的异常\ }

//捕获除数为0的异常 catch(Exception e){

System.out.println(\除数为0的异常\ } } }

（8）编写程序包含自定义异常MyException，当100被13和4除时抛出该异常，其余除数显示商值。

import java.io.*;

class MyException extends Exception{ MyException(String msg) { super(msg); } }

public class DoubleDivideA {

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

BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); System.out.print(\请输入实数除法运算的被除数：\ String str = in.readLine();

double a = Double.parseDouble(str); System.out.print(\请输入除数：\ str = in.readLine();

double b = Double.parseDouble(str);

System.out.println(\商结果：\ }

catch (ArithmeticException e1) {

System.out.println(\商结果：Infinity\

System.out.println(\商结果：NaN\ }

catch (NumberFormatException e2) {

System.out.println(\异常：字符串不能转换成整数！\ }

catch (IOException e3) { System.out.println(\异常：IO异常\ }

finally {

System.out.println(\程序结束。\ } }

static double division(double a, double b) throws MyException {

if (a==100&&(b==4||b==13))

throw new MyException (\不符规范\

else

return (a/b); } }

四、实验结果与分析

（1）调试结果

调试结果：(2.0+3.5i)+(9.0+1.7i)=(11.0+5.2i)

(2.0+3.5i)-(9.0+1.7i)=(-7.0+1.8i)

b:(9.0+1.7i),c:(9.0+1.7i),b==c?true,b.equals(c)?true b:(9.0+1.7i),c:(9.0+1.7i),b==c?false,b.equals(c)?true

（3）设计三角形类，继承图形抽象类，计算三角形面积和周长。调试结果：面积是100.0

周长是48.0 高10.0 底20.0

是否继续Y/N? y

输入第一个数: 23

输入计算符号:+ - * / +

输入第二个数: 23

23+23=46 是否继续Y/N? n

程序退出

（5）结果：

Boss —— HohnSmith:

父类调用earnings方法得：800.0 子类调用earnings方法得：800.0 CommissionWorkerSueHones: 父类调用earnings方法得：403.0 子类调用earnings方法得：403.0 pieceWoeker —— BobLeis: 父类调用earnings方法得：500.0 子类调用earnings方法得：500.0 hourlyWorker —— Karenprice: 父类调用earnings方法得：550.0 子类调用earnings方法得：550.0

分析：Employee的每个子类都声明为final，因为不需要再继承它们生成子类。在主测试类Test中测试各类雇员工资计算结果。（6）结果： 1.正常值结果：请输入除数：1 请输入被除数：2 商为：2

2.除数为0的结果：

请输入除数：0 请输入被除数：1 除数为0的异常

3.数值异常的结果：请输入除数：2.1 数值转化有关的异常

分析：用三个catch语句，分别捕获三种异常情况 IOException e 定义IO的异常

NumberFormatException e 定义数值转化有关的异常 Exception e 定义除数为0的异常（8）编写程序包含自定义异常MyException，当100被13和4除时抛出该异常，其余除数显示商值。

调试结果：请输入实数除法运算的被除数：100

请输入除数：4 程序结束。

Exception in thread \cc.MyException: 不符规范

at cc.DoubleDivideA.division(DoubleDivideA.java:45) at cc.DoubleDivideA.main(DoubleDivideA.java:24) 请输入实数除法运算的被除数：100

请输入除数：13 程序结束。

Exception in thread \cc.MyException: 不符规范

at cc.DoubleDivideA.division(DoubleDivideA.java:45) at cc.DoubleDivideA.main(DoubleDivideA.java:24) 请输入实数除法运算的被除数：100

请输入除数：2 商结果：50.0 程序结束。分析：

在实验中用三个catch语句，分别捕获三种异常情况IOException e 定义IO的异常NumberFormatException e 定义数值转化有关的异常Exception e 定义除数为0的异常

实验项目名称：图形用户界面实验学时： 7 同组学生姓名： ———— 实验地点：实验日期：实验成绩：批改教师： xxxxx 批改时间：

一、实验目的和要求

（1）掌握Swing组件的使用方法；

（2）熟练掌握Swing中常用布局管理器的使用方法；（3）掌握用户界面动作与事件的处理程序的编写方法；（4）熟练掌握构造用户界面的方法和常见界面元素的使用；（5）熟练掌握Java绘图的主要方法。

（6）了解线程的基本概念和多线程程序设计的基本方法；（7）调试程序要记录调试过程中出现的问题及解决办法；

（8）编写程序要规范、正确，上机调试过程和结果要有记录，不断积累编程及调试

经验；

（9）做完实验后给出本实验的实验报告。

二、实验仪器和设备

奔腾以上计算机，Windows 操作系统，装有JDK1.6和MyEclipse8.5软件。

三、实验过程

1. 计算器设计

2. 整数进制转换

将一个十进制整数分别转换成二进制、八进制和十六进制整数。

3. 模拟裁判评分。

设计如图所示图形界面，显示n个裁判的评分，根据制定规则计算出最后得分。要求：图形界面采用表格显示裁判评分，随裁判人数变化而变化；指定分数范围，若超出，则异常处理；

得分规则有指定接口约定，由多个接口对象给出多种得分规则，如求平均数值，或去掉一个最高分和一个最低分后，再求平均值。

4. 编译运行下例，然后修改程序，当使用鼠标单击后在另一位置重新绘制月亮。【例】在Applet中画月亮。 import java.awt.*;

import java.applet.Applet;

public class MoonApplet extends Applet {

public void paint(Graphics g) //在Applet上绘图 {

g.setColor(Color.red);

g.drawString(\

int x=0,y=0; //圆外切矩形左上角坐标 x = this.getWidth() /4; y = this.getHeight() /4;

int diameter = Math.min(this.getWidth()/2, this.getHeight()/2); //圆的直径

g.setColor(Color.yellow);

g.fillOval(x,y,diameter,diameter); //画圆

g.setColor(this.getBackground()); //设置为背景色 g.fillOval(x-20,y-20,diameter,diameter); //画圆 } }

5.根据阿基米德螺线的极坐标方程：r=aθ画出相应图形。

要求：

(1)注意选用适当的布局管理器设计图形用户界面，比较它们的布局情况；

(2)养成良好的编程习惯，严格按照命名规则为包、类及类成员命名，将每个程序打包，包的命名方式如three.num1表示实验三的第一题； (3)学会使用MyEclipse的各种调试方法；

(4)学会查阅Java API文档，如查找事件类的处理里方法。

程序清单：

（建议程序中适当添加注释信息，增强可读性；较长程序可分栏书写，保证报告排版整洁美观。）

1. 计算器设计

import java.awt.*; import java.awt.event.*;

import javax.swing.*;

public class Calculator extends JFrame implements ActionListener{ private JTextField text; private char op;

private float value; private boolean first; public Calculator(){ super(\ this.setSize(280,210); this.setLocation(300,240);

this.display(); this.setDefaultCloseOperation(EXIT_ON_CLOSE); this.setVisible(true); op='+'; value=0.0f; first=true; }

private void display(){

text = new JTextField(\

text.setHorizontalAlignment(JTextField.RIGHT); text.setEditable(false); this.getContentPane().add(text,\

JPanel panel = new JPanel(new GridLayout(5,4,5,5)); this.getContentPane().add(panel); String

str[]={\1\

JButton buttons[] = new JButton[str.length]; for (int i=0; i

buttons[i].addActionListener(this); } }

public void actionPerformed(ActionEvent e){

String current = e.getActionCommand(); if (current==\

text.setText(\ value = 0.0f; first = true; return; }

if (current==\

String

str=text.getText().substring(0,text.getText().length()-1); text.setText(str); if (str==\

text.setText(\ first = true; } return; } if

(current.charAt(0)>='0' &&

current.charAt(0)<='9' ||

current==\ {

if (first){

text.setText(\ first = false; }

text.setText(text.getText()+current); } else {

System.out.print(\ switch (op){

case '+': value += Float.parseFloat(text.getText());break; case '-': value -= Float.parseFloat(text.getText());break; case '*': value *= Float.parseFloat(text.getText());break; case '/': value /= Float.parseFloat(text.getText());break; }

System.out.println(\ text.setText(\

op = current.charAt(0); first = true; } }

public static void main(String arg[]){ new Calculator(); } }

（实验二程序清单续1）

2. 整数进制转换

import java.awt.*; import javax.swing.*;

import javax.swing.event.*;

public class BinaryJFrame extends JFrame implements CaretListener{ private JTextField texts[]; public BinaryJFrame(){

super(\十进制整数转换\);

this.setBounds(300,240,440,140); this.setResizable(false);

this.setBackground(Color.lightGray);

this.setDefaultCloseOperation(EXIT_ON_CLOSE); this.getContentPane().setLayout(new FlowLayout(FlowLayout.RIGHT));

String labelstr[]={\十进制\,\二进制\,\八进制\,\十六进制\}; texts = new JTextField[labelstr.length]; for (int i=0; i

this.getContentPane().add(new JLabel(labelstr[i])); texts[i] = new JTextField(32); texts[i].setEditable(false);

this.getContentPane().add(texts[i]); }

texts[0].setEditable(true); texts[0].setText(\);

texts[0].addCaretListener(this); this.caretUpdate(null); this.setVisible(true); }

public void caretUpdate(CaretEvent e){ try{

int i = Integer.parseInt(texts[0].getText()); texts[1].setText(Integer.toBinaryString(i)); texts[2].setText(Integer.toOctalString(i)); texts[3].setText(Integer.toHexString(i)); }

catch(NumberFormatException nfe){

JOptionPane.showMessageDialog(this,\+texts[0].getText()+\不能转换，请重新输入!\); }

finally{} }

public static void main(String arg[]){ new BinaryJFrame(); }

}

（实验二程序清单续2）

3. 模拟裁判评分。

import java.awt.*; import java.awt.event.*; import javax.swing.*;

public class ScoreJFrame extends JFrame implements ActionListener{ private JTextField texts[],text_score; private JButton button; private Average av; public ScoreJFrame(int rows, int columns, Average av){ super(\模拟裁判评分\

this.setBounds(300,240,400,150); this.setBackground(Color.lightGray);

this.setDefaultCloseOperation(EXIT_ON_CLOSE);

JPanel panel1 = new JPanel(new GridLayout(rows, columns)); this.getContentPane().add(panel1); texts=new JTextField[rows*columns]; for (int i=0; i

texts[i].setHorizontalAlignment(JTextField.CENTER); panel1.add(texts[i]); }

JPanel panel2 = new JPanel(new FlowLayout(FlowLayout.RIGHT)); this.getContentPane().add(panel2, \ button=new JButton(\平均分\ panel2.add(button);

button.addActionListener(this); text_score = new JTextField(\ text_score.setEditable(false);

text_score.setHorizontalAlignment(JTextField.CENTER); panel2.add(text_score); this.setVisible(true); this.av=av; }

public void actionPerformed(ActionEvent e){ double table[]=new double[texts.length]; for (int i=0; i

table[i] = Double.parseDouble(texts[i].getText()); if(table[i]>10)

throw new Exception(\ }

catch(NumberFormatException nfe){

JOptionPane.showMessageDialog(this, texts[i].getText()+\字符串不能转换符点数，请重新输入。\ }

catch(Exception ex) {

if(ex.getMessage()==\

JOptionPane.showMessageDialog(this,table[i]+\分数范围超出，请重新输入！\ }

text_score.setText(String.format(\ }

public static void main(String arg[]){ new ScoreJFrame(2,5, new AverageExceptMaxMin()); } }

class AverageExceptMaxMin implements Average{ public double average(double table[]){ if (table!=null && table.length>2){

double sum=table[0], max=table[0], min=table[0]; for (int i=1; imax) max = table[i]; if (table[i]

return (sum-max-min)/(table.length-2); }

return 0.0; } }

（实验二程序清单续3）

4. 编译运行下例，然后修改程序，当使用鼠标单击后在另一位置重新绘制月亮。

import java.awt.*;

import java.awt.event.*;

class Mycanvas extends Canvas implements MouseListener{

int x=0,y=0; Mycanvas(){

setSize(400,400);

setBackground(Color.lightGray); addMouseListener(this); }

public void paint(Graphics g) { g.setColor(Color.red);

g.drawString(\

int diameter = Math.min(this.getWidth()/2, this.getHeight()/2); g.setColor(Color.yellow);

g.fillOval(x,y,diameter,diameter); g.setColor(this.getBackground()); g.fillOval(x-20,y-20,diameter,diameter); }

public void mousePressed(MouseEvent e){ x=e.getX(); y=e.getY(); repaint(); }

public void mouseReleased(MouseEvent e){} public void mouseEntered(MouseEvent e){} public void mouseExited(MouseEvent e){} public void mouseClicked(MouseEvent e){ x=e.getX(); y=e.getY(); repaint(); }

public void update(Graphics g){ paint(g); super.update(g); } }

public class MoonJFrame{

public static void main(String args[]){ Frame f=new Frame();

f.setBounds(500,300,400,400); f.setVisible(true);

f.add(new Mycanvas(),\ f.validate(); } }

（实验二程序清单续4）

5.根据阿基米德螺线的极坐标方程：r=aθ画出相应图形。

import java.awt.*; import java.awt.event.*; import javax.swing.*;

public class ArchimedesJFrame extends JFrame implements ActionListener{ private ArchimedesCanvas archimedes; private JRadioButton radiob_color[]; public ArchimedesJFrame(){

super(\阿基米德螺线\);

Dimension dim=getToolkit().getScreenSize();

this.setBounds(dim.width/4,dim.height/4,dim.width/2,dim.height/2); this.setDefaultCloseOperation(EXIT_ON_CLOSE); JToolBar toolbar=new JToolBar(); this.getCntentPane().add(toolbar,\); String colorstr[]={\红\,\绿\,\蓝\};

ButtonGroup bgroup_color=new ButtonGroup(); radiob_color=new JRadioButton[colorstr.length]; for(int i=0;i

radiob_color[i]=new JRadioButton(colorstr[i]);

radiob_color[i].addActionListener(this);

bgroup_color.add(radiob_color[i]);

toolbar.add(radiob_color[i]); }

radiob_color[0].setSelected(true);

archimedes=new ArchimedesCanvas(Color.red); this.getContentPane().add(archimedes,\); this.setVisible(true); }

public void actionPerformed(ActionEvent e){ Color c=null;

if(e.getSource()==radiob_color[0])

c=new Color(255,0,0);

if(e.getSource()==radiob_color[1]){

c=new Color(0,255,0); }

if(e.getSource()==radiob_color[2])

c=new Color(0,0,255);

archimedes.setColor(c);

archimedes.repaint(); }

public static void main(String[] args){

new ArchimedesJFrame(); } }

class ArchimedesCanvas extends Canvas implements ComponentListener,FocusListener,ActionListener{

private Color color;

private Timer mTimer;

public ArchimedesCanvas(Color color){

this.setBackground(Color.WHITE);

this.setColor(color);

this.addComponentListener(this); this.addFocusListener(this); }

public void setColor(Color color){ this.color = color; }

public void paint(Graphics g){

int x0 = this.getWidth()/2; int y0 = this.getHeight()/2;

g.setColor(color); g.drawLine(x0,0,x0,y0*2); g.drawLine(0,y0,x0*2,y0); for (int i=0; i<4000; i++){ double angle = i*Math.PI/512; double radius = 0.5*angle;

int x=(int)Math.round(radius*angle*Math.cos(angle)); int y=(int)Math.round(radius*angle*Math.sin(angle)); mTimer=new Timer(1000,this); mTimer.start();

g.drawOval(x0+x,y0+y,1,1); } }

public void componentMoved(ComponentEvent e) {}

public void componentHidden(ComponentEvent e) {} public void componentResized(ComponentEvent e) {

this.repaint(); }

public void componentShown(ComponentEvent e) {} public void focusGained(FocusEvent arg0){

mTimer.stop(); }

public void focusLost(FocusEvent arg0){

mTimer.restart(); }

public void actionPerformed(FocusEvent arg0){} public void actionPerformed(ActionEvent e) {} }

四、实验结果与分析

（分析每题采用的布局管理器、事件处理类和主要功能实现方法。）结果：

（1）输出结果：