中 南 民 族 大 学
实 验 报 告
2010—2011第二学期
课程名称： Java程序设计 院 系： 计算机科学学院 年 级： 2009 专 业： 计算机科学与技术(1)大班 学 号： 09061060 姓 名： 李亚巧 指导教师： 陈建国 陶双喜
20xx年6月
实验日期：20xx年5月9日
实验一 简单Java Application编程
1.实验类型：设计型
2.实验目的
（1）了解Java命令行编程环境JDK的组成；
（2）熟悉Java命令行编程环境JDK的配置和使用；
（3）掌握Application程序的输入和输出；
（4）掌握Application程序的结构和命名；
（5）熟悉Textpad等编辑器的使用。
3.实验内容
（1）熟悉javac、java等命令的使用，熟悉使用Java编辑器。
（2）编写一个Java Application程序，接受用户从键盘输入的10个整数，比较并输出其中
的最大值和最小值。要求程序能对非法数据进行处理。
（3）编写一个Java Application程序，从键盘读取年份，输出该年份是否为闰年。要求程序
能对非法数据进行处理。
4. 实验要求
（1）程序的数据从键盘读取；
（2）主类名自定，注意其与文件名的关系；
（3）当输入的数据格式不对，提示用户输入一个格式正确的数据；
（4）可用图形用户界面或字符界面。
5. Java源代码
// Java Application程序1
import java.io. * ;
public class daxiao{
public static void main(String arg[]){ int N[]=new int[10]; int max,min,i; String s;
char c=' ';
do{
System.out.println("请输入十个整型数：");
for(i=0;i<10;i++){ try{ BufferedReader br=
new BufferedReader(new InputStreamReader(System.in)); s=br.readLine(); N[i]=Integer.parseInt(s); }catch(Exception e ){ i--; System.out.println("输入错误");
System.out.println("重新输入:"); continue ; }
} System.out.println("最小数min="+min); } max=min=N[0]; for(i=1;i<10;i++){ if(max<N[i]){ max=N[i];} } System.out.println("最大数max="+max); for(i=1;i<10;i++){ if(min>N[i]){ min=N[i];}
System.out.println("要继续输入吗？");
System.out.println("请输入Y/y或N/n");
try{
c=(char)System.in.read();
System.in.skip(2);
}catch(Exception e ){}
}while(c=='Y'||c=='y');
}
}
// Java Application程序2
import java.io. * ;
public class Year{
public static void main(String args[]){
int y=0;
int n=0;
String s;
char c='y';
do{
System.out.print("请输入年数:");
try{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); s=br.readLine();
y=Integer.parseInt(s);
}catch(Exception e ){
System.out.println("输入错误");
System.out.println("重新输入:");
continue ; }
if(y<0){
System.out.println("输入错误"); }
else{
if(y%4==0&&y%100==0||y%400==0){
System.out.print("年份："+y);
System.out.println("\t,是闰年");}
else{
if(y>=0){ System.out.print("年份："+y);
System.out.println("\t,不是闰年");}
}
}
System.out.println("要继续输入吗？");
System.out.println("请输入Y/y或N/n");
try{
c=(char)System.in.read();
System.in.skip(2);
}catch(Exception e ){}
}while(c=='Y'||c=='y');
}
}
6. 实验原理
1、java中变量必须先声明后使用，声明变量包括指明变量的数据类型和变量的名称，必要时还可以指定变量的初始数值。
2、java的类型转换有较严格的规定：凡是将变量从占用内存较少的短数据类型转换成占用内存
较多的长数据类型时，可以不做显示的类型转换声明；而将变量从较长的数据类型转换成较短的数据类型时，则必须做强制类型转换。
3、java的跳转语句有三个：continue语句、break语句和return语句，java语言不支持无条件跳转的goto语句。Continue语句必须用于循环结构中，它有两种使用形式。一种是不带标号的continue语句，它的作用是终止当前这一轮的循环，跳过本轮剩余的语句，直接进入当前循环的下一轮。另一种是带标号的continue语句，其格式是：continue标号名；这个标号应定义在程序中外层循环语句的前面，用来标志这个循环结构。
7. 实验结果分析及心得体会
（1）实验结果分析
一、求整数最大最小数：
1、根据提示输入十个整数，当用户输入非法数据时，catch语句提示错误并重新输入，由for循环找出最大最小值。
二、瑞年：
1、根据提示输入年数，当用户输入非法数据（非法字符和年份为负数）时，提示错误并重新输入，由y%4==0&&y%100==0||y%400==0求的瑞年。
（2）心得体会
1、掌握了Java命令行编程环境JDK的组成；Textpad等编译器的使用； 2、掌握Application程序的输入和输出及数据类型之间的转换； 3、掌握Application程序的结构和命名； 4、非法数据进行处理时，非法数据项应考虑完全； 5、应设置用户提示语，方便用户输入使用； 6、数据变量要初始化。 8.成绩评定
评语：
成绩：
教师签名：
日 期： 年 月 日
实验日期：20xx年5月23日
实验二 Java类的定义和对象的创建
1. 实验类型：设计型
2. 实验目的
（1）进一步熟悉Java命令行编程环境JDK、Textpad编辑器的使用；
（2）熟悉类与对象的概念及其关系；
（3）掌握Java类的定义、对象的创建；
（4）掌握成员变量的访问、成员方法的调用；
（5）掌握封装的概念及意义。
3. 实验任务
（1）编写一个复数类ComplexNumber，其中包括实例变量real、image，方法如下：
1)构造方法 ComplexNumber（double a,double b）
2) ComplexNumber add(ComplexNumber x)
//当前复数对象与另一复数对象进行复数的加法运算，返回一新的复数对象
3) ComplexNumber sub(ComplexNumber x)
//当前复数对象与另一复数对象进行复数的减法运算，返回一新的复数对象
4)double getReal () //获取复数对象的实部
5)double getImage () //获取复数对象的虚部
6)void show( ) //按照实部+虚部i(如10+8i)的形式显示复数对象的值
7)String toString()//返回复数对象对应的串(如4+7i)
（2）编写一个主类，定义并实例化两个复数对象，输出这两个复数对象的值，然后进行复数的
加法和减法运算，输出其运算结果（对象）的值。
4. 实验要求
（1）将两个类存放在一个Java文件或存放在两个Java文件中；
（2）实例化复数对象的实部和虚部值要求从键盘输入；
（3）主类名自定，注意其与文件名的关系；
（4）可用图形用户界面或字符界面。
5. Java源代码
// Java程序
import java.io. *;
public class ComplexNumber{
private double real; public static void main(String args[]){ double d1=0.0,d2=0.0,d3=0.0,d4=0.0; char c='y'; do{ private double image;
System.out.println("请输入第一个复数："); BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); try{ System.out.print("请输入复数的实部:"); String st=br.readLine(); d1=Double.parseDouble(st); }catch(Exception e){System.out.println("输入错误");continue;}; try{ System.out.print("请输入复数的虚部:"); String st1=br.readLine(); d2=Double.parseDouble(st1);
}catch(Exception e){System.out.println("输入错误");continue;}; ComplexNumber x=new ComplexNumber(d1,d2);
System.out.println("请输入第二个复数：");
System.out.print("请输入复数的虚部:"); String st1=br.readLine(); d4=Double.parseDouble(st1); System.out.print("请输入复数的实部:"); String st=br.readLine(); d3=Double.parseDouble(st); }catch(Exception e){System.out.println("输入错误");continue;}; try{ BufferedReader s=new BufferedReader(new InputStreamReader(System.in)); try{
}catch(Exception e){System.out.println("输入错误");continue;}; ComplexNumber y=new ComplexNumber(d3,d4);
System.out.print("第一个复数为:");
x.show(x);
System.out.print("第二个复数为:");
y.show(y);
System.out.print("复数和为:");
System.out.println((x.add(y)).toString()); System.out.print("复数差为:");
System.out.println((x.sub(y)).toString()); System.out.println("要继续输入吗？"); System.out.println("请输入Y/y或N/n"); try
{
c=(char)System.in.read();
System.in.skip(2);
}catch(Exception e ){}
}while(c=='Y'||c=='y');
}
public ComplexNumber(double a, double b){ this.real = a ;
this.image = b;
}
public ComplexNumber add(ComplexNumber a){
ComplexNumber result= ComplexNumber(this.real+a.real,this.image+a.image);
return result;
}
public ComplexNumber sub(ComplexNumber a){
ComplexNumber result= ComplexNumber(this.real-a.real,this.image-a.image);
return result;
} new new
public String toString(){
ComplexNumber=new String(this.real+"+"+this.image+"i");
}
return ComplexNumber;
}
public double getReal(ComplexNumber a)
{
} public double getImage(ComplexNumber a) { } void show(ComplexNumber a) { } } System.out.println(a.getReal(a)+"+"+a.getImage(a)+"i"); return a.image; return a.real; else{ String ComplexNumber=""; if(this.image<0) { ComplexNumber=new String(this.real+""+this.image+"i"); }
6. 实验原理
1、创建对象时，需要为对象开辟内存空间保存域和方法；
2、构造函数的方法名与类名相同；构造函数无返回值；
3、在定义一个类时，需要定义一组称之为“域”或“属性”的变量，保存类或对象的数据，域的类型包括简单类型、类、接口和数组等；
4、静态初始化器与构造函数的不同：构造函数对每个新创建的对象初始化，而静态初始化
器是对类自身进行初始化；构造函数是在用new运算符产生新对象时由系统自动执行，而静态初始化器则是在它所属的类加载入内存时由系统调用执行；静态初始化器不是方法，没有方法名、返回值和参数列表；
5、方法定义中，方法名后的小括号是方法的标志，程序使用方法名来调用方法。
6、类成员访问控制包括：private私有访问控制符、默认访问控制符、protected保护访问控制符和public公共访问控制符。类和类成员都采用默认访问控制符，类比成员的访问范围宽。成员在类的定义内，根据各自的用途设置不同的访问控制，
7. 实验结果分析及心得体会
（1）实验结果分析
根据提示输入复数的实部和虚部，后程序调用求和和求差构造函数，求得结果；当输入为非法数据时，提示错误并重新输入
（2）心得体会
1、进一步熟悉Java命令行编程环境JDK、Textpad编辑器的使用；
2、熟悉了类与对象的概念与关系；
3、掌握了Java类的定义、对象的创建；
4、掌握了成员变量的访问、成员方法的调用；
5、掌握了封装的概念及意义及类成员访问控制。
8. 成绩评定
评语：
成绩：
教师签名：
日 期： 年 月 日
实验日期：20xx年5月30日
实验三 Java的继承和多态编程
1.实验题目：使用Java的继承和多态编程实现小型公司的工资管理
2.实验类型：综合设计
3.实验目的
（1）理解面向对象程序设计的三大基本原则；
（2）掌握Java中类的定义及对象的创建；
（3）掌握Java中继承的定义及使用；
（4）掌握Java中实例方法的覆盖及使用；
（5）熟悉如何将面向对象编程基本原则运用到实际编程中。
4.实验内容
编写Application程序实现小型公司的工资管理。该公司主要有4类人员：经理（Manager）、兼职技术人员（Technician）、销售员（Salesman）和销售经理（SalesManager）。要求记录这些人员的编号、姓名和月工资，计算他们的月工资并显示全部信息。月工资计算办法是：经理拿固定月薪8000元；兼职技术人员按每小时100元领取月薪；销售人员按该当月销售额的4%提成；销售经理既拿固定月工资也领取销售提成，固定月工资为5000元，销售提成为所管辖部门当月销售总额的0.5%。
5.实验要求
（1）不同人员的信息从键盘读取；
（2）主类名自定，注意其与文件名的关系；
（3）当输入的数据格式不对，提示用户输入一个格式正确的数据；
（4）可用图形用户界面或字符界面；
（5）可考虑为每一个类建立一个Java源文件。
6. Java源代码
import java.io. * ;
public class TestPolymorphism
{
public static void main(String args[]) { int a1,a2,a3,a4; String b1,b2,b3,b4; float c,d,m;
a1=a2=a3=a4=0;
b1=b2=b3=b4="Li";
c=d=m=0;
BufferedReader InputStreamReader(System.in));
BufferedReader br5=new BufferedReader(new InputStreamReader(System.in)); try{ System.out.println("请输入兼职技术人员工作时间(小时)："); String t=br5.readLine(); BufferedReader br3=new BufferedReader(new InputStreamReader(System.in)); try{ System.out.println("请输入兼职技术人员姓名："); String s=br3.readLine(); b2=s; try{ System.out.println("请输入兼职技术人员编号："); String st=br2.readLine(); a2=Integer.parseInt(st); }catch(Exception e){System.out.println("输入错误");} br2=new BufferedReader(new BufferedReader br1=new BufferedReader(new InputStreamReader(System.in)); try{ System.out.println("请输入经理姓名："); String s=br1.readLine(); b1=s; BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); try{ System.out.println("请输入经理编号："); String st=br.readLine(); a1=Integer.parseInt(st); }catch(Exception e){System.out.println("输入错误");} }catch(Exception e){System.out.println("输入错误");} }catch(Exception e){System.out.println("输入错误");}
c=Float.parseFloat(t); }catch(Exception e){System.out.println("输入错误");} BufferedReader br6=new BufferedReader(new InputStreamReader(System.in)); try{ System.out.println("请输入销售员编号："); String st=br6.readLine(); a3=Integer.parseInt(st); }catch(Exception e){System.out.println("输入错误");}
BufferedReader try{ System.out.println("请输入销售员姓名："); String s=br7.readLine(); b3=s;
BufferedReader
try{
System.out.println("请输入销售员销售额：");
String t=br8.readLine();
d=Float.parseFloat(t);
}catch(Exception e){System.out.println("输入错误");} br8=new BufferedReader(new br7=new BufferedReader(new
InputStreamReader(System.in)); }catch(Exception e){System.out.println("输入错误");}; InputStreamReader(System.in)); BufferedReader br9=new BufferedReader(new InputStreamReader(System.in)); try{ System.out.println("请输入销售经理编号："); String st=br9.readLine(); a4=Integer.parseInt(st); }catch(Exception e){System.out.println("输入错误");}
BufferedReader br10=new BufferedReader(new InputStreamReader(System.in)); try{ System.out.println("请输入销售经理姓名："); String s=br10.readLine(); b4=s; BufferedReader try{ System.out.println("请输入销售经理销售额："); String t=br11.readLine(); m=Float.parseFloat(t); }catch(Exception e){System.out.println("输入错误");} br11=new BufferedReader(new }catch(Exception e){System.out.println("输入错误");} InputStreamReader(System.in));
Manager emp1=new Manager(a1,b1,8000f);
emp1.getInfo();
Technician emp2=new Technician(a2,b2,(100*c));
emp2.getInfo();
Saleman emp3=new Saleman(a3,b3,(4*d/100));
emp3.getInfo();
SalesManager emp4=new SalesManager(a4,b4,5000f,(5*m/1000)); emp4.getInfo();
emp4.getTotal();
}
abstract class Employee{
int number; String name; float salary; Employee(){} Employee(int number,String name,float salary){ this.number=number; this.name=name; }
}
} this.salary=salary;
class Manager extends Employee{
}
class Technician extends Employee{
}
class Saleman extends Employee{
}
class SalesManager extends Employee { Saleman(int number,String name,float salary){ } void getInfo(){ } System.out.println("销售员"+"编号："+number+"姓名:"+name+"工 super(number,name,salary); Technician(int number,String name,float salary){ } void getInfo(){ } System.out.println("兼职技术人员"+"编号："+number+"姓名:"+name+"工 super(number,name,salary); Manager (int number,String name,float salary){ } void getInfo(){ } System.out.println("经理"+"编号："+number+"姓名:"+name+"工 super(number,name,salary); 资:"+salary); 资:"+salary); 资:"+salary);
} float allowance; SalesManager(int number,String name,float salary,float aa) { } this.number=number; this.name=name; this.salary=salary; allowance=aa; } System.out.println("销售经理"+"编号："+number+"姓名:"+name+"工资:"+salary+"} System.out.println("总工资"+(salary+allowance)); void getInfo(){ 销售提成"+allowance); void getTotal(){
7. 实验原理
1、当一个类获取另一个类中所有非私有的数据和操作的定义作为自己的部分或全部成分时，就成这两类具有继承关系，被继承的类称为父类或超类，继承了父类或超类的所有数据和操作类称为子类；
2、定义类没有extends，默认类为object，子类最多只有一个父亲，即单继承；
3、子类可以继承父类的所有非私有域；
4、父类的非私有方法作为类的非私有成员，也可以被子类所继承；
5、This用来引用当前对象，super用来引用当前对象的父类；
6、方法的重载是类对自身已有的同名方法的重新定义；
7、如果子类没有定义任何构造函数，那么在创建子类对象时，将调用父类无参数的构造函数；如果子类定义了构造函数，则在创建子类对象时，系统将首先隐藏执行父类无参数的构造函数，执行子类自己的构造函数；如果在子类自己定义的构造函数中，利用super关键字显示调用父类的构造函数，系统将不再隐藏调用父类的无参数的构造函数。
8、接口的父亲一定是接口，且接口允许多继承。
8. 实验结果分析及心得体会
（1）实验结果分析
根据提示输入各成员信息，传递信息给父类的各个子类，调用子类输出构造方法，输出员工信息
（2）心得体会
1、理解了面向对象程序设计的三大基本原则；掌握了类的继承和多态；
2、掌握了Java中类的定义及对象的创建；
3、掌握了Java中继承的定义及使用；
4、掌握了Java中实例方法的覆盖及使用；
5、熟悉了如何将面向对象编程基本原则运用到实际编程中；
6、了解了this及super的使用。
9.成绩评定
评语：
成绩：
教师签名：
日 期： 年 月 日
实验日期：20xx年6月13日
实验四 图形用户界面编程
1. 实验题目：使用Java图形用户界面实现一个Java Applet程序
2. 实验类型：设计
3. 实验目的
（1）进一步熟悉javac、appletviewer等命令的使用；
（2）了解Java系统图形用户界面的基本工作原理及界面的设计步骤；
（3）掌握Java事件委托模型；
（4）熟悉Java图形用户界面包；
（5）能熟练使用基本组件和容器。
4. 实验内容
编写一个字符替换的Java Applet程序。在文本域(TextArea或JTextArea)中显示一段预先录入的文字。用户可以在(TextField或JTextField)文本框“寻找”中输入一个被替换字符，在另一个文本框“替换成”中输入欲替换的字符，单击“替换”按钮将文本域中所有的被替换字符改写成替换字符。
5. 实验要求
（1）要求能实现对字符的替换操作；
（2）主类名自定，注意其与文件名的关系；
（3）使用图形用户界面包java.awt或javax.swing；
（4）用java.awt.TextArea或javax.swing.JTextArea作为文本编辑窗口。
6. Java源代码
// Java源程序
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class replace extends Applet implements ActionListener
{
Label prompt2= new Label("被替换字符:");
Label prompt1 = new Label("对应的替换字符:");
TextField text2 = new TextField(10);
TextField text1 = new TextField(10);
TextArea text=new TextArea(10,50);
Button btn1 = new Button("替换");
Button btn2 = new Button("清空");
public void init() { add(prompt2); add(text2);
add(prompt1);
add(text1);
add(btn1);
} public void actionPerformed(ActionEvent e) { if(e.getSource() == btn1) { String s=text.getText(); String st=text2.getText(); String se=text1.getText(); } if (e.getActionCommand()=="清空") s=s.replace(st,se); text.setText(s); add(btn2); add(text); btn1.addActionListener(this); btn2.addActionListener(this);
{ text2.setText("");text2.setText("");
text1.setText("");text1.setText("");
text.setText("");text.setText("");
text2.requestFocus();
text1.requestFocus();
text.requestFocus();
}
}
}
7. 实验原理
1、图形用户界面的每个可能产生事件的组件被称为事件源，不同事件源上发生的事件的种类不同；例如，Botton对象作为事件源可能引发ActionEvent类代表的事件ACTION_PERFORMED;
2、创建标签对象时应同时说明这个标签中的字符串；标签不能接受用户的输入，所以不能引发事件；
3、按钮本身不显示信息，它一般对应一个事先定义好的功能操作，并对应一段程序；常用方法：调用按钮的getLabel（）方法可以返回按钮标签字符串，调用按钮的setLabel（）方法可以设置按钮上的名字；按钮可以引发动作事件，当用户单击一个按钮时就引发了一个动作事件，希望按钮动作事件的程序必须把按钮注册给实现了ActionListener接口的动作事件监听者，并为
实现这个接口的类编写actionPerformed方法代码；
4、java中用于文本处理的基本组件有两种：单行文本框（TextField）和多行文本区域（TextArea），它们都是TextComponent的子类；在创建文本组件的同时，可以指出文本组件中的初始文本字符串；
5、程序通过调用getText（）方法获得用户界面上输入的信息，通过setText（）方法对文本区域显示的内容赋值
8. 实验结果分析及心得体会
（1）实验结果分析
1、在文本域提前输入一段字符，后输入被替换字符和替换字符，点击替换即可；
2、当替换另一文本域中的字符时，点击清空，后重复1操作。
3、实验结果：
替换前：
替换后：
（2）心得体会
1、进一步熟悉了javac、appletviewer等命令的使用；
2、了解了Java系统图形用户界面的基本工作原理及界面的设计步骤；
3、掌握了Java事件委托模型；
4、熟悉了Java图形用户界面包；能熟练使用基本组件和容器。
9.成绩评定
评语：
成绩：
教师签名：
日 期： 年 月 日