Java 程 序 设 计 实 验 报 告
实验一 JDK开发环境和结构化程序设计
实验学时：2 实验类型：综合性
一、实验目的
1．熟悉JDK开发环境。
2．熟悉UltraEdit/NotePad等编辑器编写、编译、运行Java程序。
3．掌握Java Application的程序结构和开发过程。
4．掌握Eclipse工具的使用。
5．结构化程序设计
二、实验内容
1．JDK开发环境
（1）J2sdk开发环境安装。假设JDK的安装路径为C:\JDK；
（2）设置环境变量PATH和CLASSPATH（如果在autoexec.bat中没有进行设置）。如 SET PATH=C:\JDK\BIN;%PATH%
SET CLASSPATH=.; %CLASSPATH%；d:\test_java (自己的工作目录)
2．UltraEdit/Notepad编辑器
练习使用Ultraedit/Notepad创建Java源程序的方法。
3．掌握Java Application程序开发过程
（1）编辑源程序，如下程序：
import java.io.*;
public class HelloWorld1{
public static void main(String arg[]){
System.out.println("Hello World!");
}
}
（2）保存文件，（注意大小写）。可将文件保存在“D:\test_java\”目录中，注意文件名为HelloWorld1.java。
（3）进入命令行（MS-DOS）方式，设定当前目录为“D:\test_java\”，运行Java编译器：
D:\test_java>javac HelloWorld1.java
（4）如果输出错误信息，则根据错误信息提示的错误所在行返回EditPlus编辑器进行修改。常见错误是类名与文件名不一致、当前目录中没有所需源程序、标点符号全角等。 如果没有输出任何信息或者出现“deprecation”警告，则认为编译成功，此时会在当前目录中生成HelloWorld1.class文件。
（5）利用Java解释器运行这个Java Application程序，并查看运行结果。
D:\test_java>java HelloWorld1
4.Eclipse开发环境的使用
练习使用Eclipse实现第3步中Java HelloWorld程序的方法。
5．编程采用冒泡法实现对数组元素由小到大排序。
冒泡法排序对相邻的两个元素进行比较，并把小的元素交换到前面。
public class hello {
public static void main(String[] args) {
int i,j,t;
int intArray[]={1,9,3,7,4,5};
for(i=0;i<intArray.length-1;i++)
for(j=i+1;j<intArray.length;j++)
if(intArray[i]>intArray[j]){
t=intArray[i];intArray[i]=intArray[j];intArray[j]=t; }
for(i=0;i<intArray.length;i++)
System.out.println(intArray[i]);
}
}
运行结果为：1
3
4
5
7
9
1．什么是Java虚拟机？它的作用是什么？
Java虚拟机是一个想象中的机器,在实际的计算机上通过软件模拟来实现。Java虚拟机有自己想象中的硬件,如处理器、堆栈、寄存器等,还具有相应的指令系统。
Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行,至少需要编译成不同的目标代码。而引入Java语言虚拟机后,Java语言在不同平台上运行时不需要重新编译。Java语言使用模式Java虚拟机屏蔽了与具体平台相关的信息,使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码(字节码),就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时,把字节码解释成具体平台上的机器指令执行。
2．Java Application程序与Java Applet程序的不同之处有那些？
（1）运行方式不同。Java Application是完整的程序，可以独立运行；Java Applet程序不能单独运行，它必须嵌入到用HTML语言编写的Web页面中，通过与Java兼容的浏览器来控制执行。（2）运行工具不同。Java Application程序被编译以后，用普通的Java解释器就可以使其边解释边执行，而Java Applet必须通过网络浏览器或者Applet观察器才能执
行。（3）程序结构不同。每个Java Application程序必定含有一个并且只有一个main方法,而Applet程序则没有含main方法的主类，这也正是Applet程序不能独立运行的原因。
(4）受到的限制不同。Java Application程序可以设计成能进行各种操作的程序，包括读／写文件的操作，但是 Java Applet 对站点的磁盘文件既不能进行读操作，也不能进行写 操作。
实验二 类与对象
实验学时：2 实验类型：综合性
一、实验目的
1．掌握类的声明。
2．掌握对象的创建。
3．掌握方法的定义和调用。
4．掌握构造函数的使用。
二、实验内容
1．编程创建一个Box类，在其中定义三个变量表示一个立方体的长、宽和高，再定义一个方法setDemo对这三个变量进行初始化，然后定义一个方法求立方体的体积。创建一个对象，求给定尺寸的立方体的体积。
public class Box {
private float i;
private float m;
private float n;
public void SetDemo(float i, float m, float n)
{
this.i=i;
this.m=m;
this.n=n;
}
public void Volum()
{
System.out.println(i*m*n);
}
public static void main(String[] args) {
Box a=new Box(8.5f,5.5f,6.0f);
a.SetDemo();
System.out.print("该长方体的体积为：");
a.Volum();
2．将上题的方法setDemo改用构造函数实现初始化。
public class Box {
private float i;
private float m;
private float n;
public Box(float i, float m, float n)
{
this.i=i;
this.m=m;
this.n=n;
}
public void Volum()
{
System.out.println(i*m*n);
}
public static void main(String[] args) {
Box a=new Box(8.5f,5.5f,6.0f);
System.out.print("该长方体的体积为：");
a.Volum();
三、思考题
1．一个方法或一个块内定义的变量是否可以在方法外或块外使用？这种变量称为什么？方法的形式参数是否可以在方法之外使用？
一个方法或一个块内定义的变量不可以在方法外或块外使用，这种变量称为局部变量。 方法的形式参数不可以在方法之外使用
2．为什么说构造函数是一种特殊的方法？特殊在哪里？构造函数什么时候执行？被谁调用？
因为它是在创建对象时就调用，当一个对象被创建时构造函数就执行了，它是java虚拟机自动调用的。
3．编程创建一个Point类，在其中定义两个变量表示一个点的坐标值，再定义构造函数初始化为坐标原点，然后定义一个方法实现点的移动，再定义一个方法打印当前点的坐标。并创建一个对象验证。
public class Point {
private float x;
private float y;
public Point(float x, float y){ this.x = x; this.y = y; } public void go(float i, float j){ System.out.println(+(i-x),+(j-y)); } public static void main(String[] args) { Point p = new Point(3f,6f);
p.go(6f, 9f);
}
}
实验三 继承与多态
实验学时：2 实验类型：综合性
一、实验目的
1．掌握类的继承方法。
2．掌握变量的继承和覆盖。
3．掌握方法的继承、重载和覆盖。
4．了解接口的实现方法。
二、实验内容
1．运行下面的程序，理解成员变量的继承与隐藏。 import java.io.*;
class sum_3{
int sum,num1,num2;
static int num3;
//定义构造函数初始化对象
sum_3(){
num1=0;
num2=0;
num3=0;
sum=0;
}
}
class sub_sum3 extends sum_3{
int sum,num1,num2; //隐藏父类sum_3中的实例变量 static int num3; //隐藏父类sum_3中的类变量 void sum(int i,int j,int k){
num1=i;
num2=j;
num3=k;
sum=num1+num2+num3;
}
}
public class computing{
public static void main (String arg[]){
sub_sum3 m1=new sub_sum3();
m1.sum(100,200,300);
System.out.println("sum="+m1.num1+"+"+m1.num2+"+"+m1.num3+"="+m1.sum); }
}
打印结果：sum=100+200+300=600
2．运行下面的程序，理解方法的继承。
class Sort3{
double max1,max2,max3;
Sort3(){
max1=-1;
max2=-1;
max3=-1;
}
void sort(){
double s;
if (max1<max2){
s=max1;max1=max2;max2=s;
}
if (max1<max3){
s=max1;max1=max3;max3=s;
}
if (max2<max3){
s=max2;max2=max3;max3=s;
}
}
}
class sub_Sort3 extends Sort3{
void subsort(double i,double j,double k){
max1=i;
max2=j;
max3=k;
sort(); //调用父类中的方法sort()
}
}
public class Class1{
public static void main (String args[]){
sub_Sort3 m1 = new sub_Sort3();
m1.subsort(100,200,300);
System.out.println("三个数从大到小为："+m1.max1+","+m1.max2+","+m1.max3); }
}
打印结果：三个数从大到小为：300.0,200.0,100.0
3．运行下面的程序，理解方法的重载。
class Sort2or3{
double max1,max2,max3;
Sort2or3(){
max1=-1;
max2=-1;
max3=-1;
}
void sort(double i,double j){
double s;
max1=i;
max2=j;
if(max1<max2){
s=max1;max1=max2;max2=s;
}
}
void sort(double i,double j,double k){
double s;
max1=i;
max2=j;
max3=k;
if (max1<max2){
s=max1;max1=max2;max2=s;
}
if (max1<max3){
s=max1;max1=max3;max3=s;
}
if (max2<max3){
s=max2;max2=max3;max3=s;
}
}
}
public class Class1{
public static void main (String args[]){
Sort2or3 m1 = new Sort2or3();
m1.sort(100,200);
System.out.println("两个数从大到小为："+m1.max1+","+m1.max2);
m1.sort(50,150,100);
System.out.println("三个数从大到小为："+m1.max1+","+m1.max2+","+m1.max3); }
}
打印结果：两个数从大到小为：200.0,100.0
三个数从大到小为：150.0,100.0,50.0
4．运行下面的程序，理解方法的覆盖。
class sort_Demo{
int i,j,k,swap;
sort_Demo(){
i=j=k=swap=0;
}
void sort(int t1,int t2[]){ //父类中的方法用来实现升序
//用选择法按升序排列
for(i=0;i<t1-1;i++){
k=i;
for(j=i+1;j<t1;j++)
if(t2[j]<t2[k]) k=j;
if (k!=i){
swap=t2[i];
t2[i]=t2[k];
t2[k]=swap;
}
}
}
}
class sub_sort_Demo extends sort_Demo{
void sort(int t1,int t2[]){ //子类中的方法实现降序 //用选择法实现降序排列
for(i=0;i<t1-1;i++){
k=i;
for(j=i+1;j<t1;j++)
if(t2[j]>t2[k]) k=j;
if (k!=i){
swap=t2[i];
t2[i]=t2[k];
t2[k]=swap;
}
}
}
}
public class Class1{
public static void main (String args[]){ int a[]={34,12,8,67,88,23,98,101,119,56}; sort_Demo m1=new sort_Demo();
sub_sort_Demo m2=new sub_sort_Demo();
System.out.println("排序前的数据为：");
for (int i=0;i<10;i++)
System.out.print(" "+a[i]);
//调用父类中的sotr()方法
m1.sort(a.length ,a);
System.out.println("\n按升序排列的数据为："); for (int i=0;i<10;i++)
System.out.print(" "+a[i]);
//调用子类中的sort()方法,该方法实现了对父类中方法的覆盖
m2.sort(a.length ,a);
System.out.println("\n按降序排列的数据为：");
for (int i=0;i<10;i++)
System.out.print(" "+a[i]);
}
}
打印结果：
排序前的数据为：
34 12 8 67 88 23 98 101 119 56
按升序排列的数据为：
8 12 23 34 56 67 88 98 101 119
按降序排列的数据为：
119 101 98 88 67 56 34 23 12 8
5．定义两个接口，其方法协议分别完成两个数的加法和减法操作，然后创建一个类实现这两个接口的方法。
public interface Arithmetic {
public int add(int a,int b);
public int sub(int a,int b);
}
public class IArithmetic implements Arithmetic{
public static void main(String[] args) {
IArithmetic i = new IArithmetic();
System.out.println(i.add(2, 3));
System.out.println(i.sub(2, 3));
}
public int add(int a, int b) {
return a+b;
}
public int sub(int a, int b) {
return a-b;
}
}
三、思考题
1．子类重新定义与父类方法的方法头完全相同的方法，这种情况称为什么？
方法的重写
2．同名的不同方法共存的情况称为什么？如何区分这些同名方法？
方法的重载，以参数类型，参数个数和返回值的不同加以区分。
3．创建一个类，声明一个无参数的构造函数，打印类已创建的信息；再重载一个具有String参数的构造函数，打印参数信息；并创建主类验证之。
public class Test { public Test(){ System.out.println("无参构造！"); } public Test(String temp){ System.out.println("字符串："+temp); } public static void main(String[] args) { Test t = new Test(); Test t1 = new Test("hello world!!"); } }
实验四 GUI标准组件及事件处理
实验学时：2 实验类型：综合性
一、实验目的
掌握常用GUI控制组件及其事件处理。
二、实验内容
1．编程包含一个标签和一个按钮，单击按钮时，标签的内容在“你好”和“再见”之间切换。
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class Jframe1 implements ActionListener{ int count=0;
JFrame j = new JFrame("first");
JLabel jl = new JLabel("你好！");
public void actionPerformed(ActionEvent arg0) { String temp = arg0.getActionCommand(); if("do".equals(temp)){
count++;
if(count==2){
jl.setText("你好！");
count=0;
}else{
jl.setText("再见！");
}
}
}
public Jframe1(){
JButton jb = new JButton("do");
jb.addActionListener(this);
j.add(jl);
j.add(jb);
j.setLayout(new FlowLayout());
j.setSize(200,150);
j.setLocation(300,300);
j.setVisible(true);
}
public static void main(String[] args) {
new Jframe1();
}
}
2．编程包含一个单选按钮组和一个普通按钮，单选按钮组中包含三个单选，文本说明分别为“普通”、“黑体”和“斜体”。选择文本标签为“普通”的单选按钮时，普通按钮中的文字为普通字体，选择文本标签为“黑体”的单选按钮时，普通按钮中的文字的字体为黑体，选择文本标签为“斜体”的单选按钮时，普通按钮中的文字的字体为斜体。 import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
public class TypeSet implements ActionListener {
JFrame jf=new JFrame("字体框设置");
JButton jb= new JButton("你好");
JRadioButton jrb1=new JRadioButton("普通");
JRadioButton jrb2=new JRadioButton("黑体");
JRadioButton jrb3=new JRadioButton("斜体");
ButtonGroup bg=new ButtonGroup();
JPanel jp=new JPanel();
public TypeSet(){
jb.setFont(new Font(jb.getText(),Font.PLAIN,30)); jf.setLayout(new FlowLayout());
} bg.add(jrb1); bg.add(jrb2); bg.add(jrb3); jrb1.addActionListener(this); jrb2.addActionListener(this); jrb3.addActionListener(this); jp.add(jrb1); jp.add(jrb2); jp.add(jrb3); jf.add(jp); jf.add(jb); jf.setSize(400,300); jf.setLocation(400,300); jf.setVisible(true); jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } public void actionPerformed(ActionEvent ae){ String comm = ae.getActionCommand(); if("普通".equals(comm)){ jb.setFont(new Font(jb.getText(),Font.PLAIN,30)); }else if("黑体".equals(comm)){ jb.setFont(new Font(jb.getText(),Font.BOLD,30)); }else if("斜体".equals(comm)){ jb.setFont(new Font(jb.getText(),Font.ITALIC,30)); } } public static void main(String[] args) { new TypeSet(); }
3．编程创建一个Frame，实现窗口的监听器接口。 import java.awt.FlowLayout;
import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.awt.event.WindowListener;
import javax.swing.JFrame;
public class Jframe2 {
JFrame j = new JFrame("secound");
public Jframe2(){
jf.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){ int jop = JOptionPane.showConfirmDialog( jf,"你确定要退出吗？","退出",
JOptionPane.OK_CANCEL_OPTION);
if(jop==JOptionPane.OK_OPTION){
System.exit(0);
}
}
j.setLayout(new FlowLayout());
j.setSize(200,150);
j.setLocation(300,300);
j.setVisible(true);
}
public static void main(String[] args) {
new Jframe2();
}
}
三、思考题
1．Java的事件处理机制是怎样的？
Java的事件处理采用基于层次模型的向上传递机制。这种模型中，当事件发生时，首先发送给产生事件的组件，如果该组件不对事件进行处理，则事件将自动传递给包含组件的容器。因此，事件将沿着组件间的包含关系层层向上传递。Jdk1.1以上的版本采用的是一种新的处理事件的方式，称为委托方式或者是监听器的处理方式，这种模型中，需要响应用户操作的组件事先已经注册一个或者是多个包含事件处理器的对象。
2．若一个数据只有两种取值可能，采用哪种组件表示比较合适？如果有二种到三种取值可能，采用哪种合适？如果取值的可能大于5个，采用哪种组件合适？
若一个数据只有两种取值可能，采用单选组件表示比较合适，如果有二种到三种取值可
能，采用下拉列表合适，如果取值的可能大于5个，采用复选组件合适。
3．事件监听器和事件适配器的关系是什么？
监听器是接口，而适配器是个实现类。 可以认为适配器仅仅是为了编程的方便而加入的。适配器实现了它所对应的监听器接口，“实现”的方式就是为每一个接口方法提供一个空的实现体，所以它没有任何实际作用。 但有时候一个接口有好多接口方法，编程时一个一个地实现，有用的逻辑代码和无用的仅仅为了语法需要的代码就杂糅在一起了，很不好，这是就应该从适配器继承而不是直接实现从监听器接口，从而仅仅需要实现你所感兴趣的事件响应方法就可了。
4．编程包含两个按钮和一个标签，将发生单击事件的按钮上的文本信息显示在标签中。
import java.awt.*;
import java.awt.event.*;
public class she
{ static Button b1=new Button("Button 1");
static Button b2=new Button("Button 2");
static Label who=new Label("文本信息显示区域");
public static void main(String args[])
{ Frame f1=new Frame("事件信息显示在标签中");
f1.setSize(300,100);
f1.setLayout(new FlowLayout());
f1.add(b1); f1.add(b2); f1.add(who);
b1.addActionListener(new B1());
b2.addActionListener(new B2());
f1.setVisible(true);
f1.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
}
static class B1 implements ActionListener
{ public void actionPerformed(ActionEvent e)
{ who.setText("Button 1");
}
}
static class B2 implements ActionListener
{ public void actionPerformed(ActionEvent e)
{ who.setText("Button 2");
}
}
}
程序运行结果：
点击Button1按钮时，在标签中显示Button1 点击Button2按钮时，标签中显示Button2