Java必实验二：类的高级应用

一、 实验目的

1. 初步掌握面向对象编程中类的编写。

二、实验内容与要求

1. “自行车”、“小汽车”、“火车”都可以称之为“车”。请通过分析，抽象它们所共有的性质，定义一个抽象类Vehicle。在报告中附上程序截图、运行结果截图和详细的文字说明。（20分）

2.编写一个Person类。该类包含三个成员变量name、weight和height，分别代表一个人的身高和体重。在该类中重写Object类的toString方法，当调用它重写的toString方法时，输出这个人的姓名、体重和身高。在报告中附上程序截图、运行结果截图和详细的文字说明。（20分）

3.编写一个队列类Queue，用来存储float型数据，队列中的数据是先进先出的。具体要求如下：成员变量float [] elements用来存储float型数据；成员变量int size用来表示存储的float型数据的个数；构造方法Queue在初始化队列的时候，设置队列的容量为12；方法enqueue(float v)用来往队列中添加一个float型数据；方法dequeue()用从队列中删除并返回一个float型数据；方法getSize()用来返回队列的大小。在报告中附上程序截图、运行结果截图和详细的文字说明。（20分）

4.编写一个秒表类StopWatch，成员变量和方法自定。编写一个支持快速排序算法的类QuickSort，成员变量和方法自定。对100000, 1000000, …等不同长度的数组中的元素（元素的值随机给定）进行排序，并用秒表对象来记录排序所用的时间。在报告中附上程序截图、运行结果截图和详细的文字说明。（20分）

三、实验过程及结果

1.“自行车”、“小汽车”、“火车”都可以称之为“车”。请通过分析，抽象它们所共有的性质，定义一个抽象类Vehicle。（20分）

package example2;
import java.util.Scanner;      
abstract class Vehicle{         //定义交通工具抽象类Vehicle
	protected String name;      //声明被保护的成员变量name
	public Vehicle(String n) {  //抽象类中的一般方法,本方法为定义Vehicle类的有参构造方法
		name = n;
	}
	abstract public void display(); //将打印收费信息的方法声明为抽象方法
}

class Bicycle extends Vehicle{     //定义继承自Vehicle的自行车子类Bicycle
	private int weight;             //声明私有数据成员weight
	public Bicycle(String n, int w) {  //有参构造方法
		super(n);   //调用父类的有参构造方法
		weight = w;
	}
	public void display() {   //实现抽象类中的display（）方法
		System.out.printf("%s收费为%.2f\n",name,weight*0.15);
	}
}

class Car extends Vehicle{   //定义继承自Vehicle的小汽车子类Car
	private int num;
	private int weight;    //声明私有数据成员num, weight
	public Car(String n, int nu, int w) {  //有参构造方法
		super(n);   //调用父类的有参构造方法
		num = nu;
		weight = w;
	}
	public void display() {   //实现抽象类中的display（）方法
		System.out.printf("%s收费为%.2f\n",name,num * 8 + weight * 0.015);
	}
}

class Train extends Vehicle{  //定义继承自Vehicle的火车子类Train
	private int num;   //声明私有数据成员num
	public Train(String n, int nu) {
		super(n);     //调用父类的有参构造方法
		num = nu;
		num = nu;
	}
	public void display() {   //实现抽象类中的display（）方法
		System.out.printf("%s收费为%.2f\n",name, num * 0.15);
	}
}

public class Tool {         //定义主类
	public static void main(String[] args) {  
		Scanner reader = new Scanner(System.in);
		System.out.println("请输入乘客的重量："); //提示用户输入信息
		int weight1 = reader.nextInt();//从键盘获取weight1
		Vehicle bic = new Bicycle("自行车",weight1); //创建父类对象Vehicle，指向子类对象Bicycle
		bic.display();    //用bic对象调用display（）方法
		System.out.println("请输入小汽车的载客量和重量：");
		int num2 = reader.nextInt();
		int weight2 = reader.nextInt();
		Vehicle car = new Car("小汽车",num2,weight2); //创建父类对象Vehicle，指向子类对象Car
		car.display();   //用car对象调用display（）方法
		System.out.println("请输入小汽车的载客量：");
		int num1 = reader.nextInt();
		Vehicle tra = new Train("火车",num1);       //创建父类对象Vehicle，指向子类对象Train
		tra.display();  //用Tra对象调用display（）方法
		reader.close();  
	}
}

 

2. 编写一个Person类。该类包含三个成员变量name、weight和height，分别代表一个人的身高和体重。在该类中重写Object类的toString方法，当调用它重写的toString方法时，输出这个人的姓名、体重和身高。（20分）

package example;
import java.io.*;  //加载java.io类库里的所有类
import java.util.Scanner;

class Person{     //定义Person类
	private String name;   
	private float weight;
	private float height;    //声明私有成员变量name，weight，height
	public Person(String n, float w, float h) {//定义有参构造方法
		name = n;
		weight = w;
		height = h;
	}
	public String toString() {  //重写Object类的toString()方法
		return name;
	}
	public void display() {   //定义公有成员方法
		Object obj = this;  
		System.out.printf("这个人的姓名为：%s, 体重为: %.2fkg, 身高为: %.2fcm\n",obj.toString(),weight,height); //用对象obj调用Person类同名toString（）方法
	}
}

public class People {    //People主类
	public static void main(String[] args)throws IOException {
		System.out.println("请输入姓名，体重以及身高：");
		BufferedReader buf;
		buf = new BufferedReader(new InputStreamReader(System.in));   		
        String name = buf.readLine();
		Scanner in = new Scanner(System.in);
		float weight = in.nextFloat();
		float height = in.nextFloat(); //获取用户从键盘输入的name，weight，height
		
        Person p = new Person(name, weight, height);//创建对象Person
		p.display();   //用p对象调用display（）方法
		in.close();
		buf.close();
	}
}

 

3. 编写一个队列类Queue，用来存储float型数据，队列中的数据是先进先出的。具体要求如下：成员变量float [] elements用来存储float型数据；成员变量int size用来表示存储的float型数据的个数；构造方法Queue在初始化队列的时候，设置队列的容量为12；方法enqueue(float v)用来往队列中添加一个float型数据；方法dequeue()用从队列中删除并返回一个float型数据；方法getSize()用来返回队列的大小。（20分）

package example;
import java.util.Scanner;

class Queue{             //定义Queue类
	private float []elements;
	private int size;   //声明私有成员变量elements,size	
	public Queue(float [] e, int s) {   //有参构造方法
		size = s;
		elements = new float[200];
		for(int i = 0; i < s; i++) {  //
			 elements[i] = e[i];
		}
		s = 12;              //设置size初值
	}

	public void enqueue(float v) {  //入队，传入入队元素，将元素于队尾入队，同时队列大小+1
		elements[size] = v;
		size++;
	}
	public float dequeue() {   //出队，删除队头元素，同时队列长度-1
		float e = elements[0];
		for(int i = 0; i < size - 1; i++) {
			elements[i] = elements[i + 1];
		}
		size--;
		return e;    //返回被删除元素
	}
	public int getSize() {   //返回数组长度，即队列大小
		return size;
	}
	public void display() {   //逐个输出队列元素
		System.out.printf("队列元素为：");
		for(int i = 0; i < size; i++) {
			System.out.printf("%.2f ",elements[i]);
		}
		System.out.println();
	}
}

public class DataStruct {  //主类
	public static void main(String []args) {
		Scanner sc = new Scanner(System.in);
		System.out.printf("请输入数组长度：");
		int size = sc.nextInt();  //从数组获取队列大小
		float []ele = new float[size];
		System.out.printf("请输入队列元素：");
		for(int i = 0; i < size; i++) {
			ele[i] = sc.nextFloat();   //从键盘获取队列元素
		}
		
		Queue q = new Queue(ele, size);//创建对象Queue
		q.display();    //用q对象调用display（）方法
		int command;
		System.out.printf("请输入测试次数：");
		int t = sc.nextInt(); //从键盘获取测试次数t
		
		while(true) {   
			if(t == 0)
				break;
			else {
				System.out.printf("请输入操作类型：");
				command = sc.nextInt();   //从键盘获取操作类型
				if(command == 1) {
					float v;
					System.out.printf("请输入添加入队的元素：");
					v = sc.nextFloat();   //从键盘获取入队元素
					q.enqueue(v); //v入队
					q.display();
				}
				else if(command == 2) {
					System.out.printf("出队元素为：%.2f\n",q.dequeue());  //队头元素出队
					q.display();   //打印队列元素
				}
				else if(command == 3) {
					System.out.println("数组长度为：" + q.getSize()); //用q对象调用getSize（）方法
					q.display();
				}
				else
					break;
				t--;
			}
		}
		sc.close();
		System.exit(0);
	}
}

 4.编写一个秒表类StopWatch，成员变量和方法自定。编写一个支持快速排序算法的类QuickSort，成员变量和方法自定。对100000, 1000000, …等不同长度的数组中的元素（元素的值随机给定）进行排序，并用秒表对象来记录排序所用的时间。（20分）

package example;

import java.util.*;

class QuickSort{      //QuickSort类
	private int[]elements;
	private int size;
	public QuickSort(int []e, int s) {   //有参构造函数
		size = s;
		elements = new int[s];
		for(int i = 0; i < size; i++) {
			elements[i] = e[i];
		}
	}
    //快速排序算法
	public void quickSort(int []element, int le, int ri) {
		if(le > ri)return;	//递归终止条件
		int i = le;
		int j = ri;
		int temp = element[le]; //定义temp为基准数
		while(i < j) {
            //从右边界向中间遍历，当element[j]大于temp时，继续向左查找，直至element[j]小于temp，下标j左移
			while(element[j] > temp && i < j) {
				j--;
			}
			element[i] = element[j];//将右边查找到的小于等于基准数的数填入右边相应位置
            //从左边界向中间遍历，当element[j]小于等于temp时，继续向右查找，直至element[j]大于temp，下标i右移
			while(temp >= element[i] && i < j) {
				i++;
			}
			element[j] = element[i];//将左边查找到的大于基准数的数填入左边相应位置
		}
		element[i] = temp;//将基准元素填入相应位置
		quickSort(element, le, j - 1);//递归左半边区间进行同样的快速排序
		quickSort(element, j + 1, ri);//递归右半边区间进行同样的快速排序
	}

	public void quickSort() {    //无参quickSort（）方法
		quickSort(elements, 0, size - 1);
	}
    //逐个输出数组元素
	public void display() {
		System.out.println("快速排序后数组为：");
		for(int i = 0; i < size; i++) {
			System.out.printf("%d ",elements[i]);
		}
		System.out.println();
	}
}

class StopWatch{    //StopWatch类
	private long startTime;
	private long endTime;
	public StopWatch(long st, long et) {
		startTime = st;
		endTime = et;
	}
    //获取开始时间
	public void getStartTime() {
		startTime = System.nanoTime();
	}
    //获取结束时间
	public void getEndTime() {
		endTime = System.nanoTime();
	}
	public void display() {
		System.out.println("程序运行时间为："+(endTime-startTime)+"纳秒");
	}
}
//主类
public class Sort {  
	static public void main(String []args) {
		System.out.printf("请输入数组个数：");
		Scanner cn = new Scanner(System.in);
		int size = cn.nextInt();   //获取数组个数
		System.out.printf("请输入数组元素：");
		int []ele = new int[size];
        //获取数组元素
		for(int i = 0; i < size; i++) {
			ele[i] = cn.nextInt();
		}
		QuickSort q = new QuickSort(ele, size);  //创建对象QuickSort
		StopWatch s = new StopWatch(0, 0);  //创建对象StopWatch
		
		s.getStartTime();  //用s对象调用getStartTime（）方法
		q.quickSort();
		q.display();   //用q对象调用quickSort()，display()方法
		s.getEndTime();
		s.display();	//用s对象调用getEndTime（），display()方法
		
		cn.close();
	}
}