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);
		}
		
	}
}