Java第一次blog作业
一、前言
1.知识点：
（1）第一次题目集：共有九道题，主要为计算题，考察的内容为类的设计。比如浮点型计算，一维数组，排序，多个类的设计
（2）第二次题目集：主要有八道题，主要考察字符串，数组和类等内容，具体为串口字符串解析
（3）第三次题目集：也是三道题，但难度较大，从点类到线类再到形类，考察了我们数学知识，更让我们更深入体会到了类与对象的关系，并且在理解题目含义的同时运用类的创建（包含 若干属性和若干方法）以及多个类的创建来完成整个代码的框架与思路
2.题量与难度：
总体上讲题量适中，难度从简单到复杂，很符合我们Java现阶段学习的应用和实践，从第一次作业到第三次，引导我们用不同的方法实现同一项功能，通过具体的题目要求，逐步引导我们从面向过程的思维过渡到面向对象的思维。
二、设计与分析
创建学生类，包含
属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）
方法：计算总分、计算平均分
输入5个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
输入格式:
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 { private String studentId; private String name; private int chineseScore; private int mathScore; private int physicsScore; public Student(String studentId, String name, int chineseScore, int mathScore, int physicsScore) { this.studentId = studentId; this.name = name; this.chineseScore = chineseScore; this.mathScore = mathScore; this.physicsScore = physicsScore; } public int getTotalScore() { return chineseScore + mathScore + physicsScore; } public double getAverageScore() { return getTotalScore() / 3.0; } public String getFormattedAverageScore() { return String.format("%.2f", getAverageScore()); } public String toString() { return studentId + " " + name + " " + getTotalScore() + " " + getFormattedAverageScore(); } } public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); Student[] students = new Student[5]; for (int i = 0; i < 5; i++) { String input = scanner.nextLine(); String[] info = input.split(" "); if (info.length == 5) { String studentId = info[0]; String name = info[1]; int chineseScore = Integer.parseInt(info[2]); int mathScore = Integer.parseInt(info[3]); int physicsScore = Integer.parseInt(info[4]); students[i] = new Student(studentId, name, chineseScore, mathScore, physicsScore); } else { students[i] = null; System.out.println("Invalid input for student " + (i + 1)); } } for (Student student : students) { if (student != null) { System.out.println(student.toString()); } } } }
解释与心得
这是一个很好的尝试，但这个程序有一些局限性。首先，它只能处理5个学生的信息，而且一旦输入了5个学生的信息，就不能再添加新的学生。在实际应用中，你可能需要一个动态的数据结构（如ArrayList）来存储任意数量的学生信息。
其次，这个程序没有做很好的错误处理。例如，如果用户输入的不是整数或有效的学号，程序可能会抛出异常。应该在这些地方添加更多的错误处理代码。
2.
创建成绩类，包含：
属性：平时成绩（int）、期末成绩（int）
方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）
创建学生类，包含：
属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）
方法：计算总分、计算平均分
输入3个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
输入格式:
依次输入3个学生的每门课成绩，每个学生成绩信息格式：
学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致
例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出格式:
3个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 242 80.67
22201312 黄昊 234 78.00
22201313 李少辰 236 78.67
输入样例:
在这里给出一组输入。例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 242 76.67 84.00 80.67
22201312 黄昊 234 75.00 80.67 78.00
22201313 李少辰 236 import java.util.Scanner; class Score { int regularScore; int finalScore; public int calculateTotalScore() { return (regularScore * 0.4) + (finalScore * 0.6); } } class Student { String id; String name; Score chinese; Score math; Score physics; public int calculateTotalScore() { return chinese.calculateTotalScore() + math.calculateTotalScore() + physics.calculateTotalScore(); } public double calculateAverageScore() { return calculateTotalScore() / 3.0; } } public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); Student[] students = new Student[3]; for (int i = 0; i < 3; i++) { String id = sc.next(); String name = sc.next(); students[i] = new Student(id, name); for (int j = 0; j < 3; j++) { String course = sc.next(); if (course.equals("语文")) { students[i].chinese = new Score(); } else if (course.equals("数学")) { students[i].math = new Score(); } else if (course.equals("物理")) { students[i].physics = new Score(); } students[i].chinese.regularScore = sc.nextInt(); students[i].chinese.finalScore = sc.nextInt(); } } for (Student student : students) { System.out.printf("%s %s %d %.2f%n", student.id, student.name, student.calculateTotalScore(), student.calculateAverageScore()); } } }
解释与心得
这个Java程序是一个学生成绩管理系统的简化版本。它定义了两个类，Score和Student，用来存储和计算学生的成绩。
在Score类中，它有两个成员变量，regularScore和finalScore，并且有一个方法calculateTotalScore，用来计算这个类的总分。
在Student类中，它有三个Score类的对象，代表学生的语文、数学、物理成绩，并且有两个方法，calculateTotalScore和calculateAverageScore，用来计算学生的总成绩和平均成绩。
在Main类的main方法中，它使用一个Scanner对象从标准输入读取数据，创建了一个学生数组，然后循环读取每个学生的信息，包括他们的ID、名字和三个科目的成绩。然后它计算每个学生的总成绩和平均成绩，最后输出每个学生的ID、名字、总成绩和平均成绩。
这个程序是一个很好的Java编程的练习，它使用了类、对象、输入/输出流等Java的重要特性。但是它还可以进一步改进，比如添加异常处理来处理非法的输入，或者把学生和成绩的数据结构更加严谨地存储起来。
3.
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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 72import java.util.*; class Course { String name; String type; String mode; public Course(String name, String type, String mode) { this.name = name; this.type = type; this.mode = mode; } } class Student { String id; String name; public Student(String id, String name) { this.id = id; this.name = name; } } class Grade { Student student; Course course; int regularScore; int finalScore; int totalScore; public Grade(Student student, Course course, int regularScore, int finalScore) { this.student = student; this.course = course; this.regularScore = regularScore; this.finalScore = finalScore; if ("考试".equals(course.mode)) { this.totalScore = (int) (regularScore * 0.3 + finalScore * 0.7); } else { this.totalScore = finalScore; } } } public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); Map<String, Course> courses = new HashMap<>(); Map<String, Student> students = new HashMap<>(); List<Grade> grades = new ArrayList<>(); Map<String, List<Grade>> gradesByCourse = new HashMap<>(); Map<String, List<Grade>> gradesByStudent = new HashMap<>(); Map<String, List<Grade>> gradesByClass = new HashMap<>(); // 输入课程信息 while (true) { String line = scanner.nextLine(); if (line.equals("end")) break; String[] parts = line.split(" "); if (parts.length < 2) { System.out.println("wrong format"); return; } String courseName = parts[0]; String courseType = parts[1]; String courseMode = parts.length > 2 ? parts[2] : "考试"; if ("必修".equals(courseType) && !"考试".equals(courseMode)) { System.out.println(courseName + " : course type & access mode mismatch"); return; } courses.put(courseName, new Course(courseName, courseType, courseMode)); } // 输入学生成绩 while (true) { String line = scanner.nextLine(); if (line.equals("end")) break; String[] parts = line.split(" "); if (parts.length < 4) { System.out.println("wrong format"); return; } String studentId = parts[0]; String studentName = parts[1]; String courseName = parts[2]; int regularScore = 0; int finalScore = 0; if (!courses.containsKey(courseName)) { System.out.println(studentId + " " + studentName + " : " + courseName + " does not exist"); continue; } Course course = courses.get(courseName); if ("考试".equals(course.mode) && parts.length != 5) { System.out.println(studentId + " " + studentName + " : access mode mismatch"); continue; } if ("考察".equals(course.mode) && parts.length != 4) { System.out.println(studentId + " " + studentName + " : access mode mismatch"); continue; } try { if ("考试".equals(course.mode)) { regularScore = Integer.parseInt(parts[3]); finalScore = Integer.parseInt(parts[4]); } else { finalScore = Integer.parseInt(parts[3]); } } catch (NumberFormatException e) { System.out.println("wrong format"); continue; } if (finalScore < 0 || finalScore > 100 || regularScore < 0 || regularScore > 100) { System.out.println("wrong format"); continue; } if (!students.containsKey(studentId)) { students.put(studentId, new Student(studentId, studentName)); } Student student = students.get(studentId); Grade grade = new Grade(student, course, regularScore, finalScore); grades.add(grade); gradesByCourse.computeIfAbsent(courseName, k -> new ArrayList<>()).add(grade); gradesByStudent.computeIfAbsent(studentId, k -> new ArrayList<>()).add(grade); String classId = studentId.substring(0, 6); gradesByClass.computeIfAbsent(classId, k -> new ArrayList<>()).add(grade); } // 输出学生总成绩平均分 gradesByStudent.entrySet().stream() .sorted(Comparator.comparing(Map.Entry::getKey)) .forEach(entry -> { List<Grade> studentGrades = entry.getValue(); int sum = 0; for (Grade grade : studentGrades) { sum += grade.totalScore; } int avg = sum / studentGrades.size(); System.out.println(entry.getKey() + " " + entry.getValue().get(0).student.name + " " + avg); }); // 输出单门课程成绩平均分 gradesByCourse.entrySet().stream() .sorted(Comparator.comparing(Map.Entry::getKey)) .forEach(entry -> { List<Grade> courseGrades = entry.getValue(); int regularSum = 0; int finalSum = 0; int totalSum = 0; for (Grade grade : courseGrades) { regularSum += grade.regularScore; finalSum += grade.finalScore; totalSum += grade.totalScore; } int regularAvg = regularSum / courseGrades.size(); int finalAvg = finalSum / courseGrades.size(); int totalAvg = totalSum / courseGrades.size(); System.out.println(entry.getKey() + " " + regularAvg + " " + finalAvg + " " + totalAvg); }); // 输出班级所有课程总成绩平均分 gradesByClass.entrySet().stream() .sorted(Comparator.comparing(Map.Entry::getKey)) .forEach(entry -> { List<Grade> classGrades = entry.getValue(); int sum = 0; for (Grade grade : classGrades) { sum += grade.totalScore; } int avg = sum / classGrades.size(); System.out.println(entry.getKey() + " " + avg); }); } }
解释与心得
这是一个用Java编写的程序，该程序定义了三个类：Course，Student和Grade。Course类表示课程，包含课程名称，类型和模式。Student类表示学生，包含学生ID和姓名。Grade类表示学生的课程成绩，包括学生、课程、平时成绩和期末成绩。程序还包含一个主类Main，在其main方法中，通过控制台输入来收集课程信息，并将其存储在各种映射和列表中，以课程名、学生ID和班级名作为键。
程序展示了一个非常清晰和模块化的设计。使用映射（Map）来存储以各种属性（如课程名、学生ID和班级名）为键的对象列表，使得数据的组织更加有序和灵活。这种数据结构对于处理大量数据并进行复杂的查询非常有用。
4.
从键盘输入两个日期，格式如：2022-06-18。判断两个日期的先后，并输出它们之间间隔的天数、周数（不足一周按0计算）。
预备知识：通过查询Java API文档，了解Scanner类中nextLine()等方法、String类中split()等方法、Integer类中parseInt()等方法的用法，了解LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用规则，了解ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法。
输入格式:
输入两行，每行输入一个日期，日期格式如：2022-06-18
输出格式:
第一行输出：第一个日期比第二个日期更早（晚）
第二行输出：两个日期间隔XX天
第三行输出：两个日期间隔XX周
输入样例1:
2000-02-18
2000-03-15
输出样例1:
第一个日期比第二个日期更早
两个日期间隔26天
两个日期间隔3周
输入样例2:
2022-6-18
2022-6-1
输出样例2:
第一个日期比第二个日期更晚
两个日期间隔17天
两个日期间隔2周import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); // 输入两个日期 String[] date1Parts = sc.nextLine().split("-"); String[] date2Parts = sc.nextLine().split("-"); // 解析日期 int year1 = Integer.parseInt(date1Parts[0]); int month1 = Integer.parseInt(date1Parts[1]); int day1 = Integer.parseInt(date1Parts[2]); int year2 = Integer.parseInt(date2Parts[0]); int month2 = Integer.parseInt(date2Parts[1]); int day2 = Integer.parseInt(date2Parts[2]); if(year1 < year2 || (year1 == year2 && month1 < month2) || (year1 == year2 && month1 == month2 && day1 < day2)) { System.out.println("第一个日期比第二个日期更早"); int[] result = daysBetween(year1, month1, day1, year2, month2, day2); System.out.println("两个日期间隔" + result[0] + "天"); System.out.println("两个日期间隔" + result[1] + "周"); } else { System.out.println("第一个日期比第二个日期更晚"); int[] result = daysBetween(year2, month2, day2, year1, month1, day1); System.out.println("两个日期间隔" + result[0] + "天"); System.out.println("两个日期间隔" + result[1] + "周"); } } private static int[] daysBetween(int y1, int m1, int d1, int y2, int m2, int d2) { int days = 0; while(!(y1 == y2 && m1 == m2 && d1 == d2)) { d1++; if(d1 > daysInMonth(y1, m1)) { d1 = 1; m1++; if(m1 > 12) { m1 = 1; y1++; } } days++; } int weeks = days / 7; return new int[] {days, weeks}; } private static int daysInMonth(int year, int month) { int[] daysInMonths = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; if(isLeapYear(year) && month == 2) { return 29; } else { return daysInMonths[month]; } } private static boolean isLeapYear(int year) { return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0; } }
解释与心得
这段Java代码实现了以下功能：通过Scanner类从控制台读取用户输入的两个日期，并使用split方法按“-”分割每个日期（如“2023-02-28”），然后解析成年、月、日的整数。对比两个日期的大小，如果第一个日期早于第二个日期，就调用daysBetween方法计算两个日期之间相隔的天数，并计算相隔的周数（整数除7）。如果第一个日期晚于第二个日期，就调用daysBetween方法计算第二个日期与第一个日期相差的天数，并计算相隔的周数。daysBetween方法通过循环逐步增加日期的天数，直到两个日期相等，计算过程中同时更新天数并处理进月和进年的情况。daysInMonth方法返回给定年份和月份的天数，如果是闰年并且月份是2月就返回29天，否则返回该月份的天数。
这段代码学习了如何使用Java的Scanner类从控制台读取用户输入并分割字符串；学会了如何解析日期以及如何使用循环和条件语句计算两个日期间隔的天数和处理进月进年的情况；还学会了如何定义一个返回天数的函数。
5.
Student类具体要求如下：
私有成员变量：学号(sid，String类型)，姓名(name，String类型)，年龄(age，int类型)，专业(major，String类型) 。
提供无参构造和有参构造方法。（注意：有参构造方法中需要对年龄大小进行判定）
普通成员方法：print()，输出格式为“学号：6020203100，姓名：王宝强，年龄：21，专业：计算机科学与技术”。
普通成员方法：提供setXxx和getXxx方法。（注意：setAge()方法中需要对年龄进行判定）
注意：
年龄age不大于0，则不进行赋值。
print()中的“：”和“，”为均为中文冒号和逗号。
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//调用无参构造方法，并通过setter方法进行设值
String sid1 = sc.next();
String name1 = sc.next();
int age1 = sc.nextInt();
String major1 = sc.next();
Student student1 = new Student();
student1.setSid(sid1);
student1.setName(name1);
student1.setAge(age1);
student1.setMajor(major1);
//调用有参构造方法
String sid2 = sc.next();
String name2 = sc.next();
int age2 = sc.nextInt();
String major2 = sc.next();
Student student2 = new Student(sid2, name2, age2, major2);
//对学生student1和学生student2进行输出
student1.print();
student2.print();
}
}
/* 请在这里填写答案 */
输入格式:
无
输出格式:
学号：6020203110，姓名：王宝强，年龄：21，专业：计算机科学与技术
学号：6020203119，姓名：张三丰，年龄：23，专业：软件工程
输入样例:
在这里给出一组输入。例如：
6020203110 王宝强 21 计算机科学与技术
6020203119 张三丰 23 软件工程
输出样例:
在这里给出相应的输出。例如：
学号：6020203110，姓名：王宝强，年龄：21，专业：计算机科学与技术
学号：6020203119，姓名：张三丰，年龄：23，专业：软件工程import java.util.Scanner; class Student { private String sid; private String name; private int age; private String major; public Student() { } public Student(String sid, String name, int age, String major) { this.sid = sid; this.name = name; setAge(age); this.major = major; } public void print() { System.out.println("学号：" + sid + "，姓名：" + name + "，年龄：" + age + "，专业：" + major); } public void setSid(String sid) { this.sid = sid; } public void setName(String name) { this.name = name; } public void setAge(int age) { if (age > 0) { this.age = age; } } public void setMajor(String major) { this.major = major; } public String getSid() { return sid; } public String getName() { return name; } public int getAge() { return age; } public String getMajor() { return major; } } public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); //调用无参构造方法，并通过setter方法进行设值 String sid1 = sc.next(); String name1 = sc.next(); int age1 = sc.nextInt(); String major1 = sc.next(); Student student1 = new Student(); student1.setSid(sid1); student1.setName(name1); student1.setAge(age1); student1.setMajor(major1); //调用有参构造方法 String sid2 = sc.next(); String name2 = sc.next(); int age2 = sc.nextInt(); String major2 = sc.next(); Student student2 = new Student(sid2, name2, age2, major2); //对学生student1和学生student2进行输出 student1.print(); student2.print(); } }
这段Java代码定义了一个Student类，表示一个学生，包括学号(sid)、姓名(name)、年龄(age)和专业(major)。
这个类中包含两个构造方法，一个无参构造方法和一个有参构造方法。无参构造方法创建一个没有参数的Student对象，而有参构造方法则接收四个参数来初始化Student对象的属性。
此外，这个类还包含一些setter和getter方法，用于设置或获取Student对象的属性。还有一个print方法，用于打印Student对象的信息。
在Main类中，程序从控制台读取输入并创建一个Student对象。首先使用无参构造方法创建一个Student对象，并使用setter方法从控制台读取的输入来设置对象的属性。然后类似地使用有参构造方法创建第二个Student对象。
最后，使用print方法打印两个Student对象的信息。
这段代码展示了如何定义一个类并使用构造方法和getter/setter方法。它也展示了如何从控制台读取输入并使用这些输入来初始化对象。这是一个基本的学生信息管理的Java代码示例，可以在实际的程序中进一步扩展和改进。
6.
输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[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”。
输入样例1:
在这里给出一组输入。例如：
50 50 50.0
输出样例1:
在这里给出相应的输出。例如：
Equilateral triangle
输入样例2:
在这里给出一组输入。例如：
60.2 60.2 80.56
输出样例2:
在这里给出相应的输出。例如：
Isosceles triangle
输入样例3:
在这里给出一组输入。例如：
0.5 20.5 80
输出样例3:
在这里给出相应的输出。例如：
Wrong Formatimport java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner input = new Scanner(System.in); double a, b, c;//三角形的三条边 a = input.nextDouble(); b = input.nextDouble(); c = input.nextDouble(); if((a>=1&&a<=200)&&(b>=1&&b<=200)&&(c>=1&&c<=200)) { if((a+b>c) && (a+c>b) && (b+c>a))//判断是否能构成三角形 { if((a==b)&&a==c&&b==c)//判断是不是等边三角形 { System.out.print("Equilateral triangle"); } else if((a==b)&&((a*a+b*b)-c*c)<0.00001) { System.out.print("Isosceles right-angled triangle"); } else if((a==c)&&((a*a+c*c)-b*b)<0.00001) { System.out.print("Isosceles right-angled triangle"); } else if((c==b)&&((c*c+b*b)-a*a)<0.00001) { System.out.print("Isosceles right-angled triangle"); } else if(a==b||a==c||b==c) { System.out.print("Isosceles triangle"); } else if((a*a+b*b)==c*c||(a*a+c*c)==b*b||(c*c+b*b)==a*a) { System.out.print("Right-angled triangle"); } else if((a+b>c) && (a+c>b) && (b+c>a)) { System.out.print("General triangle"); } else { System.out.print("Not a triangle"); } } else { System.out.print("Not a triangle"); } } else { System.out.print("Wrong Format"); } } }
解释与心得
这段Java代码是用于根据用户输入的三个边长判断它们能否构成一个三角形，并进一步判断三角形的类型。
代码解释：
-
首先，代码导入了
Scanner类，用于从控制台读取用户输入。 -
定义了一个
Main类和它的main方法。 -
在
main方法中，创建一个Scanner对象来读取用户输入。 -
定义了三个
double类型的变量a、b和c来存储用户输入的三角形的三条边。 -
使用
input.nextDouble()方法从控制台读取用户输入的每个边长，并将它们赋值给对应的变量。 -
使用一个条件语句检查这三个边长是否在1到200的范围内，这是为了确保输入的有效性。
-
如果边长在有效范围内，则进一步检查这三个边长是否满足构成三角形的条件，也就是任意两边之和大于第三边。
-
如果满足构成三角形的条件，则开始判断三角形的类型：
- 等边三角形：如果三条边都相等。
- 等腰直角三角形：如果其中两条边相等且第三条边与它们构成的三角形满足勾股定理（误差在0.00001以内）。
- 一般直角三角形：如果其中两条边的平方和等于第三条边的平方（误差在0.00001以内）。
- 等腰三角形：如果其中两条边相等。
- 普通三角形：如果以上条件都不满足。
-
如果不满足构成三角形的条件，则输出“Not a triangle”。
-
如果输入的边长不在1到200的范围内，则输出“Wrong Format”。
心得：
- 这段代码是一个很好的示例，展示了如何使用Java进行简单的用户输入处理。
- 通过对用户输入的边长进行各种条件判断，实现了对三角形类型的分类。
- 在检查是否满足构成三角形的条件时，采用了多个if语句，虽然可读性稍差，但能够清晰地表达判断逻辑。
- 在检查等腰直角三角形和一般直角三角形时，使用了勾股定理，但需要注意的是，这里使用了近似相等（误差在0.00001以内），这是因为在浮点数的计算中，由于精度问题，很难完全相等。
三、踩坑心得
学习Java的过程犹如探险，布满挑战与陷阱。以下是我总结的几点踩坑心得：
- 理解基本概念： 学习Java，首先要掌握基本概念，如变量、数据类型、循环、条件语句等。初学者往往急功近利，忽略了基础的重要性，导致后续学习困难。
- 重视编程规范： Java有严格的编程规范，不遵循规范可能会导致程序出错或难以维护。例如，不适当的命名可能会导致代码含义模糊，不恰当的缩进可能导致程序逻辑混乱。
- 掌握面向对象编程： Java是一种面向对象的编程语言，需要理解类、对象、继承、多态等概念。初学者往往对这些概念感到困惑，但只有深入理解这些概念，才能更好地运用Java。
- 关注异常处理： Java的异常处理是其强大之处，但也是初学者的一个陷阱。忽视异常处理或使用不当，可能导致程序在运行时出错。
- 不要忽视实践： 理论学习固然重要，但只有通过大量实践，才能真正理解和掌握Java编程。多写代码，多做项目，才能真正提高编程能力。
总之，学习Java需要耐心和毅力，不断实践和学习，才能避开陷阱，提高编程能力。
四、改进建议
1.对于类的设计，明确需求和功能：在开始设计类之前，需要明确需求和功能，了解程序需要完成什么，以及需要哪些类来支持这些功能。定义类的属性和方法：根据需求和功能，定义每个类的属性和方法。属性应该与类的对象相关联，方法应该实现类的行为。
2. 对于类的错误避免方面， 使用异常处理：Java提供了异常处理机制，可以在程序中抛出异常并捕获处理，以避免错误的发生和程序的崩溃。
3. 对于使用集合框架方面，了解集合框架的基本概念：Java的集合框架包括List、Set、Map等接口及其实现类。了解这些接口及其实现类的基本概念和使用方法，可以帮助你更好地使用集合框架。使用合适的集合类型：根据实际需求选择合适的集合类型，例如List、Set、Map等。不同的集合类型具有不同的特性，需要根据实际需求进行选择。
五、总结
在Java学习中，我意识到自己在方法和类的运用上仍有不足。具体来说，我需要更深入地理解Java中的方法、类和面向对象编程的概念，以更好地掌握它们的运用。
对于方法的运用，我需要了解它们的具体使用场景、条件和内部原理。在遇到问题时，我需要思考并尝试用不同的方法来解决它们，以提高自己的解决问题的能力。同时，我也需要通过大量的实践来加深自己对Java方法的掌握程度。
在类的设计方面，我需要更加熟悉和掌握面向对象编程的概念。通过学习和实践，我逐渐了解到Java中的类是一个封装了数据和方法的重要概念。类可以被实例化，并且每个实例都有自己的属性和方法。这种设计方式使得程序更加模块化和可维护。因此，我需要提高自己设计和实现类的能力，使程序更加结构化和易于理解。
在编程习惯方面，我需要更加注重代码的可读性和规范性。首先，我需要使用面向对象的思维来设计和实现程序，将相关的函数组织到一个类中，以提高代码的可维护性和可扩展性。其次，我需要遵守Java的编码规范，如规范命名、缩进和注释等，以提高代码的可读性和可理解性。
在学习过程中，我希望老师能够提供更多的指导和帮助。例如，老师可以将每次课的授课知识点文件发给我，以便我进行进一步的学习和研究。此外，老师还可以通过逐步增加难度的方式来布置实验作业，逐步引导我从面向过程的思维方式转变为面向对象的思维方式。
总的来说，Java是一门功能强大的编程语言，具有广泛的应用领域。在学习Java的过程中，我们需要不断地学习和实践，以提高自己的编程能力和解决问题的能力。同时，我们也需要注重代码的可读性和规范性。
浙公网安备 33010602011771号