Java实验六

2020-01-04

《Java程序设计》课程第六周实验题目和代码。

实验内容：面向接口编程与异常处理，实现学位颁发

编写一个程序，通过面向接口编程思想，实现学位颁发功能。具体设计要求如下。
1、设计一个抽象类 Student，描述学生的基本信息。该抽象类所包含的属性为： String name; char gender; Date birthDay; String school; String stuId; String category; double[] score; boolean status;
public abstract String getDegree();
分别对应学生的姓名、性别、出生日期、学校、学号、学生类别、课程成绩、学
位颁发状态、以及获得学位的抽象方法。变量要求包含对应的 set/get 方法。

import java.util.Date;

//抽象类Student
abstract public class Student {
	private String name;      //学生姓名
	private char gender;      //学生性别
	private Date birthDay;    //学生出生日期
	private String school;    //学校
	private String stuId;     //学号
	private String category;   //学生类别
	private double []score;     //课程成绩
	private boolean status;       //学位颁发状态
	
	//设置和获得学生姓名
	void setName(String name) {
		this.name=name;
	}
	String getName() {
		return name;
	}
	
	//设置和获得学生性别
	void setGender(char gender) {
		this.gender=gender;
	}
	char getGender() {
		return gender;
	}
	
	//设置和获得学生出生日期
	void setBirthDay(Date birthday) {
		birthDay=birthday;
	}
	Date getBirthDay() {
		return birthDay;
	}
	
	//设置和获得学生学院
	void setSchool(String school) {
		this.school=school;
	}
	String getSchool() {
		return school;
	}
	
	//设置和获得学生学号
	void setStuId(String stuId) {
		this.stuId=stuId;
	}
	String getStuId() {
		return stuId;
	}
	
	//设置和获得学生类别
	void setCategory(String category) {
		this.category=category;
	}
	String getCategory() {
		return category;
	}
	
	//设置和获得学生成绩
	void setScore(double []s) {
		score=s;
		/**int n=score.length;
		System.out.println("修改成绩为：");
		for(int i=0;i<n;i++) 
			System.out.println(score[i]);**/
	}
	double[] getScore() {
		return score;
	}
	
	//设置和获得学生学位颁发状态
	void setStatus(boolean s) {
		status=s;
	}
	boolean getStatus() {
		return status;
	}
		
	
	public abstract String getDegree();         //判定是否发学位

}

2、设计一个接口 Manageable，提供学位管理功能。该接口定义如下的三个抽象方
法： public abstract double computeAverage() throws Exception; public abstract boolean getPass(); public abstract void printInfo(); 分别用于计算给定一组数据的平均值、识别是否满足用户给定的约束条件、以及
打印一组信息。

//接口Manageable
public interface Manageable {
	public abstract double computeAverage() throws Exception;  //计算给定一组数据的平均值
	public abstract boolean getPass();   //识别是否满足用户给定的约束条件
	public abstract void printInfo();    //打印一组信息
}

3、设计一个继承 Exception 的异常类 UndergraduateException，用于捕获大学生
异常，定义如下：
public class UndergraduateException extends Exception
该异常类中定义一个变量 message，用于判断当大学生的某门成绩不在
0-100 范围内，捕获异常信息，通过 warnMess()方法返回收集的异常信息。

//异常类 UndergraduateException，用于捕获大学生异常
public class UndergraduateException extends Exception {
	String message;
	public UndergraduateException(double s) {
		message="大学生的某门成绩: "+s+" 不在0-100 范围内";
	}
	public String warnMess() {
		return message;
	}

}

4、设计一个继承 Exception 的异常类 MasterException，用于捕获硕士研究生异常，定义如下：
public class MasterException extends Exception
该异常类中定义一个变量 message，用于判断当硕士研究生学位论文等级
不在 A-E 范围内，捕获异常信息，通过 warnMess()方法返回收集的异常信息。

//异常类 MasterException，用于捕获硕士研究生异常
public class MasterException extends Exception{
	String message;
	public MasterException(char s) {
		message="研究生的学位论文等级: " +s+" 不在 A-E 范围内";
	}
	public String warnMess() {
		return message;
	}

}

5、设计一个继承 Student 抽象类、实现 Manageable 接口的具体类 Undergraduate
类，具体要求如下：
（1）定义一个 double 型变量 aver，用于保存该类大学生课程成绩的平均值；
（2）实现 Manageable 接口中定义的三个抽象方法。
（3）在实现 computeAverage()方法过程中，要求通过算术平均值计算大学生
课程平均分。若某门课程不在 0-100 范围，抛出和该分数相关的异常对象。
（4）在实现 getPass()方法过程中，根据大学生课程平均分判定，若课程成绩
平均分 aver 大于等于 60 分，则满足学位颁发要求，改变学位颁发状态。
（5）在实现 getDegree()方法过程中，根据学生的学位颁发状态，确定是否授
予“学士学位”的决定。
（6）在实现 printInfo()方法过程中，分别输出大学生的基本信息（姓名、性
别、出生日期、学校、学号、学生类别、各门课程成绩、颁发学位状况）。

import java.util.Date;

public class Undergraduate extends Student implements Manageable{
private double aver;  //大学生课程成绩的平均值
	
	
	//判断是否满足学位颁发条件
	public boolean getPass () {
		try{
			computeAverage();
			}
		catch(UndergraduateException e) {
			System.out.println("计算大学生平均分过程时出现如下问题：");
			System.out.println(e.warnMess());
		}
		if (aver>=60) {
			setStatus(true);
			return true;
		}
		else {
			setStatus(false);
			return false;
		}
	
	}

	//计算学生课程平均值
	public double computeAverage() throws UndergraduateException{
		double []score;
		int i,n;
		double undergraduatem=0;
		
		score=getScore();
		n=score.length;
		for(i=0;i<n;i++) {
			//System.out.println(score[i]);
			if(score[i]>100||score[i]<0) {
				throw new UndergraduateException(score[i]); //方法抛出异常，导致方法结束
			}
			undergraduatem+=score[i];
		}
		aver=undergraduatem/n;
		
		return aver;
	}
	
	//判定是否发学位
	public String getDegree() {
		boolean k=getStatus();
		if(k==true)
			return Constants.ISSUE_UNDERGRADUATE_DEGREE;
		else
			return Constants.UNSATISFACTORY_ISSUE_UNDERGRADUATE_DEGREE;
	}
	
	//打印一组信息
	public void printInfo() {
		
		String name;      //学生姓名
		char gender;      //学生性别
		Date birthDay;    //学生出生日期
		String school;    //学校
		String stuId;     //学号
		String category;   //学生类别
		double avg;     //平均成绩
		
		//获得学生的基本信息（包括姓名、性别、出生日期、学校、学号、学生类别)
	    name=getName();
	    gender=getGender();
	    birthDay=getBirthDay();
	    school=getSchool();
	    stuId=getStuId();
	    category=getCategory();
	    
	  //输出学生的基本信息（包括姓名、性别、出生日期、学校、学号、学生类别、平均成绩、平均分)
	    System.out.println("学生姓名: "+name);
	    System.out.println("学生性别: "+gender);
	    System.out.println("学生出生日期: "+birthDay);
	    System.out.println("学生学校: "+school);
	    System.out.println("学生学号: "+stuId);
	    System.out.println("学生学号: "+category);
	    try {
	    	avg=computeAverage();
	    	System.out.println("学生成绩: "+avg);
	    }
	    catch(UndergraduateException e) {
			System.out.println("计算大学生平均分过程时出现如下问题：");
			System.out.println(e.warnMess());
		}
	}

}

6、设计一个继承 Student 抽象类、实现 Manageable 接口的具体类 Master 类，具体
要求如下：
（1）定义一个 double 型变量 aver，用于保存该类硕士研究生课程成绩平均值；
定义一个字符型变量 thesisLevel，用于保存硕士研究生学位论文等级
（取值范围为’A’,’B’,’C’,’D’,’E’），并提供对应 get/set 方法。
（2）实现 Manageable 接口中定义的三个抽象方法。
（3）在实现 computeAverage()方法过程中，要求通过几何平均值计算硕士研
究生课程平均分，同时判定学位论文等级的合法性。若某门课程不在
0-100 范围，抛出和该分数相关的大学生异常对象；若学位论文等级不在
A-E 范围内，抛出和学位论文等级相关的硕士生异常对象。
（4）在实现 getPass()方法过程中，根据硕士研究生课程平均分和学位论文两
个方面判定，若课程成绩平均分 aver 大于等于 80 分且学位论文等级为’C ‘及其以上，则满足学位颁发要求，改变学位颁发状态。
（5）在实现 getDegree()方法过程中，根据学生的学位颁发状态，确定是否授
予“硕士学位”的决定。
（6）在实现 printInfo()方法中，输出硕士生基本信息（姓名、性别、出生日
期、学校、学号、学生类别、各门课程成绩、论文等级、颁发学位状态）。

import java.util.Date;

public class Master extends Student implements Manageable {
	private double aver;  //硕士研究生课程成绩的平均值
	private char thesislevel; //硕士研究生学位论文等级
	
	void setThesislevel(char t) {
		thesislevel=t;
	}
	char getThesislevel() {
		return thesislevel;
	}
	
	//判断是否满足学位颁发条件
	public boolean getPass() {
		double a;
		try {
		  a=computeAverage();
		  if(a>=80 && (thesislevel=='C'||thesislevel=='B'||thesislevel=='A')) {
				boolean k=true;
				setStatus(k);
				return true;
			}
			else
				return false;
		}
		catch(UndergraduateException e) {
				System.out.println("计算大学生平均分过程时出现如下问题：");
				System.out.println(e.warnMess());
		}
		catch(MasterException e1) {
			System.out.println("计算大学生平均分过程时出现如下问题：");
			System.out.println(e1.warnMess());
	}
		
           return false;
	}
	
	//计算硕士研究生课程几何平均值
	public double computeAverage()throws UndergraduateException,MasterException{
		double []score;
		int i,n;
		double undergraduatem=1;
		if(thesislevel!='A'&&thesislevel!='B'&&thesislevel!='C'&&thesislevel!='D'&&thesislevel!='E') {
			throw new MasterException(thesislevel);
		}
		
		score=getScore();
		n=score.length;
		for(i=0;i<n;i++) {
			if(score[i]>100||score[i]<0) {
				throw new UndergraduateException(score[i]); //方法抛出异常，导致方法结束
			}
			undergraduatem*=score[i];
		}
		aver=Math.pow(undergraduatem,1.0/n);
		return aver;
	}
	
	//判定是否发学位
	public String getDegree() {
		boolean k=getStatus();
		if(k==true)
			return Constants.ISSUE_MASTER_DEGREE;
		else
			return Constants.UNSATISFACTORY_ISSUE_MASTER_DEGREE;
	}
	//打印一组信息
		public void printInfo() {
			
			String name;      //学生姓名
			char gender;      //学生性别
			Date birthDay;    //学生出生日期
			String school;    //学校
			String stuId;     //学号
			String category;   //学生类别
			double avg;     //平均成绩
			
			//获得学生的基本信息（包括姓名、性别、出生日期、学校、学号、学生类别)
		    name=getName();
		    gender=getGender();
		    birthDay=getBirthDay();
		    school=getSchool();
		    stuId=getStuId();
		    category=getCategory();
		    
		  //输出学生的基本信息（包括姓名、性别、出生日期、学校、学号、学生类别、平均成绩、平均分)
		    System.out.println("学生姓名: "+name);
		    System.out.println("学生性别: "+gender);
		    System.out.println("学生出生日期: "+birthDay);
		    System.out.println("学生学校: "+school);
		    System.out.println("学生学号: "+stuId);
		    System.out.println("学生学号: "+category);
		    try {
		    	avg=computeAverage();
		    	System.out.println("学生成绩: "+avg);
		    }
		    catch(UndergraduateException e) {
				System.out.println("计算大学生平均分过程时出现如下问题：");
				System.out.println(e.warnMess());
			}
		    catch(MasterException e1) {
				System.out.println("计算大学生平均分过程时出现如下问题：");
				System.out.println(e1.warnMess());
		}
		}

}

7、设计一个具体类 StudentDegree，用于管理各类学生的学位授予。具体要求如下：
（1）该类包含一个方法：
public void issueDegree(Manageable manage)
通过调用接口的打印信息方法（printInfo()）和计算平均值方法
（computeAverage()）分别输出学生基本信息和学生课程成绩平均分
（不同类别学生对应的学生基本信息不同）。
（2）提示：在调用计算平均值方法（computeAverage()）过程中，需要捕
获可能的异常信息，包括大学生的课程成绩异常和硕士生研究生的学位论
文等级异常。
（3）提示：在调用以上方法过程中，利用了面向接口编程思想，manage 接受
实现了该接口的任何类创建的对象，则调用接口方法时实际上是调用传入
类对象所实现的方法。

public class StudentDegree {
	//输出学生的基本信息（包括姓名、性别、出生日期、学校、学号、学生类别、平均成绩、平均分)
	   public void issueDegree(Manageable manage) throws Exception{
		   manage.computeAverage();
		   manage.printInfo();
	   }
}

8、设计一个测试类 StudentApplication，测试学生学位授予情况。具体要求如下：
（1）创建一个 Undergraduate 类对象 undergraduate，采用如下赋值：
String name=”王小二”; char gender=’男’; Date birthday=”1998-6-1”; String school=”上海大学”; String stuId=”11128981”; String category=”大学本科生”; double[] score={89.5, 82, 87, 73}; boolean status=false;
（2）创建一个 Master 对象 master，采用如下赋值：
String name=”李燕”; char gender=”女”; Date birthday=”1992-6-12”; String school=”上海大学”; String stuId=”10306”; String category=’硕士研究生’; double[] score={70, 52.5, 95, 88, 89, 91}; char thesisLevel=’B’; boolean status=false;
（3）创建一个 StudentDegree 类的对象 studentDegree，用于测试学位授予。
（4）调用 studentDegree 的成员方法 issueDegree（Manageable manage），
并分别使用 undergraduate 和 master 类作为实参传入，测试大学生对象
和硕士生对象的学位授予情况。

import java.util.Date;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;



public class StudentApplication {
	public static void main(String args[]) throws Exception {
		 try {
				//创建一个 Student 对象 student，用于作为上转型对象
				Student student;
				
				//创建一个 Undergraduate 类对象 undergraduate，采用如下赋值
				Undergraduate undergraduate =new Undergraduate();
				DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
				Date myDate1 = dateFormat.parse("1998-6-1");
				double []score1= {89.5, 82, 87, 73};
				
				undergraduate.setName("王小二");
				undergraduate.setGender('男');
				undergraduate.setBirthDay(myDate1);
				undergraduate.setSchool("上海大学");
				undergraduate.setStuId("11128981");
				undergraduate.setCategory(Constants.UNDERGRADUATE);
				undergraduate.setScore(score1);
				undergraduate.setStatus(false);
				
				//创建一个 Master 对象 master，采用如下赋值
				Master master=new Master();
				DateFormat dateFormat1 = new SimpleDateFormat("yyyy-MM-dd");
				Date myDate2 = dateFormat1.parse("1992-6-12");
				double []score2= {70, 52.5, 95, 88, 89, 91};
				
				master.setName("李燕");
				master.setGender('女');
				master.setBirthDay(myDate2);
				master.setSchool("上海大学");
				master.setStuId("10306");
				master.setCategory(Constants.MASTER);
				master.setScore(score2);
				master.setThesislevel('B');
				master.setStatus(false);
				
				//创建一个 StudentDegree 类的对象 studentDegree，用于测试学位授予。
				StudentDegree studentDegree=new StudentDegree();
				studentDegree.issueDegree(undergraduate);
				studentDegree.issueDegree(master);
				}
			    catch(UndergraduateException e) {
					System.out.println("计算大学生平均分过程时出现如下问题：");
					System.out.println(e.warnMess());
				}
			    catch(MasterException e1) {
					System.out.println("计算大学生平均分过程时出现如下问题：");
					System.out.println(e1.warnMess());
			}
	
				
	}
}

9、创建一个类 Constants,里面定义各类在此程序中使用到的常量，分别如下：
public class Constants { public final static String UNDERGRADUATE = “大学本科生”; public final static String MASTER = “硕士研究生”; public final static String ISSUE_UNDERGRADUATE_DEGREE=”颁发学士学位”; public final static String ISSUE_MASTER_DEGREE=”颁发硕士学位”; public final static String UNSATISFACTORY_ISSUE_UNDERGRADUATE_DEGREE=” 不满足颁发学士学位要求”; public final static String UNSATISFACTORY_ISSUE_MASTER_DEGREE=”不满足颁发硕士学位要求”; }

//类 Constants,里面定义各类在此Java 程序中使用到的常量，分别如下：
public class Constants {
	public final static String UNDERGRADUATE = "大学本科生";
    public final static String MASTER = "硕士研究生";
    public final static String ISSUE_UNDERGRADUATE_DEGREE="颁发学士学位";
    public final static String ISSUE_MASTER_DEGREE="颁发硕士学位";
    public final static String UNSATISFACTORY_ISSUE_UNDERGRADUATE_DEGREE="不满足颁发学士学位要求";
    public final static String UNSATISFACTORY_ISSUE_MASTER_DEGREE="不满足颁发硕士学位要求";
}

打赏