java题目集1-3总结
一.前言
对于第一次题目集，共有九道题目，分别是身体质量指数（BMI）测算、长度质量计量单位换算、NCHU_奇数求和、NCHU_房产税费计算、游戏角色选择、NCHU_学号识别、NCHU_巴比伦法求平方根近似值、二进制数值提
取、判断三角形类型。以上这九道题目还是比较简单的，其主要包含了java的一些数据类型、输入、输出等一些基础语法。其中判断三角形类型在后续中会有一个简介，其实这个题目并不难，有一个小小的精度问题。
对于第二次题目集，共有八道题目，分别是成绩计算-1-类、数组的基本运用、成绩计算-2-关联类、有重复的数据、去掉重复的数据、面向对象编程(封装性)、GPS测绘中度分秒转换、菜单计价程序-1、jmu-java-日期类的基本
使用。本次题目集共八道题目，从这次题目集开始接触到了类，有了一点面向对象编程的思想了。这次题目对于刚学两周的java同学还是有一定的难度的，尤其是成绩计算-2-关联类和jmu-java-日期类的基本使用。这次作业对于逻辑的理解不是太深，主要是要查找一些java的知识点，这里给大家一个Java的API文档，里面的讲解还是很详细的。Java 官方文档 |官方教程|Java 官方文档 API中文手册|Java 官方文档参考文档_w3cschool
对于第二次题目集，共有四道题目，分别是 jmu-java-日期类的基本使用、课程成绩统计程序-1、面向对象编程(封装性)、判断两个日期的先后，计算间隔天数、周数。其中还有两道题目是上次作业的，按理讲应该还是简单地，但是你想的太多了，其中课程成绩统计程序-1这道题目快要把我搞麻木了，写不明白根本写不明白。这次得分很低，后面到了截止日期也没写出来，后来我又对我自己的代码进行了更改，测试案例过了一部分，但是由于过了截止日期就不能再次提交了，最后过了多少也不清楚。
二、设计与分析
7-7 判断三角形类型
输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。
输出格式:
（1）如果输入数据非法，则输出“Wrong Format”；
（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；
（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；
（3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；
（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”；
（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；
（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。
这道题目其实并不难，就是if-else的搭配，它主要坑人的地方是在判断等腰直角三角形的时候，由于精度问题，判断条件就不能写成a==b&&a*a+b*b-c*c=0，必须写a==b&&a*a+b*b-c*c<0.1这个才能测试点。
部分代码如下：
if((a==b&&a*a+b*b-c*c<0.1)||(a==c&&a*a+c*c-b*b<0.1)||(b==c&&c*c+b*b-a*a<0.1)) {
System.out.println("Isosceles right-angled triangle");
}
7-1 成绩计算-1-类、数组的基本运用
创建学生类，包含
属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）
方法：计算总分、计算平均分
输入5个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：
https://blog.csdn.net/huaishuming/article/details/17752365
注意：未用学生类对象封装数据的，本题计0分
输入格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80 22201312 黄昊 66 82 81 22201313 李少辰 77 76 80 22201314 袁婷 62 79 90 22201315 朱哲一 74 98 94
输出格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 240 80.00 22201312 黄昊 229 76.33 22201313 李少辰 233 77.67 22201314 袁婷 231 77.00 22201315 朱哲一 266 88.67
输入样例:
在这里给出一组输入。例如：
22201311 张琳 80 80 80 22201312 黄昊 66 82 81 22201313 李少辰 77 76 80 22201314 袁婷 62 79 90 22201315 朱哲一 74 98 94
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 240 80.00 22201312 黄昊 229 76.33 22201313 李少辰 233 77.67 22201314 袁婷 231 77.00 22201315 朱哲一 266 88.67
完整代码如下
import java.util.Scanner;
class Student {
String studentID;
String studentName;
int chinese;
int math;
int physics;
public Student(String studentID,String studentName,int chinese,int math,int physics) {
this.studentID = studentID;
this.studentName = studentName;
this.chinese = chinese;
this.math = math;
this.physics = physics;
}
public Student() {
}
public String getStudentID() {
return studentID;
}
public String getStudentName() {
return studentName;
}
public int getChinese() {
return chinese;
}
public int getMath() {
return math;
}
public int getPhysics() {
return physics;
}
/**
* 功能：计算总分
* 输入：无
* 输出：返回一个int类型的三科成绩总分
*/
public int totalScore() {
int sum = chinese + math + physics;
return sum;
}
/**
* 功能：计算三科成绩的平均分
* 输入：无
* 输出：返回一个保留两位小数的值（四舍五入）
*/
public String averageScore() {
String averageScore = String.format("%.2f",totalScore()/3.0);
return averageScore;
}
}
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Student[] stus = new Student[5];
for(int i = 0;i < stus.length;i++) {
String id = input.next();
String name = input.next();
int c = input.nextInt();
int m = input.nextInt();
int p = input.nextInt();
stus[i] = new Student(id,name,c,m,p);
}
for(int j = 0;j < stus.length;j++) {
System.out.print(stus[j].studentID + " ");
System.out.print(stus[j].studentName + " ");
System.out.print(stus[j].totalScore() + " ");
System.out.println(stus[j].averageScore());
}
}
}
类图：
这个题目第一次使用了类，建了一个Student的类，里面没包含了属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）。方法：计算总分、计算平均分这些内容。这里大家可以不用像我一样手敲get和set方法，Eclipse可以帮我们生成get和set方法，步骤如下：鼠标右键——Source—Generate Getters and Setters.
7-7 菜单计价程序-1
某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9
设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）
不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。
参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}
点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}
输入格式:
每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。
输出格式:
订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 2 西红柿炒蛋 3 end
输出样例:
在这里给出相应的输出。例如：
48
输入样例1:
订单中包含不存在的菜品记录。例如：
麻婆豆腐 2 炒脆肚 2 西红柿炒蛋 3 end
输出样例1:
在这里给出相应的输出。例如：
炒脆肚 does not exist 48代码如下：
import java.util.Scanner;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Order order = new Order();
String line = input.nextLine();
while(!line.equals("end")) {
String[] arr = line.split(" ");
String dishName = arr[0];
int portion = Integer.parseInt(arr[1]);
order.addARecord(dishName, portion);
line = input.nextLine();
}
int totalPrice = order.getTotalPrice();
System.out.println(totalPrice);
}
}
//菜品类
class Dish {
String name;
int unit_price;
public Dish(String name, int unit_price) {
this.name = name;
this.unit_price = unit_price;
}
public Dish() {
}
public int getPrice(int portion) {
if(portion == 1) {
return unit_price;
}
else if(portion == 2) {
return (int)(Math.round(unit_price * 1.5));
}
else if(portion == 3) {
return unit_price * 2;
}
else {
return 0;
}
}
}
class Menu{
Dish[] dishs;
public Menu() {
dishs=new Dish[4];
dishs[0] = new Dish("西红柿炒蛋",15);
dishs[1] = new Dish("清炒土豆丝",12);
dishs[2] = new Dish("麻婆豆腐",12);
dishs[3] = new Dish("油淋生菜",9);
}
public Dish searchDish(String dishName) {
for(int i = 0;i < dishs.length;i++) {
if(dishs[i].name.equals(dishName)) {
return dishs[i];
}
}
return null;
}
}
class Record {
Dish d;
int portion;
public Record(Dish d, int portion) {
this.d = d;
this.portion = portion;
}
public int getPrice(){
return d.getPrice(portion);
}
}
class Order {
Record[] records;
int number;
public Order() {
records=new Record[10];
number = 0;
}
public int getTotalPrice(){
int total = 0;
for (int i = 0; i < number; i++) {
total += records[i].getPrice();
}
return total;
}
public Record addARecord(String dishName,int portion){
Menu menu = new Menu();
Dish dish = menu.searchDish(dishName);
if(dish != null) {
Record record = new Record(dish,portion);
records[number++] = record;
return record;
}
else {
System.out.println(dishName + " does not exist");
return null;
}
}
}
类图：
这个题目还是有一点难度的，主要是搞清楚了雷语类之间的关系，问题就迎刃而解了，首先先new一个订单，然后判断该订单是否在目录里面，如果不在就返回错误，如果在就能加在点菜记录里，然后再对订单进行处理。
7-8 jmu-java-日期类的基本使用
- 给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
- 给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。
输入格式:
第一行输入一个日期字符串，格式为"YYYY-MM-dd"
第二行输入两个日期字符串，中间使用空格隔开。分别代表开始日期与结束日期。
输出格式:
如果第一行日期字符串非法，输出自定义的错误信息。
如果第一行日期有效，输出相关信息，如果是闰年要输出是闰年。
如果第二行两个日期，只要有一个无效。就输出相关错误信息。
如果第二行两个日期有效且结束日期不早于开始日期，输出相关信息。
输入样例1:
第一行日期非法、第二行有日期非法
2020-02-30 2020-02-30 2020-01-02
输出样例1:
2020-02-30无效! 2020-02-30或2020-01-02中有不合法的日期.
输入样例2:
均有效且合法
2021-02-28 2019-08-01 2020-01-02
输出样例2:
2021-02-28是当年第59天,当月第28天,当周第7天. 2020-01-02与2019-08-01之间相差154天,所在月份相差-7,所在年份相差1.
输入样例3:
日期均有效，但结束日期早于开始日期
2020-02-28 2020-02-02 2020-02-01
输出样例3:
2020-02-28是闰年. 2020-02-28是当年第59天,当月第28天,当周第5天. 2020-02-01早于2020-02-02,不合法!
代码如下：
import java.util.Scanner;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int flag1 = 1;
int flag2 = 1;
String date1 = input.next();
String[] arr1 = date1.split("-");
String date2 = input.next();
String[] arr2 = date2.split("-");
String date3 = input.next();
String[] arr3 = date3.split("-");
if(!legalJudgment(date1)) {
System.out.println(date1 + "无效!");
flag1 = 0;
}
else {
if(judgeDate(Integer.parseInt(arr1[0]),Integer.parseInt(arr1[1]),Integer.parseInt(arr1[2]))){
if((Integer.parseInt(arr1[0]) % 100 == 0 && Integer.parseInt(arr1[0]) % 400 == 0) || (Integer.parseInt(arr1[0]) % 4 == 0 && Integer.parseInt(arr1[0]) % 100 != 0)) {
System.out.println(date1 + "是闰年.");
showDate1(date1);
}
else {
showDate1(date1);
}
}
else {
System.out.println(date1 + "无效!");
}
}
if(!legalJudgment(date2)||!legalJudgment(date2)) {
System.out.println(date2 + "或" + date3 + "中有不合法的日期.");
return;
}
if (!judgeDate(Integer.parseInt(arr2[0]),Integer.parseInt(arr2[1]),Integer.parseInt(arr2[2]))||
!judgeDate(Integer.parseInt(arr3[0]),Integer.parseInt(arr3[1]),Integer.parseInt(arr3[2]))) {
System.out.println(date2 + "或" + date3 + "中有不合法的日期.");
return;
}
flag2 = compareDates(date2,date3);
if(flag2 == 1) {
differenceDate(date2,date3);
}
}//main
/**
* 判断日期是否合法
* @param year
* @param month
* @param day
* @return boolean
*/
public static boolean judgeDate(int year,int month,int day) {
int[] days = {31,28,31,30,31,30,31,31,30,31,30,31};
if(month >= 1||month <= 12) {
if((year % 100 == 0 && year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) {
if(month == 2&&day <= 29) {
return true;
}
else if(day <= days[month - 1]) {
return true;
}
}
else if(day <= days[month - 1]){
return true;
}
}
return false;
}
/**
* 该日期是当年第几天、当月第几天、当周第几天
* @param date
*/
public static void showDate1(String date) {
// 解析日期字符串为 LocalDate 对象
LocalDate localDate = LocalDate.parse(date, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
// 获取当年的第几天
int dayOfYear = localDate.getDayOfYear();
// 获取当月的第几天
int dayOfMonth = localDate.getDayOfMonth();
// 获取当周的第几天（星期一为一周的第一天）
int dayOfWeek = localDate.getDayOfWeek().getValue();
// 输出结果
System.out.print(date + "是当年第" + dayOfYear + "天,");
System.out.print("当月第" + dayOfMonth + "天,");
System.out.println("当周第" + dayOfWeek + "天.");
}
/**
* 判定结束日期是否早于起始日期
* @param date2
* @param date3
*/
public static int compareDates(String date2,String date3) {
int flag = 1;
LocalDate startDate = LocalDate.parse(date2);
LocalDate endDate = LocalDate.parse(date3);
// 检查结束日期是否早于起始日期
if (endDate.isBefore(startDate)) {
System.out.println(date3 + "早于" + date2 + ",不合法!");
flag = 0;
return flag;
}
return flag;
}
/**
* 输出结束日期与起始日期之间的相差的天数、月数、年数
* @param date2
* @param date3
*/
public static void differenceDate(String date2,String date3) {
// 解析日期字符串为 LocalDate 对象
LocalDate startDate = LocalDate.parse(date2, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
LocalDate endDate = LocalDate.parse(date3, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
// 计算相差的天数
long days = ChronoUnit.DAYS.between(startDate, endDate);
System.out.print(date3 + "与" + date2 + "之间相差" + days + "天,");
String[] arr2 = date2.split("-");
String[] arr3 = date3.split("-");
int month2 = Integer.parseInt(arr2[1]);
int month3 = Integer.parseInt(arr3[1]);
int year2 = Integer.parseInt(arr2[0]);
int year3 = Integer.parseInt(arr3[0]);
System.out.print("所在月份相差" + (month3 - month2) + ",所在年份相差" + (year3 - year2) + ".");
}
public static boolean legalJudgment(String date) {
if((date.charAt(0) >= 48 && date.charAt(0) <= 57) &&
(date.charAt(1) >= 48 && date.charAt(1) <= 57) &&
(date.charAt(2) >= 48 && date.charAt(2) <= 57) &&
(date.charAt(3) >= 48 && date.charAt(3) <= 57) &&
(date.charAt(4) == '-' && date.charAt(4) == '-') &&
(date.charAt(5) >= 48 && date.charAt(5) <= 57) &&
(date.charAt(6) >= 48 && date.charAt(6) <= 57) &&
(date.charAt(7) == '-' && date.charAt(7) == '-') &&
(date.charAt(8) >= 48 && date.charAt(8) <= 57) &&
(date.charAt(9) >= 48 && date.charAt(9) <= 57)){
return true;
}
return false;
}
}
这道题有一点难度，但是当你查询一些资料以后就回发现这道题很简单，大家可以参考上面作者分享的一个java的API文档，里面有对java中日期的操作。其中还有一部分代码也是很关键的，就是日期合法性的判断，写这道题时还不知道什么时正则表达式，就用了一些基础的判断，代码如下。这里就让我深刻体会到了，异常输入测试案例比正常输入测试案例更难，所以对异常输入要更加的重视。这部分要是搞好了，代码的健壮性就很好。
public static boolean legalJudgment(String date) {
if((date.charAt(0) >= 48 && date.charAt(0) <= 57) &&
(date.charAt(1) >= 48 && date.charAt(1) <= 57) &&
(date.charAt(2) >= 48 && date.charAt(2) <= 57) &&
(date.charAt(3) >= 48 && date.charAt(3) <= 57) &&
(date.charAt(4) == '-' && date.charAt(4) == '-') &&
(date.charAt(5) >= 48 && date.charAt(5) <= 57) &&
(date.charAt(6) >= 48 && date.charAt(6) <= 57) &&
(date.charAt(7) == '-' && date.charAt(7) == '-') &&
(date.charAt(8) >= 48 && date.charAt(8) <= 57) &&
(date.charAt(9) >= 48 && date.charAt(9) <= 57)){
return true;
}
return false;
}
7-2 课程成绩统计程序-1
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修
考核方式输入选项：考试、考察
课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
以上信息的相关约束：
1）平时成绩和期末成绩的权重默认为0.3、0.7
2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
3）学号由8位数字组成
4）姓名不超过10个字符
5）课程名称不超过10个字符
6）不特别输入班级信息，班级号是学号的前6位。
2、输出：
输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。
为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。
1）学生课程总成绩平均分按学号由低到高排序输出
格式：学号+英文空格+姓名+英文空格+总成绩平均分
如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
3）班级所有课程总成绩平均分按班级由低到高排序输出
格式：班级号+英文空格+总成绩平均分
如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"
异常情况：
1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
以上两种情况如果同时出现，按第一种情况输出结果。
3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"
4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图：
输入样例1:
仅有课程。例如：
java 必修 考试 数据结构 选修 考试 形式与政治 选修 考察 end
输出样例1:
在这里给出相应的输出。例如：
java has no grades yet 数据结构 has no grades yet 形式与政治 has no grades yet
输入样例2:
单门考试课程 单个学生。例如：
java 必修 考试 20201103 张三 java 20 40 end
输出样例2:
在这里给出相应的输出。例如：
20201103 张三 34 java 20 40 34 202011 34
输入样例3:
单门考察课程 单个学生。例如：
java 选修 考察 20201103 张三 java 40 end
输出样例3:
在这里给出相应的输出。例如：
20201103 张三 40 java 40 40 202011 40
输入样例4:
考试课程 单个学生 不匹配的考核方式。例如：
java 必修 考试 20201103 张三 java 20 end
输出样例4:
在这里给出相应的输出。例如：
20201103 张三 : access mode mismatch 20201103 张三 did not take any exams java has no grades yet 202011 has no grades yet
输入样例5:
单门课程，单个学生，课程类型与考核类型不匹配。例如：
java 必修 考察 20201103 张三 java 40 end
输出样例5:
在这里给出相应的输出。例如：
java : course type & access mode mismatch java does not exist 20201103 张三 did not take any exams 202011 has no grades yet
输入样例6:
单门课程，多个学生。例如：
java 选修 考察 20201103 李四 java 60 20201104 王五 java 60 20201101 张三 java 40 end
输出样例6:
在这里给出相应的输出。例如：
20201101 张三 40 20201103 李四 60 20201104 王五 60 java 53 53 202011 53
输入样例7:
单门课程，单个学生，课程类型与考核类型不匹配。例如：
形式与政治 必修 考试 数据库 选修 考试 java 选修 考察 数据结构 选修 考察 20201103 李四 数据结构 70 20201103 李四 形式与政治 80 90 20201103 李四 java 60 20201103 李四 数据库 70 78 end
输出样例7:
在这里给出相应的输出。例如：
20201103 李四 73 java 60 60 数据结构 70 70 数据库 70 78 75 形式与政治 80 90 87 202011 73
输入样例8:
单门课程，单个学生，成绩越界。例如：
数据结构 选修 考察 20201103 李四 数据结构 101 end
输出样例8:
在这里给出相应的输出。例如：
wrong format 数据结构 has no grades yet
输入样例9:
多门课程，多个学生，多个成绩。例如：
形式与政治 必修 考试 数据库 选修 考试 java 选修 考察 数据结构 选修 考察 20201205 李四 数据结构 70 20201103 李四 形式与政治 80 90 20201102 王五 java 60 20201211 张三 数据库 70 78 end
输出样例9:
在这里给出相应的输出。例如：
20201102 王五 60 20201103 李四 87 20201205 李四 70 20201211 张三 75 java 60 60 数据结构 70 70 数据库 70 78 75 形式与政治 80 90 87 202011 73 202012 72
代码如下;
class Student {
int studentID;
String studentName;
int regularGrade;
int finalGrade;
Course course;
int sumGrade;
public Student(){
}
public Student(int studentID,String studentName,int regularGrade,int finalGrade,Course course) {
this.studentID = studentID;
this.studentName = studentName;
this.regularGrade = regularGrade;
this.finalGrade = finalGrade;
this.course = course;
}
public int getStudentID() {
return studentID;
}
public void setStudentID(int studentID) {
this.studentID = studentID;
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
}
public int getRegularGrade() {
return regularGrade;
}
public void setRegularGrade(int regularGrade) {
this.regularGrade = regularGrade;
}
public int getFinalGrade() {
return finalGrade;
}
public void setFinalGrade(int finalGrade) {
this.finalGrade = finalGrade;
}
public int getSumGrade() {
return sumGrade;
}
public void setSumGrade2(int finalGradede) {
this.sumGrade = finalGrade;
}
public void setSumGrade1(int regularGrade,int finalGrade) {
this.sumGrade = (int)(regularGrade * 0.3 + finalGrade * 0.7);
}
}
class Class {
int classID;
int averageGrade;
Student stus;
public Class() {
}
public Class(int classID) {
this.classID = classID;
}
public int getClassID() {
return classID;
}
public void setClassID(int classID) {
this.classID = classID;
}
public int getAverageGrade() {
return averageGrade;
}
public void setAverageGrade(int averageGrade) {
this.averageGrade = averageGrade;
}
}
class Score {
int number;
String name;
int className;
int regularGrade;
int finalGrade;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getClassName() {
return className;
}
public void setClassName(int className) {
this.className = className;
}
public int getRegularGrade() {
return regularGrade;
}
public void setRegularGrade(int regularGrade) {
this.regularGrade = regularGrade;
}
public int getFinalGrade() {
return finalGrade;
}
public void setFinalGrade(int finalGrade) {
this.finalGrade = finalGrade;
}
}
class Course {
String courseName;
String courseNatue;
String examWay;
int regularAverage;
int finalAverage;
int sumAverage;
public Course() {
}
public Course(String courseName,String courseNatue,String examWay) {
this.courseName = courseName;
this.courseNatue = courseNatue;
this.examWay = examWay;
}
public String getCourseName() {
return courseName;
}
public void setCourseName(String courseName) {
this.courseName = courseName;
}
public String getCourseNatue() {
return courseNatue;
}
public void setCourseNatue(String courseNatue) {
this.courseNatue = courseNatue;
}
public String getExamWay() {
return examWay;
}
public void setExamWay(String examWay) {
this.examWay = examWay;
}
public int getRegularAverage() {
return regularAverage;
}
public void setRegularAverage(int regularAverage) {
this.regularAverage = regularAverage;
}
public int getFinalAverage() {
return finalAverage;
}
public void setFinalAverage(int finalAverage) {
this.finalAverage = finalAverage;
}
public int getSumAverage() {
return sumAverage;
}
public void setSumAverage(int sumAverage) {
this.sumAverage = sumAverage;
}
}
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
ArrayList<Student> studentList = new ArrayList<>();
ArrayList<Course> courseList = new ArrayList<>();
ArrayList<Class> classList = new ArrayList<>();
String data = input.nextLine();
while(!data.equals("end")) {
if(judgeInput(data) == 1) {
String[] temp1 = data.split(" ");
if(temp1[1].equals("必修") && temp1[2].equals("考察")) {
System.out.println(temp1[0] + " : course type & access mode mismatch");
System.out.println(temp1[0] + " does not exist");
//return;
}
else {
Course course = new Course(temp1[0],temp1[1],temp1[2]);
if(judgeCourseRepeat(courseList,temp1[0]) == null) {
courseList.add(course);
}
}
}
else {
String[] temp2 = data.split(" ");
if(temp2.length == 4) {
Course course = new Course();
course = judgeCourseRepeat(courseList,temp2[2]);
if(course == null) {
System.out.println(temp2[0] + " " + temp2[1] + " " + ":" + temp2[2] + " " + "does not exist");
//学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
//return;
}
else {
if(course.getExamWay().equals("考试")) {
System.out.println(temp2[0] + " " + temp2[1] + " " + ": access mode mismatch");
//学号+英文空格+姓名+英文空格+": access mode mismatch"
}
else {
int studentID = Integer.valueOf(temp2[0]);
int score1 = Integer.valueOf(temp2[3]);
//int score2 = Integer.valueOf(temp2[3]);
//if(temp2.length == 5) {
// score2 = Integer.valueOf(temp2[4]);
//}
Student stu = new Student(studentID,temp2[1],0,score1,course);
if(judgeClassRepeat(classList,studentID) == null) {
Class cl = new Class(studentID/100);
classList.add(cl);
}
stu.setSumGrade2(score1);
studentList.add(stu);
}
}
}
else {
Course course = new Course();
course = judgeCourseRepeat(courseList,temp2[2]);
if(course == null) {
System.out.println(temp2[0] + " " + temp2[1] + " " + ":" + temp2[2] + " " + "does not exist");
//学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
return;
}
else {
if(course.getExamWay().equals("考察")) {
System.out.println(temp2[0] + " " + temp2[1] + " " + ": access mode mismatch");
//学号+英文空格+姓名+英文空格+": access mode mismatch"
}
else {
int studentID = Integer.valueOf(temp2[0]);
int score1 = Integer.valueOf(temp2[3]);
int score2 = Integer.valueOf(temp2[4]);
Student stu = new Student(studentID,temp2[1],score1,score2,course);
if(judgeClassRepeat(classList,studentID) == null) {
Class cl = new Class(studentID/100);
classList.add(cl);
}
stu.setSumGrade1(score1,score2);
studentList.add(stu);
}
}
}
}
data = input.nextLine();
}
for(int i = 0;i < studentList.size();i++) {
System.out.println(studentList.get(i).getStudentID() + " " + studentList.get(i).getStudentName() + " " + studentList.get(i).getSumGrade());
}
int sum = 0;
int regularSum = 0;
int finalSum = 0;
int flag = 0;
for(int i = 0;i < courseList.size();i++) {
for(int j = 0;j < studentList.size();j++) {
if(courseList.get(i).getCourseName().equals(studentList.get(j).course.getCourseName())){
if(courseList.get(i).examWay.equals("考试")) {
regularSum += studentList.get(j).getRegularGrade();
finalSum += studentList.get(j).getFinalGrade();
sum += studentList.get(j).getSumGrade();
flag++;
}
else {
finalSum += studentList.get(j).getFinalGrade();
sum += studentList.get(j).getSumGrade();
flag++;
}
}
}
if(flag != 0) {
if(courseList.get(i).getExamWay().equals("考试")) {
courseList.get(i).setRegularAverage(regularSum/flag);
}
courseList.get(i).setFinalAverage(finalSum/flag);
courseList.get(i).setSumAverage(sum/flag);
}
else {
System.out.println(courseList.get(i).getCourseName() + " has no grades yet");
}
}
for(int i = 0;i < courseList.size();i++) {
if(courseList.get(i).getFinalAverage() != 0) {
if(courseList.get(i).getExamWay().equals("考试")) {
System.out.println(courseList.get(i).getCourseName() + " " + courseList.get(i).getRegularAverage() + " " + courseList.get(i).finalAverage + " " + courseList.get(i).sumAverage);
}
else {
System.out.println(courseList.get(i).getCourseName() + " " + courseList.get(i).finalAverage + " " + courseList.get(i).sumAverage);
}
}
}
int classSum = 0;
int classnum = 0;
for(int i = 0;i < classList.size();i++) {
for(int j = 0;j < studentList.size();j++) {
if(classList.get(i).classID == studentList.get(j).getStudentID()/100) {
classSum += studentList.get(i).getSumGrade();
classnum++;
}
}
if(classnum != 0) {
classList.get(i).setAverageGrade(classSum/classnum);
}
}
for(int i = 0;i < classList.size();i++) {
System.out.println(classList.get(i).getClassID() + " " + classList.get(i).getAverageGrade());
}
}
/**
* 正则表达式判断是否输入合理并且判断是课程信息还是学生信息
* @param data
* @return
*/
public static int judgeInput(String data) {
String courseData = "\\S{1,10} (必修|选修) (考试|考察)";
String studentData = "[0-9]{8} \\S{1,10} \\S{1,10} (([1-9]?[0-9])|100) (([1-9]?[0-9])|100)?";
if(data.matches(courseData)) {
return 1;
}
if(data.matches(studentData)) {
return 2;
}
return 0;
}
public static Course judgeCourseRepeat(ArrayList<Course> course,String courseName) {
for(int i = 0;i < course.size();i++) {
if(course.get(i).getCourseName().equals(courseName)) {
return course.get(i);
}
}
return null;
}
public static Class judgeClassRepeat(ArrayList<Class> cl,int classID) {
for(int i = 0;i < cl.size();i++) {
if(cl.get(i).getClassID() == classID) {
return cl.get(i);
}
}
return null;
}
}
这道题目愁死我了，太难了，搞不明白根本搞不明白。其难点一在于它的输入很复杂，相应的输出也就很复杂，尤其是一些错误的输入。其难点二它的类太多了，理不清类与类之间的关系。其难点三数据不知到用什么容器存储，最终我是选择了用ArrayList。最终我也没有拿到满分，后来提交日期截止了以后，我对代码进行了修改，修改后的代码就无法提交了，也不知道到底过了多少测试点。这个题目虽然得分很低，但是其中学到的很多的东西，如正则表达式，类与类之间的联系，还有在设计这个类的时候它的属性和方法如何设置以及设置在哪个类里面，这些东西真的很重要如果没有搞懂的话，写起代码真的很难。
关于正则表达式;
public class Main {
public static void main(String[] args) {
Scanner input =new Scanner(System.in);
String str = input.nextLine();
if(str.matches("^[A-Z][A-Za-z]*\\s[0-9]{8}\\s(man|women)\\s([1-9][0-9]?|1[0-4]{1}[0-9]{1})")) {
System.out.println(str);
}
else {
System.out.println("ERROR");
}
}
}
以上是个正则表达式的案例，这个东西真的可以解决好多输入异常的情况。
三、踩坑心得
此部分都在设计与分析中。
四、主要困难以及改进意见
1.对于第一次练习题，代码基本上都很少，而且都只在一个类里面，自己写的代码等过几天再来看可能一会还能看懂，但对于后面代码多的题目，还是一定要加上备注，备注写明该方法功能、传入参数和返回值。这样便于
下次看自己的代码。
2.想一定要先于写，对于我来说Java不像以前学的c语言，java必须先想，理清各各对象之间的联系，这样才能更好的书写代码。
3.书写程序一定要按照规范去写，要做到见名知意、驼峰式命名等。这样不仅便于自己观看，还有助于他人观看。
4.一定要学会Debug，这是学任何一种语言都必须要熟练掌握编译器的Debug模式，这个会很大效率解决代码的一些逻辑问题。
五、总结
这三次作业的收获很多、打击也很多，刚开始做第一次作业时刚学一件新事物感到很新鲜，后面写着写着发现就很头痛了。这个东西真的很奇怪，给你一道题目如果读不明白，根本不到到该如何下手。所以还是要做去做一些类的设计的题目，代码写的好不好，很大一定程度上取决于类设计的合不合理，优不优。这几次的练习，尤其是菜单的题目还有课程成绩的题目还有实验农夫过河的题目，对类的设计有了一定的方法但不多。希望老师在课堂上能多讲点类的设计，尤其是多个类的设计以及他们的联系。还有就是PTA能不能修改一下，等截止日期过了之后也可以进行提交，但这个提交过了不算分，因为有的题目当时真的写不出来，后来调试了一下，提交不了，也不知道测试点能不能过。
标签：输出,return,String,BLOG1,int,java,public From： https://www.cnblogs.com/gsynb/p/17744885.html