Java实验报告汇总

实验四

1、1)声明一个类Person,该类拥有：

①成员变量name(protected，String);//用于存放姓名；age(protected，int);//用于存放年龄；address(protected，String);//用于存放家庭地址

② 两个构造方法

无参构造方法()//默认将姓名设置为“张三”；

有参构造方法(Stringname,int age,String addr)//创建Person对象时设置姓名、年龄和地址；

2)声明一个类Student,它继承了上面的Person类。还拥有：

①一个成员变量department(私有,String)//用于存放所在系

②两个构造方法

无参构造方法()//先调用父类构造方法，并把所在系的默认设为“信息系”；

有参构造方法(Stringname,int age,String addr ，String dep)//先调用父类的构造方法，然后再设置所在系

3)编写类Test作为主类完成如下测试。

编写应用程序，以自己个人信息作为参数分别创建Person类和Student类的实例对象，并在主方法main中编写代码输出个人信息。

 

2 编写一个类，该类有如下一个方法：public int f(int a ,int b){     

…………………………………..//要求该方法返回a和b的最大公约数

}

再编写一个该类的子类，要求子类重写方法发()，而且重写的方法返回两个整数的最小公倍数。

3.

1）定义一个图形类Shape，定义两个方法分别用来求面积和周长。（这两个方法的体内容应该为空）

2）定义图形类Shape的子类Rectangular类重写求面积及周长的功能

3）定义图形类Shape的子类Circle类重写求面积及周长的功能

编写应用程序，通过上转型对象调用被重写的方法。

class Person{
protected String name;
protected int age;
protected String address;
Person(){
name="张三";
}
Person (String a,int b,String addr){
name=a;
age=b;
address=addr;
}
}
class  Student extends Person{
private String department;
Student(){
department="信息系";
}
Student(String name,int age,String addr,String dep){
super(name,age, addr);
department=dep;
}
void x(){
System.out.println(department);
}
}
public class Main {
public static void main(String args[]){
Person people1=new Person("吕",18,"汶上");
Student people2=new Student("小明",18,"哈尔滨","信息2系");
System.out.println(people1.name+people1.age+people1.address);
System.out.println(people2.name+people2.age+people2.address);
people2.x();
}
}

import java.text.NumberFormat;
class Person{
public int f(int a,int b){
if(a==0)
return b;
return f(a%b,a);
}
}
class A extends Person{
public int f1(int a,int b){
if(a==0)
return b;
return f1(a%b,a);
}
public int f(int a,int b){
return a*b/f1(a,b);
}

}
public class Main {
public static void main(String args[]){
Person a=new Person();
A b=new A();
System.out.println(a.f(3,6)+" "+b.f(3,6));
}
}

import java.text.NumberFormat;
class Shape{
void area(){

}
void length(){

}
}
class Rectangular extends Shape{
void area(){
System.out.println("长方形的面积");
}
void length(){
System.out.println("长方形的周长");
}
}
class Circle extends Shape{
void  area(){
System.out.println("圆的面积");
}
void length(){
System.out.println("圆的周长");
}
}
public class Main {
public static void main(String args[]){
Shape a;
Rectangular b=new Rectangular();
Circle c=new Circle();
a=b;
a.area();
a.length();
a=c;
a.area();
a.length();
}
}

实验5
1.设计一个抽象类，声明有关算术运算的方法，并创建四个子类继承该抽象的类，完成进行加、减、乘、除四则运算。要求：在应用程序的主类中使用这些子类创建对象，再让他们的上转型对象调用算术运算方法。

2.编写一个ComputerAverage抽象类，类中有一个抽象方法求平均分average，可以有参数。定义Gymnastics类和School类，它们都是ComputerAverage的子类，Gymnastics类中计算选手的平均成绩的方法是去掉一个最低分，去掉一个最高分，然后求平均分。School中计算平均分的方法是直接是总分除以总科目。

要求：定义ComputerAverage的对象为上转型对象，并调用重写的方法averge。

3.将1或2中完成的功能使用接口回调重新实现。

4.编写一个类，完成功能为通过scanner对象获得从键盘输入的值，如int，但实际从键盘输入非int值，如float,触发异常，并在catch中处理此异常，如输出异常的信息。（e.getMessage()）

abstract class A{
abstract double op(int a,int b);
}

class B extends A{
double op(int a, int b) {
return a+b;
}
}
class C extends A{

double  op(int a, int b) {

return a-b;
}
}
class D extends A{
double  op(int a, int b) {
return a*b;
}
}
class E extends A{
double  op(int a, int b) {
return a*1.0/b;
}
}

public class Main {
public static void main(String args[]){
B b=new B();
C c=new C();
D d=new D();
E e=new E();
System.out.println(b.op(3,4)+" "+c.op(3,4)+" "+d.op(3,4)+" "+e.op(3,4));
}
}

interface A{
double op(int a,int b);
}

class B implements A{
public double op(int a, int b) {
return a+b;
}
}
class C implements A{
public double op(int a, int b) {
return a-b;
}
}
class D implements A{
public double op(int a, int b) {
return a*b;
}
}
class E implements A{
public double  op(int a, int b) {
return a*1.0/b;
}
}

public class Main {
public static void main(String args[]){
A sm;
sm=new B();
System.out.println(sm.op(3,4));
sm=new C();
System.out.println(sm.op(3,4));
sm=new D();
System.out.println(sm.op(3,4));
sm=new E();
System.out.println(sm.op(3,4));
}
}

import java.util.*;
public class Main {
public static void main(String args[]){
Scanner reader=new Scanner(System.in);
int n;
try{
n=reader.nextInt();
}
catch(Exception e){
System.out.println("发生异常");
}
}
}

实验6

实验内容（1.2中任选一个，3.4.5中任选一个,6必做）

1.编写一个程序，实现字符串的大小写转换并倒序输出，如输入为“HelloWord”，输出为“DROwOLLEH”。要求如下：不能使用StringBudder类的reverse（）方法实现。

编程思路：将字符串放入字符数组中，从最后一个字符开始遍历，通过方法判断如是小写字符则转换为大写，反之转换为小写；定义一个StringBuffer对象，调用方法将数字中转换后的字符放入，用toString()方法输出。

注：String的toLowerCase()方法，可将大写字符转换为小写，toUpperCase()方法可将小写转换为大写。其余方法书上参考或查API帮助。

2.编写一个应用程序，用户从键盘输入一行含有数字和字符的字符串，程序仅仅输出字符串中的全部数字字符。

3.编写一个应用程序，计算从今天起，100天后是几月几号，并使用SimpleDateFormat类，按你设置的格式显示某面某月某日，星期几。

注：可用Calendar类的Add()方法计算100天后的日期。

4编写一个应用程序，输出某年某月的日历。

5.编写一个应用程序，使用BigInteger类实现计算大整数的阶乘。

6.自己编写一个泛型的例子。

import java.util.*;
public class Main {
public static void main(String args[]){
Scanner reader=new Scanner(System.in);
String a;
int i;
a=reader.next();
char[] ch=a.toCharArray();
for(i=0;i<ch.length;i++)
if(ch[i]>='0'&&ch[i]<='9')
System.out.printf("%c",ch[i]);
System.out.printf("\n");

}
}

import java.math.*;
public class Main {
public static void main(String args[]){
BigInteger n=new BigInteger("5");
BigInteger mul=new BigInteger("1");
BigInteger one=new BigInteger("1");
for(BigInteger i=n;i.compareTo(one)>=0;i=i.subtract(one)){
mul=mul.multiply(i);
}
System.out.println(mul);

}
}

import java.util.ArrayList;
import java.util.List;
public class Main {

public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("1234567");
list.add("89101112");
for (int i = 0; i < list.size(); i++) {
String name = list.get(i);
System.out.println("name:" + name);
}
}
}

实验7

二、实验内容（1.2.3.4中任选一个，5.6任选一个）

1.使用TreeSet类，编写一个应用程序，输入5个学生的姓名和数学分数、英语分数。程序分别按英语、数学和总分排序输出学生的姓名和分数。

2.使用LinkList类，编写一个应用程序，用一个二维数组模拟4*4方针，然后将整数1~8随机放入方阵中，要求1~8中的每个数在方阵中恰好出现2次。

提示：首先将1~8添加到链表中，使得链表的长度为16，前8个是1~8，后8个也是1~8，然后随机删除链表中的节点，同时将该结点中的数据顺序的放入方阵中。

3.有集合A={1，2，3，4}，和B={1，3，7，9，11}，编写一个应用程序输出A和B交集、并集和差集。

4.有5个硬盘，有两个重要的属性：价格和容量。使用TreeMap类编写一个应用程序，分别按照价格和容量排序输出10个硬盘的详细信息。

5. 编写一个java程序，在主线程中在创建2个线程，一个线程输出“我是线程A”10次, 一个线程输出“我是线程B”10次,多次运行此程序，观察结果是否一样。

6. 哈尔滨火车站下面有三个火车票代售点，假如哈尔滨到北京的火车票总共是200张，如何用程序来实现三个售票点同时卖票的功能。

import java.util.*;
class Student implements Comparable{
int english=0;
int math=0;
int sum=0;
String name;
Student(int e,int m,String n){
english=e;
name=n;
math=m;
sum=m+e;
}
public int compareTo(Object b) {
Student st=(Student)b;
//return (this.english-st.english);//按英语排序
//return (this.math-st.math);//按数学排序
return (this.sum-st.sum);//按总分排序
}
}
public class Main{
public static void main(String args[]){
TreeSet<Student>mytree=new TreeSet<Student>();
Student st1,st2,st3;
st1=new Student(90,80,"张");
st2=new Student(70,85,"吕");
st3=new Student(20,95,"刘");
mytree.add(st1);
mytree.add(st2);
mytree.add(st3);
Iterator <Student>te=mytree.iterator();
while(te.hasNext()){
Student stu=te.next();
System.out.println(" "+stu.name+"  "+" "+stu.english+" "+" "+stu.math+" "+" "+stu.sum);
}
}
}

class WriteWordThread extends Thread{
WriteWordThread(String s){
setName(s);
}
public void run(){
for(int i=1;i<=10;i++){
System.out.println(" "+getName());
}
}
}
public class Main{
public static void main(String args[]){
WriteWordThread zhang,wang;
zhang=new WriteWordThread("我是线程A");
wang=new WriteWordThread("我是线程B");
zhang.start();
wang.start();
}
}

实验8

二、实验内容（1.2.3任选一个，4.5.6任选一个）

1．在某目录下创建一个文本文件test.txt，通过字节输出流向文件中写入“Beijing欢迎你！”，通过字节输入流读出文件中的内容并显示；如果再已有文件中再追加“我的学号是：你自己的学号”如何实现？

2.文件的拷贝的实现原理通常是通过输入流来读取文件中的数据，通过输出流将数据写入文件。通过编写一段程序来文成文件拷贝的工作。首先在当前目录下创建文件夹source和target，然后在source文件夹中存放“High.mp3”，使用字节输入流读入文件，使用字节输出流写入文件夹target下。（试试你拷贝的文件是否好使）

3．将字符串加密后，通过字符输出流写入文件，然后读取该文件，并解密。

4．编程包含一个文本框和一个文本区域，文本框内容改变时，将文本框中的内容显示在文本区域中；在文本框中按回车键时，清空文本区域的内容。

5．编写一个算术测试小软件，用来训练小学生的算术能力。程序由3个类组成：teacher类的对象充当监视器，负责给出算术题目，并判断回答者的答案是否正确；ComputerFrame类的对象负责为算术题目提供视图，如用户提供ComputerFrame类的对象提供GUI界面看到题目，并通过该GUI界面给出题目的答案；MailClass类是软件的主类。

6.编写一个简单的计算器，要求能实现简单的加、减、乘、除四则运算和置零的功能。

import java.io.*;
public class Main{
public static void main(String args[]){
File file=new File("E:/","hello.txt");
byte b[]="Beijing 欢迎你！".getBytes();
try{
FileOutputStream out=new FileOutputStream(file);
out.write(b);
out.close();
FileInputStream in=new FileInputStream(file);
int n=0;
while((n=in.read(b,0,2))!=-1){
String str=new String(b,0,n);
System.out.println(str);
}
FileWriter writer = new FileWriter("E:/hello.txt", true);
writer.write("我的学号是：你自己的学号");
writer.close();
n=0;
while((n=in.read(b,0,2))!=-1){
String str=new String(b,0,n);
System.out.println(str);
}
}
catch(IOException e){
System.out.println(e);
}

}
}