（1）编写一个Student类。类中包含以下成员变量：name（姓名）、stuID（学号）、class（班级）和course（主修的课程）。定义对应的方法对这几个成员变量的值进行设置和读取。（i）在Student类外的main方法里面，创建该类的一个对象，并调用各个方法，展示相应的效果。（ii）在Student类内的main方法里面，创建该类的一个对象，并调用各个方法，展示相应的效果。
package 选实验2;
public class Student {
//定义成员变量
String name,classname,course;
int stuID;
//定义对成员变量进行设置的方法
void setName(String n)
{
name = n;
}
void setClassname(String t)
{
classname = t;
}
void setCourse(String c)
{
course = c;
}
void setStuID(int r)
{
stuID = r;
}
//定义读取成员变量的方法
String getName()
{
return name;
}
String getClassname()
{
return classname;
}
String getCourse()
{
return course;
}
int getStuID()
{
return stuID;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Student student;
student = new Student();
//设置对象成员变量
student.setName("John");
student.setClassname("创新班01");
student.setCourse("计算机科学与技术");
student.setStuID(2020150213);
//读取对象成员变量
System.out.println("姓名:"+student.getName());
System.out.println("学号:"+student.getStuID());
System.out.println("班级:"+student.getClassname());
System.out.println("主修的课程:"+student.getCourse());
}
}
package 选实验2;
public class TestStudent {
public static void main(String[] args) {
// TODO Auto-generated method stub
Student student;
student = new Student();
//设置对象成员变量
student.setName("John");
student.setClassname("创新班01");
student.setCourse("计算机科学与技术");
student.setStuID(2020150213);
//读取对象成员变量
System.out.println("姓名:"+student.getName());
System.out.println("学号:"+student.getStuID());
System.out.println("班级:"+student.getClassname());
System.out.println("主修的课程:"+student.getCourse());
}
}
（2）编写一个队列类Queue，用来存储byte型数据，队列中的数据是先进先出的。具体要求如下：成员变量byte [] elements用来存储byte型数据；成员变量short?size用来表示存储的byte型数据的个数；构造方法Queue在初始化队列的时候，设置队列的容量为16；方法enqueue(int?v)用来往队列中添加一个byte型数据；方法dequeue()用从队列中删除并返回一个byte型数据；方法getSize()用来返回队列的大小。
package 选实验2;
class Queue
{
byte[] elements;
//存储byte型数据
short size;
//存储的byte型数据的个数
int maxsize;
//队列的初始容量
//初始化队列
Queue()
{
maxsize = 16;
elements = new byte[maxsize];
}
//往队列中添加一个byte型数据
void enqueue(int v)
{
elements[size] = (byte)v;
size ++;
}
//从队列中删除并返回一个被删除的byte型数据
byte dequeue()
{
byte temp = elements[0];
for(int i=1;i<size;i++)
{
elements[i-1]=elements[i];
}
size --;
return temp;
}
//返回队列的大小
int getSize()
{
return size;
}
//展示整个队列
void display()
{
System.out.print("当前队列为:");
for(int i=0;i<size;i++)
{
System.out.print(elements[i]+" ");
}
System.out.println();
}
}
public class TestQueue {
public static void main(String[] args) {
// TODO Auto-generated method stub
Queue queue;
queue = new Queue();
//先添加5个数：1 2 3 4 5
for(int i=1;i<=5;i++)
{
queue.enqueue(i);
}
System.out.println("当前队列大小为"+queue.getSize());
queue.display();
//再删去前2个数：3 4 5
System.out.println("删去的数为:");
for(int j=1;j<=2;j++)
{
System.out.println(queue.dequeue());
}
System.out.println("当前队列大小为"+queue.getSize());
queue.display();
}
}
（3）编写一个复数类Complex：成员变量包括realPart和imagePart，分别代表实数部分和虚数部分；构造方法Complex()用于将实数部分和虚数部分都置为0；构造方法Complex(int r, int i)用于将实数部分置为r、虚数部分置为i；方法Complex complexMULTIPLE(Complex c)将当前复数对象与形参复数对象相乘，注意 (a+bj)*(c+dj)=ac-bd+(ad+bc)j；String?toString()把当前复数对象的实数部分和虚数部分组合成a+bj的字符串形式。
package 选实验2;
class Complex
{
int realPart;
int imagePart;
//将实数部分和虚数部分都置为0
Complex()
{
realPart = 0;
imagePart = 0;
}
//将实数部分置为r、虚数部分置为i
Complex(int r,int i)
{
realPart = r;
imagePart = i;
}
//当前复数对象与形参复数对象相乘
void ComplexMultiple(Complex C)
{
int a = realPart;
int b = imagePart;
int c = C.realPart;
int d = C.imagePart;
realPart = a*c-b*d;
imagePart = a*d+b*c;
}
//把当前复数对象的实数部分和虚数部分组合成a+bj的字符串形式
//重写Object类的toString()方法
public String toString()
{
String result;
if(realPart==0)
{
if(imagePart==0)result="0";//0
else result=imagePart+"j";//bj
}
else
{
if(imagePart==0)result=realPart+"";//a
else
{
if(imagePart<0)//a-bj
{
result=realPart+imagePart+"j";
}
else//a+bj
{
result=realPart+"+"+imagePart+"j";
}
}
}
return result;
}
}
public class TestComplex {
public static void main(String[] args) {
// TODO Auto-generated method stub
Complex c1;
c1 = new Complex(3,5);
System.out.println(c1.toString());
Complex c2;
c2 = new Complex(2,3);
System.out.println(c2.toString());
//输出复数3+5i和复数2+3j相乘的结果
c1.ComplexMultiple(c2);
System.out.println(c1.toString());
}
}
（4）编写一个秒表类StopWatch，成员变量和方法自定。编写一个支持快速排序算法的类QuickSort，成员变量和方法自定。对100000, 1000000, …等不同长度的数组中的元素（元素的值随机给定）进行排序，并用秒表对象来记录排序所用的时间。
package 选实验2;
import java.util.Scanner;
class QuickSort
{
//定义成员变量
int[] elements;
int size;
//定义有参构造函数,保留无参构造函数
QuickSort() {}
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[] e,int l,int r)
{
//递归终止条件
if(l>=r)return;
//x作为基准数,选中间的数
int x=e[(l+r)/2],i=l-1,j=r+1;
while(i<j)
{
do i++;while(e[i]<x);
do j--;while(e[j]>x);
//此时e[i]出现：大于x却在x左边
//小于x却在x右边的情况，则交换
if(i<j)
{
int temp=e[i];
e[i] = e[j];
e[j] = temp;
}
}
//以j为边界，继续分治递归两边
quicksort(e, l, j);
quicksort(e, j+1, r);
}
//显示序列
void display()
{
System.out.println("快速排序后为:");
for(int i=0;i<size;i++)
{
System.out.print(elements[i]+" ");
}
System.out.println();
}
}
class StopWatch
{
long startTime;
long endTime;
//无参和含参构造函数
StopWatch() {}
StopWatch(long a,long b)
{
startTime = a;
endTime = b;
}
//获取开始时间
void getStarttime()
{
startTime = System.nanoTime();
}
//获取结束时间
void getEndtime()
{
endTime = System.nanoTime();
}
//打印总运行时间
void display()
{
long ans=endTime-startTime;
System.out.println("程序运行的时间为:"+ans+"纳秒");
}
}
public class TestSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
//获取数组个数
Scanner cin = new Scanner(System.in);
int num = cin.nextInt();
int[] e = new int[num];
//获取数组元素
for(int i=0;i<num;i++)
{
e[i] = cin.nextInt();
}
//快速排序
QuickSort qSort = new QuickSort(e, num);
StopWatch sWatch = new StopWatch(0,0);
sWatch.getStarttime();
qSort.quicksort(e,0,num-1);
qSort.display();
sWatch.getEndtime();
sWatch.display();
cin.close();
}
}