第一篇：java实验报告

中 南 民 族 大 学

实 验 报 告

2010—2011第二学期

课程名称： Java程序设计

院

系：

计算机科学学院

年

级： 2009 专

业：

计算机科学与技术(1)大班 学

号： 09061060 姓 名： 李亚巧 指导教师：

陈建国 陶双喜

2011年6月

实验日期：2011年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

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.成绩评定

评语：

成绩：

教师签名：

日

期： 年 月 日

实验日期：2011年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.成绩评定

评语：

成绩：

教师签名：

日

期： 年 月 日

实验日期：2011年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.成绩评定

评语：

成绩：

教师签名：

日

期： 年 月 日

实验日期：2011年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.成绩评定

评语：

成绩：

教师签名：

日

期： 年 月 日

第二篇：Java实验报告

《Java简易聊天室》

实验目的：实现简单的客服端与服务端通讯，进一步巩固，加深对Java语言基础知识的了解，将理论与实际相结合。

实验要求：能相互之间发送消息，并进行简单的异常处理。

聊天室截图与说明：

客户端

服务端

将客服端与服务端程序同时运行，此时会显示出客户端与服务端界面。在客户端界面上点击“连接”按钮，即可使客户端与服务端进程建立连接。在文本框中输入将要发送的消息，点击“发送”按钮，即可将消息发送到对应端口。当服务端发送消息时，服务端便相当于客户端。当需要终止连接时，关闭相应窗口即可。

设计概要：类/接口/函数说明

1.public class ClientUI extends Jframe｛｝

public class ServerUI extends Jframe｛｝

ClientUI与ServerUi继承Frame类构建客户端与服务器端窗口。

2.class ChatClient extends Thread｛｝

class SvrCom extends Thread｛｝

通讯类ChatClient/SvrCom负责守候数据到来

3.public void run()

用于监听客户端/服务器端发送来的信息，运行连接

4.public void sendMsg(String msg){// 用于发送信息

try {

out.println(“【客户端】” + msg);

} catch(Exception e){

System.out.println(e);

}

} public void sendMsg(String msg){// 用于发送信息

try {

out.println(“【服务器】” + msg);// 把信息写入输出流

} catch(Exception e){

System.out.println(e);

} } 5.try {

msg = in.readLine();// 从in对象上读数据信息

} catch(SocketException ex){

System.out.println(ex);

break;

} catch(Exception ex){

System.out.println(ex);

}

if(msg!= null && msg.trim()!= “"){

System.out.println(”>>“ + msg);

ui.mainArea.append(msg + ”n“);

}

简单的异常处理

6．public ChatClient(String ip, int port, ClientUI ui){// 初始化ChatClient类

this.ui = ui;

try {

sc = new Socket(ip, port);// 创建sc, 用服务器ip和端口作参数

System.out.println(”已顺利联接到服务器。“);

out = new PrintWriter(sc.getOutputStream(), true);

in = new BufferedReader(new InputStreamReader(sc.getInputStream()));

} catch(Exception e){

System.out.println(e);

}

start();

public SvrCom(ServerUI ui){ // 初始化SvrCom类

this.ui = ui;

ui.setServer(this);

try {

soc = new ServerSocket(6666);// 开设服务器端口6666

System.out.println(”启动服务器成功，等待端口号：6666“);

client = soc.accept();// 当客户机请求连接时，创建一条链接

System.out.println(”连接成功！来自“ + client.toString());

in = new BufferedReader(new InputStreamReader(client

.getInputStream()));

out = new PrintWriter(client.getOutputStream(), true);

} catch(Exception ex){

System.out.println(ex);

}

start();

自我评价或总结：经过本次实验，进一步了解了客户端与服务器之间的通信机制，对以后的编程实践垫定了基础。同时还巩固了GUI图形界面知识，更重要的是它使我对网络编程有了一定的了解，也学到了不少知识。

附：

源代码：import java.io.*;import java.net.*;import javax.swing.*;import java.awt.event.*;import java.awt.*;

public class ClientUI extends JFrame { JTextArea mainArea;

JTextArea sendArea;

ChatClient client;JTextField ipArea;JButton btnLink;public void setClient(ChatClient client){ this.client = client;} public ClientUI(){ super(”客户端“);Container contain = getContentPane();contain.setLayout(new BorderLayout());mainArea = new JTextArea();JScrollPane mainAreaP = new JScrollPane(mainArea);JPanel panel = new JPanel();panel.setLayout(new BorderLayout());sendArea = new JTextArea(3, 8);JButton sendBtn = new JButton(”发送“);sendBtn.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent ae){

client.sendMsg(sendArea.getText());

mainArea.append(”【客户端】“ + sendArea.getText()+ ”n“);

sendArea.setText(”“);

} });JPanel ipPanel = new JPanel();ipPanel.setLayout(new FlowLayout(FlowLayout.LEFT, 10, 10));ipPanel.add(new JLabel(”服务器：“));ipArea = new JTextField(12);ipArea.setText(”127.0.0.1“);ipPanel.add(ipArea);btnLink = new JButton(”连接“);ipPanel.add(btnLink);btnLink.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent ae){

client = new ChatClient(ipArea.getText(), 6666, ClientUI.this);

ClientUI.this.setClient(client);

} });

panel.add(sendBtn, BorderLayout.EAST);

panel.add(sendArea, BorderLayout.CENTER);

contain.add(ipPanel, BorderLayout.NORTH);

contain.add(mainAreaP, BorderLayout.CENTER);

contain.add(panel, BorderLayout.SOUTH);

setSize(500, 300);

setVisible(true);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}

public static void main(String[] args){

ClientUI ui = new ClientUI();} }

class ChatClient extends Thread { Socket sc;BufferedReader in;PrintWriter out;ClientUI ui;

public ChatClient(String ip, int port, ClientUI ui){

this.ui = ui;

try {

sc = new Socket(ip, port);

System.out.println(”已顺利联接到服务器。“);

out = new PrintWriter(sc.getOutputStream(), true);

in = new BufferedReader(new InputStreamReader(sc.getInputStream()));

} catch(Exception e){

System.out.println(e);

}

start();}

public void run(){

String msg = ”“;

while(true){

try {

msg = in.readLine();

} catch(SocketException ex){

System.out.println(ex);

break;

} catch(Exception ex){

System.out.println(ex);

}

if(msg!= null && msg.trim()!= ”“){

System.out.println(”>>“ + msg);

ui.mainArea.append(msg + ”n“);

}

} }

public void sendMsg(String msg){

try {

out.println(”【客户端】“ + msg);

} catch(Exception e){

System.out.println(e);

} } } import java.io.*;import java.net.*;import javax.swing.*;import java.awt.event.*;import java.awt.*;/** * 服务端界面ServerUI */ public class ServerUI extends JFrame { JTextArea mainArea;

JTextArea sendArea;

JTextField indexArea;

SvrCom server;

public void setServer(SvrCom server){

this.server = server;}

public ServerUI(){

super(”服务器端“);

Container contain = getContentPane();

contain.setLayout(new BorderLayout());

mainArea = new JTextArea();

JScrollPane mainAreaP = new JScrollPane(mainArea);JPanel panel = new JPanel();panel.setLayout(new BorderLayout());sendArea = new JTextArea(3, 8);JButton sendBtn = new JButton(”发送“);sendBtn.addActionListener(new ActionListener()

{

public void actionPerformed(ActionEvent ae){

server.sendMsg(sendArea.getText());

mainArea.append(”【服务器】sendArea.getText()+ “n”);

sendArea.setText(“");

}

});JPanel tmpPanel = new JPanel();indexArea = new JTextField(2);indexArea.setText(”0“);tmpPanel.add(sendBtn);tmpPanel.add(indexArea);panel.add(tmpPanel, BorderLayout.EAST);panel.add(sendArea, BorderLayout.CENTER);contain.add(mainAreaP, BorderLayout.CENTER);contain.add(panel, BorderLayout.SOUTH);setSize(500, 300);setVisible(true);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);} public static void main(String[] args){ ServerUI ui = new ServerUI();SvrCom server = new SvrCom(ui);}

} class SvrCom extends Thread

{ Socket client;ServerSocket soc;BufferedReader in;PrintWriter out;ServerUI ui;// ChatServer server;public SvrCom(ServerUI ui){

” +

this.ui = ui;ui.setServer(this);try {

soc = new ServerSocket(6666);

}

System.out.println(“启动服务器成功，等待端口号：6666”);

client = soc.accept();

System.out.println(“连接成功！来自” + client.toString());

in = new BufferedReader(new InputStreamReader(client

.getInputStream()));

out = new PrintWriter(client.getOutputStream(), true);} catch(Exception ex){

System.out.println(ex);} start();} public void run(){ String msg = “";while(true){

try {

msg = in.readLine();

} catch(SocketException ex){

System.out.println(ex);

break;

} catch(Exception ex){

System.out.println(ex);

}

if(msg!= null && msg.trim()!= ”“){

System.out.println(”>>“ + msg);

ui.mainArea.append(msg + ”n“);

} } } public void sendMsg(String msg){ try {

out.println(”【服务器】" + msg);} catch(Exception e){

System.out.println(e);} }

第三篇：JAVA实验报告

学 生 实 验 报 告 册

（理工类）

课程名称：面向对象程序设计 专业班级：16计算机科学与技术（专转本）

学生学号： 1613203022 学生姓名： 张义丹

所属院部： 计算机工程 指导教师： 刘 晶 16 ——20 17 学年 第 2 学期

金陵科技学院教务处制 实验报告书写要求

实验报告上交电子稿，标题采用四号黑体，正文采用小四号宋体，单倍行距。

实验报告书写说明

实验报告中实验目的和要求、实验仪器和设备、实验内容与过程、实验结果与分析这四项内容为必需项。教师可根据学科特点和实验具体要求增加项目。

填写注意事项

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

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

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

实验报告批改说明

实验报告的批改要及时、认真、仔细，一律用红色笔批改。实验报告的批改成绩采用五级记分制或百分制，按《金陵科技学院课堂教学实施细则》中作业批阅成绩评定要求执行。

实验项目名称：Java编程基础 实验学时： 6 同组学生姓名： ———— 实验地点： 工科楼A101 实验日期： 17.3.21~17.4.4 实验成绩： 批改教师： 刘晶 批改时间：

实验1 Java编程基础

一、实验目的和要求

（1）熟练掌握JDK1.6及Eclipse4.2编写调试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和Eclipse4.2软件。

三、实验过程

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

public class Hello { public static void main(String args[]){ System.out.println(“Hello!”);} }（2）分别使用JDK命令行和Eclipse编译Java Applet，并建立HTML文档运行该Applet。压缩生成“.jar”文件。记录操作过程。import java.awt.*;import java.applet.Applet;public class HelloApplet extends Applet { public void paint(Graphics g){ g.setColor(Color.red);g.drawString(“Hello!”,20,20);}

} (3)根据变量score中存放的考试分数，输出对应的等级。要求从键盘输入学生成绩，60分以下为D等；60～69为C等；70～89为B等；90～100为A等。(4)编写一个Java Application程序，输出区间[200，300]上的所有素数，将其用数组prime[]保存，并以每10个一行的形式显示运行结果。(5)输出下列数字形式，要求用二维数组完成。①n=4 0 0 0 0 0 1 1 1 0 1 2 2 0 1 2 3 ② n=4 1 1 2 1 1 2 3 2 1 1 2 3 4 3 2 1(6)求二维数组的鞍点,即该位置上的元素在该行上最大，在列上最小。也可能无鞍点。(7)分析下列程序的输出结果，掌握equals（）方法和“= =”的区别。class StringTest2{ public static void main(String args[]){

String s1 = “This is the second string.”;

String s2 = “This is the second string.”;

String s3 = new String(“This is the second string.”);

String s4 = new String(s1);

String s5 = s1;

boolean result121 = s1.equals(s2);

boolean result122 = s1 == s2;

boolean result131 = s1.equals(s3);

boolean result132 = s1 == s3;

boolean result141 = s1.equals(s4);

boolean result142 = s1 == s4;

boolean result151 = s1.equals(s5);

boolean result152 = s1 == s5;

System.out.println(“s1 equals s2= ” +result121);

System.out.println(“s1 == s2= ” +result122);

System.out.println(“s1 equals s3= ” +result131);

System.out.println(“s1 == s3= ” +result132);

System.out.println(“s1 equals s4= ” +result141);

System.out.println(“s1 == s4= ” +result142);

System.out.println(“s1 equals s5= ” +result151);

System.out.println(“s1 == s5= ” +result152);} }(8)判断回文字符串

回文是一种“从前向后读”和“从后向前读”都相同的字符串。如“rotor”是一个回文字符串。

程序中使用了两种算法来判断回文字符串：

算法一：分别从前向后和从后向前依次获得原串str的一个字符ch1、ch2，比较ch1和ch2，如果不相等，则str肯定不是回文串，yes=false，立即退出循环:否则继续比较，直到字符全部比较完，yes的值仍为true，才能肯定str是回文串。

算法二：将原串str反转成temp串，再比较两串，如果相等则是回文字符串。(9)使用String类的compareTo(String s)方法，对以下字符串从小到大排序：“melon”, “apple”, “pear”, “banana”，显示输出排序结果。

要求：

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

（2）要分别掌握用JDK命令行和Eclipse集成开发环境调试Java程序；（3）注意Java两大类程序：应用程序和小程序的区别。

程序清单：

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

（1）主方法传递参数“Hello world”字符串，并输出

public class Hello { public Hello(){

System.out.println(“HelloWorld!”);} public static void main(String args[]){

new Hello();} }（2）Eclipse编译Java Applet import java.awt.*;import java.applet.Applet;public class HelloApplet extends Applet { int height,width;public void init(){

this.height=100;

this.width=300;}

public void paint(Graphics g){

g.setColor(Color.red);

g.drawString(“Hello!”, 20, 20);} }（3）

package b;import java.util.Scanner;public class Test { public static void main(String args[]){

int score;

//char grade;

System.out.println(“请输入分数按回车”);

Scanner reader=new Scanner(System.in);

score=reader.nextInt();

if(score>=90&&score<=100){

System.out.println(“A”);

}

else if(score>=70&&score<=89){

System.out.println(“B”);

}

else if(score>=60&&score<=69){

System.out.println(“C”);

}

else if(score<60){

System.out.println(“D”);

}

else{

System.out.println(“数据错误”);

} } }（4）

public class Lim { public static void main(String[] args){

int[] prime = calculation(20, 200, 300);

for(int i = 0;i < prime.length;i++){

if(prime[i]!= 0){

if(i % 10 == 0 && i!= 0)

System.out.println();

System.out.print(prime[i] + “ ”);// 打印数据

}

}

} public static int[] calculation(int length, int start, int end){

int j;

int step = 0;

int[] prime = new int[length];

for(int i = start;i <= end;i++)

{

j = 2;

while(i % j!= 0){

j++;

}

if(j == i)

{

prime[step] = i;

step++;

}

}

return prime;

} }(5)① public class shuzu { public static void main(String args[]){

int i,j;

int arr[][]=new int[4][];

for(i=0;i

arr[i]=new int[arr.length];for(i=0;i<4;i++)

for(j=3;j>=i;j--){

arr[i][j]=i;

} for(j=0;j<4;j++){

for(i=3;i>=j;i--){

arr[i][j]=j;

} }

for(i=0;i<=3;i++){

for(j=0;j<=3;j++){

System.out.print(arr[i][j]);

System.out.print(“ ”);

}

System.out.println();

}

} } ②public class Shuzu { public static void main(String args[]){ int num[][]=new int[4][];for(int i=0;i

num[i]=new int[2*i+1];

for(int m=0;m

System.out.print(“ ”);

}

int k=i+1;

for(int j=0;j

if(j<=i)

num[i][j]=j+1;

else{

k--;

num[i][j]=k;

}

System.out.print(num[i][j]+“ ”);

}

System.out.println();} } }(6)public class test { public static void main(String[] args){

// TODO Auto-generated method stub

int[][] mat = {{11,12,13},{4,5,6},{7,8,9}};

for(int i=0;i

{

for(int j=0;j

System.out.print(mat[i][j]+“ ”);

System.out.println();

}

boolean find = false;//找到鞍点标记

int row=0;//第1行下标

int max=0;//记录当前行最大值的列下标

while(!find && row

{

max=0;//初始设每行第1列值最大

for(int j=1;j

if(mat[row][j]>mat[row][max])//mat[row][max]为该行最大值

max = j;

boolean yes = true;//再判断mat[row][max]是否在列上最小

int j=0;

while(yes && j

{

if(mat[j][max]

yes=false;

j++;

}

if(yes)

find = true;

else

row++;

}

if(find)

System.out.println(“The dort: ”+mat[row][max]);

else

System.out.println(“The dort: null”);} }(8)import java.util.Scanner;public class HuiWenTest { public static void main(String[] args){

// TODO Auto-generated method stub

System.out.println(“请输入一个字符串”);@SuppressWarnings(“resource”)

Scanner input = new Scanner(System.in);String str = input.next();StringBuilder sb=new StringBuilder(str);sb.reverse();//将Sr倒置的方法 String newStr=new String(sb);if(str.equals(newStr)){ System.out.println(str+“是回文字符串”);}else{ System.out.println(str+“不是回文字符串”);} } }(9)import java.util.*;public class SortString { public static void main(String[] args){

// TODO Auto-generated method stub

String [ ] a={“melon”,“apple”,“pear”,“banana”};

String [ ] b=Arrays.copyOf(a,a.length);System.out.println(“使用用户编写的SortString类，按字典序排列数组a：”);SortString.sort(a);System.out.println(“排序结果是:”);for(String s:a){ System.out.print(“ ”+s);} System.out.println(“");System.out.println(”使用类库中的Arrays类，按字典序排列数组b：“);Arrays.sort(b);System.out.println(”排序结果是:“);for(String s:b){ System.out.print(” “+s);} }

四、实验结果与分析（程序运行结果及其分析）

（1）

（2）

（3）

（4）

（5）

（6）

（7）

（8）

（9）

五、实验体会（遇到问题及解决办法，编程后的心得体会）

在这次实验中，我知道了eclipse和jdk运行程序的区别，jdk比较麻烦一些，需要配置变量。在实验中，配置jdk的环境变量要注意它的path和 classpath，如果classpath本身就有，可以在后面加分号，这样不影响其它的classpath的使用。学会了如何生成注释文档，主函数传递参数的方法，还有压缩文件，实验中还对数组的创建和使用进行了练习，还有一些类的应用。

实验项目名称： 面向对象编程 实验学时： 8 同组学生姓名： ———— 实验地点： 工科楼A101 实验日期： 17.4.11~17.5.2 实验成绩： 批改教师： 刘晶 批改时间：

实验2 面向对象编程

一、实验目的和要求

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

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

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

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

二、实验仪器和设备

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

三、实验过程

（1）定义一个Man类，保存在Man.java文件中，类中包含说话方法如下： public class Man

{

public void say()

{

System.out.println(“我是中国人！”)；

}

} 为此类打包为cn.edu.jit.chinese；再在Man.java文件所在路径下，创建一个China.java文件，其中定义China类如下： public class China

{

public static void main(String[] args)

{

Man lihua = new Man();

lihua.say();

}

}

在China类中引用Man类，输出显示“我是中国人！”。试着去掉Man类的public修饰，看看会发生什么情况？

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

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

（4）试编码实现简单的银行业务：处理简单帐户存取款、查询。编写银行帐户类BankAccount,包含数据成员：余额（balance）、利率(interest)；操作方法：查询余额、存款、取款、查询利率、设置利率。再编写主类UseAccount，包含main()方法，创建BankAccount类的对象，并完成相应操作。

（5）假定根据学生的3门学位课程的分数决定其是否可以拿到学位，对于本科生，如果3门课程的平均分数超过60分即表示通过，而对于研究生，则需要平均超过80分才能够通过。根据上述要求，请完成以下Java类的设计： 1）设计一个基类Student描述学生的共同特征。

2）设计一个描述本科生的类Undergraduate，该类继承并扩展Student类。3）设计一个描述研究生的类Graduate，该类继承并扩展Student类。

4）设计一个测试类StudentDemo，分别创建本科生和研究生这两个类的对象，并输出相关信息。

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

（7）试编码实现多态在工资系统中的应用：给出一个根据雇员类型利用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();}（8）设计圆柱体类和圆椎体类，继承圆类Circle并实现体积接口Volume，计算表面积和体积。

（9）定义一个接口CanFly，描述会飞的方法public void fly();分别定义飞机类和鸟类，实现CanFly接口。定义一个测试类，测试飞机和鸟。测试类中定义一个makeFly(CanFly obj)方法，让会飞的事物飞起来（即调用相应类的fly()方法）。然后在main方法中创建飞机对象和鸟对象，并在main方法中调用makeFly(CanFly obj)方法，让飞机和鸟起飞。

（10）异常的捕获：计算两数相除并输出结果。使用三个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(”商为：“+c);} //捕获与I/O有关的异常（空白处补全捕获语句）

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

//捕获除数为0的异常

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

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

要求：

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

（2）养成良好的编程习惯，严格按照命名规则为包、类及类成员命名，将每个程序打包，包的命名方式如two.num1表示实验二的第一题；

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

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

程序清单：

（建议程序中适当添加注释信息，增强可读性；较长程序可分栏书写，保证报告排版整洁美观。）(1)package cn.edu.jit.chinese;// 为Man类打包为cn.edu.jit.chinese public class Man { public void say(){

System.out.println(”我是中国人！“);} } package cn.edu.jit.chinese;

import cn.edu.jit.chinese.*;//导入包

public class China { public static void main(String[] args){

Man lihua = new Man();//主方法先创建类然后调用类

lihua.say();} }（2）public class Complex { private double real,image;//定义私有的real,image public Complex(double real,double image)

{this.real=real;//赋值

this.image=image;} public Complex(double real){this(real,0);} public Complex(){this(0,0);} public Complex(Complex c){this(c.real,c.image);} public double getReal(){return real;} public void setReal(double real){

this.real = real;} public double getImage(){

return image;} public void setImage(double image){

this.image = image;} public Complex add(Complex c1,Complex c2)//写方法

{Complex C=new Complex(c1.real+c2.real,c1.image+c2.image);return C;} public Complex add(Complex c1){Complex C=new Complex(this.real+c1.real,this.image+c1.image);return C;} public Complex jian(Complex c1,Complex c2){Complex C=new Complex(c1.real-c2.real,c1.image-c2.image);return C;} public Complex jian(Complex c1){Complex C=new Complex(this.real-c1.real,this.image-c1.image);return C;} public boolean bijiao(Complex c1,Complex c2){return(c1.real==c2.real&&c1.image==c2.image);} public boolean bijiao(Complex c1){return(c1.real==this.real&&c1.image==this.image);} public String toString(){return this.real+”+“+this.image+”i“;} } public class ComplexText { public static void main(String[] args){

Complex c1=new Complex(2,5);//创建类，调用类里面的方法

Complex c2=new Complex(5,2);

Complex c3=new Complex();

System.out.println(c3.add(c1,c2));

System.out.println(c3.jian(c1,c2));

System.out.println(c3.bijiao(c1,c2));} }（3）public class Calculate { double i,j, t;public Calculate(int i,int j){this.i=i;this.j=j;} public Calculate(int i,int j,int t){this.i=i;this.j=j;this.t=t;} public double add(){return i+j;} public double jian(){return i-j;} public double cheng(){return i*j;} public double chu(){return i/j;} public double tiji(){return i*i*i+j*j*j+t*t*t;} } public class PackageDemo {//测试

public static void main(String[] args){

Calculate c1=new Calculate(8,4);

Calculate c2=new Calculate(8,4,2);

System.out.println(”相加=“+c1.add());

System.out.println(”相减=“+c1.jian());

System.out.println(”相乘=“+c1.cheng());

System.out.println(”相除 =“+c1.chu());

System.out.println(”立方体体积=“+c2.tiji());} }（4）public class BankAccount { double balance,interest,cunkuan;public BankAccount(double cunkuan,double balance)//写方法

{this.balance=balance;

this.cunkuan=cunkuan;} public void set(double cunkuan)

{if(cunkuan<10000)interest=0.1;

else if(cunkuan<50000)interest=0.25;

else if(cunkuan<100000)interest=0.035;

else interest=0.5;} public double get()

{ return interest;} public void chaxun(double balance,double cunkuan)

{System.out.println(”存款为：“+cunkuan);

System.out.println(”余额为：“+balance);} public void qu(double qukuan)

{System.out.println(”取款为：“+qukuan);System.out.println(”得到的利润率：“+(this.cunkuan-qukuan)*this.interest);} } public class UseAccount {//测试

public static void main(String[] args){

BankAccount c1=new BankAccount(40000,40000);

c1.chaxun(40000,20000);

c1.set(20000);

System.out.println(”利率为“+c1.get());

c1.qu(10000);} }（5）public class Student { String name;int age;float average,chainese;float math,Enghish;public Student(String name,int age){this.name=name;this.age=age;System.out.println(name+”:“+age+”岁“+” “);} public void set(float chinese,float math,float Enghish){average=(chinese+math+Enghish)/3;} public float get(){return average;} }

class Undergraduate extends Student// Student继承Undergraduate {public Undergraduate(String name,int age){ super(name,age);}

public void hege(float average){

this.average=average;

if(average>=60)System.out.println(”本科生成绩合格“);else System.out.println(”本科生成绩不合格“);}}

class Graduate extends Student// Student继承Graduate {public Graduate(String name,int age){ super(name,age);//调用

} public void hege(float average){ this.average=average;if(average>=80)System.out.println(”研究生生成绩合格“);else System.out.println(”研究生成绩不合格“);} } public class StudentDemo {//测试

public static void main(String[] args){

Undergraduate c1=new Undergraduate(”小明 “,22);

System.out.println(”本科生三门成绩分别为：“+”59,“+”85,“+”90“);

c1.set(65,75,60);

System.out.println(”本科生平均分=“+c1.get());

c1.hege(c1.get());

System.out.println();

Graduate c2=new Graduate(”小红 “,18);

System.out.println(”研究生生三门成绩分别为“+”90,“+”84,“+”88“);

c2.set(80,86,79);

System.out.println(”研究生生平均分=“+c2.get());

c2.hege(c2.get());}(6)public abstract class ClosedFigure {//定义抽象类

String shape;public ClosedFigure(String newShape){this.shape=newShape;} public abstract double perimeter();//定义抽象类，里面不能写方法

public abstract double area();} public class Triangle extends ClosedFigure {// ClosedFigure继承Triangle double a,b,c;public Triangle(String newShape,double a,double b,double c){super(”newShape“);this.a=a;this.b=b;

this.c=c;} public double perimeter(){return a+b+c;} public double area(){double s;s=(a+b+c)/2;return Math.sqrt(s*(s-a)*(s-b)*(s-c));} public String toString(){return(”三角形三边长：“+a+” “+b+” “+c+” “+”周长：“+perimeter()+”面积:“+area());} public class Test { public static void main(String[] args){

Triangle c1=new Triangle(”三角形“,3,4,5);

c1.perimeter();

c1.area();

System.out.println(c1.toString());} } }（7）public 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();} public final class Boss extends Employee{ double salary;public Boss(String first, String last, double salary){ super(first, last);

this.salary = salary;} public String earnings(){return(salary+”“);} } public final class CommissionWorker extends Employee { double salary;

double sale;double price;public CommissionWorker(String first, String last, double salary, double sale,double price){

super(first, last);

this.salary = salary;

this.sale = sale;

this.price = price;} public String earnings(){return(salary+sale*price+”“);} } public final class PieceWorker extends Employee{

double number;

double price;

public PieceWorker(String first, String last, double number,double price){

super(first, last);

this.number = number;

this.price=price;

}

public String earnings()

{return(number*price+”“);}

} public final class HourlyWorker extends Employee {double time;double money;public HourlyWorker(String first, String last, double time, double money){ super(first, last);this.time = time;this.money = money;} public String earnings(){ return(time*money+”“);} } public class Test { public static void main(String[] args){

Employee c1=new Boss(”张“,”三“,10000);

System.out.println(”张三月工资：“+c1.earnings());

Employee c2=new CommissionWorker(”李“,”四“,4000,1500,2);

System.out.println(”李四月工资：“+c2.earnings());

Employee c3=new PieceWorker(”王“,”五“,1000,3);

System.out.println(”王五月工资：“+c3.earnings());

Employee c4=new HourlyWorker(”刘“,”三“,600,30);

System.out.println(”刘三月工资：“+c4.earnings());} }（8）public class Circle { String shape;double r;double height;double pi;public Circle(String shape,double r,double height,double pi){this.shape=shape;this.height=height;this.r=r;this.pi=pi;} } public interface Volume { public abstract double area();public abstract double NewVolume();} public class Yuanzhu extends Circle implements Volume { public Yuanzhu(String shape, double r, double height, double pi){ super(shape, r, height, pi);} public double area(){ return pi*r*r;} public double NewVolume(){return area()*height;} } public class Yuanzhui extends Yuanzhu implements Volume { public Yuanzhui(String shape, double r, double height, double pi){

super(shape, r, height, pi);

// TODO Auto-generated constructor stub } double s;public double area(){s=Math.sqrt(height*height+r*r);return pi*r*s+pi*r*r;} public double NewVolum(){return 1.0/3*pi*r*pi*r*height;} } public class Test { public static void main(String[] args){

Yuanzhu c1=new Yuanzhu(”圆柱“,4,6,3.14);

Yuanzhui c2=new Yuanzhui(”圆锥“,2,3,3.14);

System.out.println(”圆柱表面积：“+c1.area());

System.out.println(”圆柱体积：“+c1.NewVolume());

System.out.println(”圆锥表面积：“+c2.area());

System.out.println(”圆锥体积：“+c2.NewVolume());} }(9)public interface CanFly {//定义接口CanFly public void fly();} public class Plane implements CanFly{//使用接口 @Override public void fly(){

// TOD