基於java校園課程作業管理系統設計與實現，可適用於班級管理、學生管理、教師管理、課程管理、課程信息管理、學生選課管理、作業佈置管理、作業提交管理、作業評分管理、課程評價管理、課程資源管理，作業管理系統，大學提交作業，佈置作業管理系統，學校作業管理系統等等 ...
目錄：
1、前言
2、設計與分析
3、踩坑心得
4、主要困難及改進建議
5、總結
1、前言
面向對象程式設計（Object-Oriented Programming，簡稱OOP）是一種編程範式，它以對象作為程式的基本單元，將數據和操作封裝在一起。面向對象程式設計的基本概念包括類、對象、繼承、多態等。
-
類（Class）是面向對象程式設計的基本構建塊，它是一種抽象的數據類型，用於描述具有相同屬性和行為的對象的集合。類定義了對象的屬性（成員變數）和行為（方法）。
-
對象（Object）是類的實例化結果，它是具體的、有狀態的實體。對象可以根據類的定義，擁有自己的屬性值，並能執行類中定義的方法。
-
繼承（Inheritance）是一種機制，允許在已有類的基礎上創建新類，新類可以繼承和擴展已有類的屬性和方法。繼承能夠提供代碼的重用性和層次化的組織結構。
-
多態（Polymorphism）是指同一類型的對象在不同的情況下可以表現出不同的行為。多態性可以通過繼承和介面實現，使得程式可以根據上下文選擇合適的方法。
面向對象程式設計的優點包括代碼的可重用性、可擴展性、易維護性和模塊化等。它提供了一種更加靈活和抽象的編程方式，使得程式的設計和實現更加清晰和可管理。在前三次的作業中我主要使用了創建類和對象的知識，並未涉及到繼承和多態的有關知識的運用。
第一次作業主要是一些java基礎語法的應用，較為簡單的輸入輸出應用，if-else、switch、while語句等迴圈、選擇語句的應用，第一次作業體量大，但是難度低，比較重視我們的基礎訓練；
第二次作業開始接觸封裝的思想，題目主要針對於類以及對象的創建和應用、java自帶的API的熟悉、各種類的運用，題目量大，難度也提高了許多；
第三次作業題量減少許多，相對難度是三次作業中最大的，其中關於類的創建和運用對於現在的我來說略感複雜。
2、設計與分析
第一次作業：
總體分析：這次作業主要設計到java語言的簡單輸入輸出、字元串匹配、迴圈、選擇語句的運用，其中對類的應用並不複雜。
類圖如下：
7-1 身體質量指數（BMI）測算---------使用了簡單的scanner類輸入，經過簡單的選擇語句，即可得出正確答案
7-2 長度質量計量單位換算-----------主要是精度之間的轉換，針對基本語法的考察，也不難
7-3 NCHU_奇數求和---------掌握演算法，經過簡單if-else語句，即可累加得出答案
7-4 NCHU_房產稅費計算---------這道題只需要註意單位轉換，輸入和輸出一一對應，與上面的難度相當
7-5 游戲角色選擇----------這道題需要用到switch選擇語句，可以減少複雜度。
7-6 NCHU_學號識別-----------這道題需要用到string類的有關方法，如substring、equals等來匹配學號的對應位數字
7-8 NCHU_巴比倫法求平方根近似值------運用math類的abs方法求絕對值，即可求出
7-9 二進位數值提取-------這道題主要用到了string類的charAt來獲取字元串的某一位字元，來匹配二進位的0、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”。
在這道題的解題過程中，我遇到一個始終過不去的測試點，就是那個等腰直角三角形的判斷，我的演算法是既符合等腰三角形的兩邊相等，又符合a的平方+b的平方=c的平方，但是始終無法通過這個測試點，後來經過網路查詢，我想到或許是因為電腦對於無理數的輸出不夠準確，於是我把其判斷條件改成了a*a+b*b-c*c<0.0001,這樣縮小了精度，但是可能更符合電腦的對於無理數的處理，再次嘗試就通過了測試點。
第二次作業：
第二次針對類的創建和應用開始接觸的更加深入，面向對象的封裝思想也在逐漸被使用，主要是數組和類的應用。
7-1 成績計算-1-類、數組的基本運用-------題目如下：
創建學生類，包含
屬性：學號（String）、姓名（String）、語文成績（int）、數學成績（int）、物理成績（int）
方法：計算總分、計算平均分
輸入5個學生的信息，將每個學生的信息封裝在一個學生對象中。
按輸入順序依次輸出5個學生的總分、平均分（精確到小數點後兩位，捨去部分按四捨五入規則計入最後一位）。
分析：這道題目開始接觸數據封裝思想，需要用學生類來封裝學生的對應信息。
7-2 成績計算-2-關聯類--------題目如下：
創建成績類，包含：
屬性：平時成績（int）、期末成績（int）
方法：計算總成績（計算規則：平時成績*0.4+期末成績*0.6，保留整數部分，小數部分直接丟棄）
創建學生類，包含：
屬性：學號（String）、姓名（String）、語文成績（成績類）、數學成績（成績類）、物理成績（成績類）
方法：計算總分、計算平均分
輸入3個學生的信息，將每個學生的信息封裝在一個學生對象中。
按輸入順序依次輸出3個學生的總分、平均分（精確到小數點後兩位，捨去部分按四捨五入規則計入最後一位）。
分析：這道題涉及兩個類的創建和數據的封裝，創建一個學生類、一個成績類關聯解題
這兩道題目類圖相同：
這兩道題目對我而言難度不是很大，我寫的代碼行數也較短，在此不贅述其代碼複雜度。
在第二次作業中值得一提的是題目是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”，**是不能識別的菜名
在這裡附上我的代碼：
class Dish {
String name;
int unit_price;
public Dish(String name, int unit_price) {
this.name = name;
this.unit_price = unit_price;
}
public int getPrice(int portion) {
double price;
if (portion == 1) {
price = unit_price;
} else if (portion == 2) {
price = unit_price * 1.5;
} else if (portion == 3) {
price = unit_price * 2;
} else {
throw new IllegalArgumentException("Invalid portion: " + portion);
}
return (int) Math.round(price);
}
}
class Menu {
Dish[] dishes;
public Menu(Dish[] dishes) {
this.dishes = dishes;
}
public Dish searchDish(String dishName) {
for (Dish dish : dishes) {
if (dish.name.equals(dishName)) {
return dish;
}
}
return null;
}
}
class Record {
Dish dish;
int portion;
public Record(Dish dish, int portion) {
this.dish = dish;
this.portion = portion;
}
public int getPrice() {
return dish.getPrice(portion);
}
}
class Order {
Record[] records;
int size;
public Order(int capacity) {
records = new Record[capacity];
size = 0;
}
public void addARecord(String dishName, int portion) {
Dish dish = MenuHolder.menu.searchDish(dishName);
if (dish != null) {
Record record = new Record(dish, portion);
records[size] = record;
size++;
} else {
System.out.println(dishName + " does not exist");
}
}
public int getTotalPrice() {
int totalPrice = 0;
for (int i = 0; i < size; i++) {
totalPrice += records[i].getPrice();
}
return totalPrice;
}
}
class MenuHolder {
static Menu menu;
static {
Dish[] dishes = new Dish[4];
dishes[0] = new Dish("西紅柿炒蛋", 15);
dishes[1] = new Dish("清炒土豆絲", 12);
dishes[2] = new Dish("麻婆豆腐", 12);
dishes[3] = new Dish("油淋生菜", 9);
menu = new Menu(dishes);
}
}
public class Main {
public static void main(String[] args) {
Order order = new Order(10);
java.util.Scanner scanner = new java.util.Scanner(System.in);
while (true) {
String input = scanner.nextLine().trim();
if (input.equalsIgnoreCase("end")) {
break;
}
String[] parts = input.split(" ");
if (parts.length == 2) {
String dishName = parts[0];
int portion = Integer.parseInt(parts[1]);
order.addARecord(dishName, portion);
} else {
System.out.println(input);
}
}
System.out.println( order.getTotalPrice());
scanner.close();
}
}
用power designer生成類圖如下：
用source monitor 分析代碼結果如下：
分析：
1、在dish類中記錄菜名、菜品的基礎價格，以及通過用戶輸入份額來計算菜品價格的方法。
2、在menu類裡面定義了dish類的一個菜品數組來記錄該餐廳有的菜品。
3、在record類裡面記錄客人的記錄情況，每輸入一道菜品的名字和價格視為一次記錄。
4、在order類裡面，用來記錄訂單情況，定義了一個record類的數組，定義了添加記錄的方法。
5、在MenuHolder類裡面保存了現有的菜品及其基礎價格。
這道題主要難在類的關聯以及調用方法實現題目所需的功能，我在做的時候遇到了很多問題，例如對record類和order類的定義和使用方法不太清楚，故而在跟蹤調試的時候產生了很多問題，有幾個測試點的輸出跟需求不符，在經過網路查詢後，對order類的對象進行了改變，從而得出正確答案。
第三次作業：
這次作業主要著重於時間類、面向對象編程封裝數據、string類、arraylist類的應用。
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）成績平均分只取整數部分，小數部分丟棄
題目類圖如下：
我的代碼如下：
import java.text.Collator;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String information = input.nextLine();
ParseInput handle = new ParseInput();
while (!information.equals("end"))
{
handle.parseInput(information);
information = input.nextLine();
}
handle.showStudents();
handle.showCourses();
handle.showClasses();}
private static double calculateDuplication1(String input1, String input2) {
Set<Character> set1 = new HashSet<>();
Set<Character> set2 = new HashSet<>();
for (char c : input1.toCharArray()) {
if (Character.isLetterOrDigit(c)) {
set1.add(c);
}
}
for (char c : input2.toCharArray()) {
if (Character.isLetterOrDigit(c)) {
set2.add(c);
}
}
Set<Character> intersection = new HashSet<>(set1);
intersection.retainAll(set2);
double duplication = (double) intersection.size() / set1.size() * 100;
return duplication;
}
private static double calculateDuplication2(String input1, String input2) {
Set<Character> set1 = new HashSet<>();
Set<Character> set2 = new HashSet<>();
for (char c : input1.toCharArray()) {
if (Character.isLetterOrDigit(c)) {
set1.add(c);
}
}
for (char c : input2.toCharArray()) {
if (Character.isLetterOrDigit(c)) {
set2.add(c);
}
}
Set<Character> intersection = new HashSet<>(set1);
intersection.retainAll(set2);
double duplication = (double) intersection.size() / set1.size() * 100;
return duplication;
}
}
class ParseInput {
ArrayList<Student> listStudent = new ArrayList<>();
ArrayList<Course> listCourse = new ArrayList<>();
ArrayList<Class> listClass = new ArrayList<>();
ArrayList<ChooseCourse> listChooseCourse = new ArrayList<>();
public void parseInput(String str){
InputMatching mat=new InputMatching();
int flag=mat.matchingInput(str);
switch (flag){
case 0:System.out.println("wrong format");
break;
//課程信息
case 1:courseMessage(str);
break;
//成績信息
case 2:gradeMessage(str);
break;
}
}
private static String readInput(Scanner scanner) {
StringBuilder sb = new StringBuilder();
String line;
while (!(line = scanner.nextLine()).equals("end")) {
sb.append(line);
sb.append(System.lineSeparator());
}
return sb.toString();
}
private static double calculateDuplication(String input1, String input2) {
Set<Character> set1 = new HashSet<>();
Set<Character> set2 = new HashSet<>();
for (char c : input1.toCharArray()) {
if (Character.isLetterOrDigit(c)) {
set1.add(c);
}
}
for (char c : input2.toCharArray()) {
if (Character.isLetterOrDigit(c)) {
set2.add(c);
}
}
Set<Character> intersection = new HashSet<>(set1);
intersection.retainAll(set2);
double duplication = (double) intersection.size() / set1.size() * 100;
return duplication;
}
public void courseMessage(String str) {
String letters[] = str.split(" ");
String courseName = letters[0];
String type = letters[1];
String testType = letters[2];
Course course = new Course(courseName, type, testType);
if (checkCourse(course)) {
if (searchCourse(courseName) == null)
listCourse.add(course);
}
}
public void gradeMessage(String str) {
String letters[] = str.split(" ");
String stuId = letters[0];
String classID = letters[0].substring(0, 6);
String name = letters[1];
String courseName = letters[2];
if (searchClass(classID) == null) {
Class cla = new Class(classID);
listClass.add(cla);
}
Student stu = new Student(classID, stuId, name);
if (!searchStudent(stuId))
listStudent.add(stu);//將學生加入列表中
//課程是否存在
if (searchCourse(courseName) == null) {
System.out.println(courseName + " " + "does not exist");
}
//當課程存在時
else if (searchCourse(courseName) != null) {
Course course = searchCourse(courseName);
//考察
if (letters.length == 4 && course.testType.equals("考察")) {
int finalGrade = Integer.parseInt(letters[3]);
AssessGrade assessGrade = new AssessGrade(finalGrade);
ChooseCourse chooseCourse = new ChooseCourse(course, stu, assessGrade);
if (!searchChooseCourse(name, courseName))
listChooseCourse.add(chooseCourse);
}
//考試
else if (letters.length == 5 && course.testType.equals("考試")) {
int usualGrade = Integer.parseInt(letters[3]);
int finalGrade = Integer.parseInt(letters[4]);
ExamGrade examGrade = new ExamGrade(usualGrade, finalGrade);
ChooseCourse chooseCourse = new ChooseCourse(course, stu, examGrade);
listChooseCourse.add(chooseCourse);
} else {
System.out.println(stuId + " " + name + " " + ": access mode mismatch");
}
}
}
public boolean checkCourse(Course course) {
int flag1, flag2;
switch (course.getType()) {
case "必修":
flag1 = 0;
break;
case "選修":
flag1 = 1;
break;
default:
flag1 = -1;
break;
}
switch (course.getTestType()) {
case "考試":
flag2 = 0;
break;
case "考察":
flag2 = 1;
break;
default:
flag2 = -1;
break;
}
if (flag1 == 0 && flag2 == 0)
return true;
if (flag1 == 1 && (flag2 == 0 || flag2 == 1))
return true;
System.out.println(course.getCourseName() + " : course type & access mode mismatch");
return false;
}
public Class searchClass(String classId) {
for (Class cls : listClass) {
if (cls.getClassId().equals(classId))
return cls;
}
return null;
}
public Course searchCourse(String name) {
for (Course course : listCourse) {
if (course.getCourseName().equals(name))
return course;
}
return null;
}
public boolean searchStudent(String id) {
for (Student stu : listStudent) {
if (stu.getId().equals(id))
return true;
}
return false;
}
//查找是否有重覆選課成績
public boolean searchChooseCourse(String stuName, String courseName) {
for (ChooseCourse cs : listChooseCourse) {
if (cs.student.getStuName().equals(stuName) && cs.course.getCourseName().equals(courseName))
return true;
}
return false;
}
public void showStudents() {
Collections.sort(listStudent);
for (int i = 0; i < listStudent.size(); i++) {
Student stu = listStudent.get(i);
//從總選課表listChooseCourse中獲取該生的選課記錄
ArrayList<ChooseCourse> stuCourseSelects = getStudentSelects(stu.getId());
if (stuCourseSelects.size() != 0) {
System.out.println(stu.getId() + " " + stu.getStuName() + " " + getAvgTotalScore(stuCourseSelects));
} else if (stuCourseSelects.size() == 0) {
System.out.println(stu.getId() + " " + stu.getStuName() + " " + "did not take any exams");
}
}
}
public void showCourses() {
Collections.sort(listCourse);
for (int i = 0; i < listCourse.size(); i++) {
Course course = listCourse.get(i);
ArrayList<ChooseCourse> stuCourseSelects = getCourseSelects(course.getCourseName());
if (stuCourseSelects.size() != 0) {
if (course.testType.equals("考試"))
System.out.println(course.getCourseName() + " " + getAvgUsualScore(stuCourseSelects) + " " + getAvgFinalScore(stuCourseSelects) + " " + getAvgTotalScore(stuCourseSelects));
if (course.testType.equals("考察"))
System.out.println(course.getCourseName() + " " + getAvgFinalScore(stuCourseSelects) + " " + getAvgTotalScore(stuCourseSelects));
} else if (stuCourseSelects.size() == 0) {
System.out.println(course.courseName + " " + "has no grades yet");
}
}
}
public void showClasses() {
Collections.sort(listClass);
for (int i = 0; i < listClass.size(); i++) {
Class cls = listClass.get(i);
ArrayList<ChooseCourse> stuCourseSelects = getClassSelects(cls.getClassId());
if (stuCourseSelects.size() != 0) {
System.out.println(cls.getClassId() + " " + getAvgTotalScore(stuCourseSelects));
} else if (stuCourseSelects.size() == 0) {
System.out.println(cls.getClassId() + " " + "has no grades yet");
}
}
}
public ArrayList<ChooseCourse> getStudentSelects(String id) {
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse cos : listChooseCourse) {
if (cos.student.getId().equals(id))
choose.add(cos);
}
return choose;
}
public ArrayList<ChooseCourse> getCourseSelects(String courseName) {
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse cos : listChooseCourse) {
if (cos.course.getCourseName().equals(courseName))
choose.add(cos);
}
return choose;
}
public ArrayList<ChooseCourse> getClassSelects(String clsId) {
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse cos : listChooseCourse) {
if (cos.student.getClsId().equals(clsId))
choose.add(cos);
}
return choose;
}
public int getAvgFinalScore(ArrayList<ChooseCourse> cs) {
int average = 0;
int sum = 0;
for (ChooseCourse c : cs) {
sum += c.grade.finalGrade;
}
average = sum / cs.size();
return average;
}
}
class ChooseCourse {
Course course;
Student student;
Grade grade;
public ChooseCourse(Course course, Student student, Grade grade) {
this.course = course;
this.student = student;
this.grade = grade;
}
}
class Student implements Comparable<Student> {
String stuName;
String id;
String clsId;
public String getId() {
return id;
}
public String getStuName() {
return stuName;
}
public String getClsId() {
return clsId;
}
public Student(String clsId, String id, String stuName) {
this.clsId = clsId;
this.id = id;
this.stuName = stuName;
}
public int compareTo(Student stu) {
return getId().compareTo(stu.getId());
}
}
class Course implements Comparable<Course> {
String courseName;
String type;
String testType;
public Course() {
}
public Course(String courseName, String type, String testType) {
this.courseName = courseName;
this.type = type;
this.testType = testType;
}
public String getCourseName() {
return courseName;
}
public String getType() {
return type;
}
public String getTestType() {
return testType;
}
}
}
class Class implements Comparable<Class> {
String classId;
public Class() {
}
public String getClassId() {
return classId;
}
public Class(String classId) {
this.classId = classId;
}
@Override
public int compareTo(Class o) {
return getClassId().compareTo(o.getClassId());
}
}
abstract class Grade {
int finalGrade;
public Grade() {
}
public abstract int getUsualGrade();
public abstract int getTotalGrade();
}
class ExamGrade extends Grade {
int usualGrade;
public ExamGrade(int usualGrade, int finalGrade) {
this.usualGrade = usualGrade;
this.finalGrade = finalGrade;
}
public int getUsualGrade() {
return usualGrade;
}
public int getFinalGrade() {
return 0;
}
public int getTotalGrade() {
return (int) (usualGrade * 0.3 + finalGrade * 0.7);
}
}
class InputMatching {
static String stuNumMatching = "[0-9]{8}";
static String stuNameMatching = "\\S{1,10}";
static String scoreMatching = "([1-9]?[0-9]|100)";
static String courseNameMatching = "\\S{1,10}";
static String courseTypeMatching = "(選修|必修)";
static String checkCourseTypeMatching = "(考試|考察)";
static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;
static String scoreInput1 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching;
static String scoreInput2 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching + " " + scoreMatching;
public InputMatching() {
}
public int matchingInput(String s) {
if (matchingCourse(s))
return 1;
if (matchingScore(s))
return 2;
return 0;
}
private static boolean matchingCourse(String s) {
return s.matches(courseInput);
}
private static boolean matchingScore(String s) {
if (s.matches(scoreInput1) || s.matches(scoreInput2))
return true;
return false;
}
}
class AssessGrade extends Grade {
public AssessGrade(int finalGrade) {
this.finalGrade = finalGrade;
}
public int getFinalGrade() {
return finalGrade;
}
@Override
public int getUsualGrade() {
return 0;
}
public int getTotalGrade() {
return finalGrade;
}
}
用SourceMonito分析代碼所得結果如下：
分析：在這道題目中用了Arraylist容器來儲存學生類對象和成績類對象，併在其他的類中調用該容器中的對象數據，student類中儲存學生的有關信息，score類中儲存課程信息。
三、踩坑心得：
在這三次作業的解答過程中我遇到了很多問題，現總結如下：
1、在處理判斷等腰直角三角形時，一直沒有那種近似的轉換思想，導致在這個問題上卡了很久，我現在知道該在對應的情況採取最合適的演算法來獲取正確答案。
2、在對字元輸入以及字元多餘空格的處理，我不夠熟練，有兩道題目就是因為字元串後的空格多餘而導致測試點始終過不了，我現在學會了用trim（）來消除輸入時的多餘空格，熟練掌握了string類的應用，掌握了string類的很多方法來使字元串符合需求。
3、在創建類時，對於有參構造和無參構造的把握不夠熟練，在面向對象數據封裝那個題目就遇到了卡殼，最後通過查閱資料。才對他們的應用和區別得以區分。
3、在類的關聯以及類之間的相互調用不夠清晰，在處理菜單計價問題以及學生成績問題時，在哪一個類的屬性和對象的調用不夠清楚，經常存在數據類型和數據定義不批撇而導致報錯的情況，例如在order類封裝的是record類的對象，但是上面總是用string類的方法來調用他，得益於idea這款軟體的調試功能才得以解決報錯問題，但是最後還是沒有能完成這道題目，很多測試點沒有能夠通過，關於這道題目代碼我還會繼續修改。
四、困難及改進建議：
在完成第三次作業時，我明顯感到有些力不從心，對於如何處理輸入的一大段字元串，將其轉化為我所需的內容，這一點需要很多其他類的知識，我還不夠熟練，在7-2 課程成績統計程式-1這道題目裡面體現的尤為明顯，我採用的方法只能通過幾個例子，可能只是幾個普通的例子，但在異常情況以及邊緣情況時考慮不夠完善，並且我寫的代碼很複雜，ifelse語句太多、太冗餘了，導致代碼的圈複雜度很高，代碼利用率低，在解題時只想著能夠通過測試點，卻並未考慮到代碼的複雜度和復用性。
改進建議：我認為可以適當降低難題和複雜的題目的分數，如在第三次作業中占65分的第二道題，如果對這道題目束手無策，就算其他的題目都滿分通過，這次作業也難以及格，所以我認為可以把難題作為優秀學生的挑戰性嘗試，適當提高平均分。
五、總結：
通過完成這三次pta的作業，我對面向對象的基本過程和知識有了一定的瞭解，我掌握了類的構建，如何查詢java自帶的API的應用，常用API的使用，正則表達式的的使用。在一道一道解決題目的過程中，我感受到了面向對象和麵向過程的編程的區別，感受到了面向對象編程在優化代碼結構，排除冗餘代碼塊的方面所具有的巨大作用，並對其產生了更加濃厚的i興趣和更加深入的瞭解。作為沒有接觸過面向對象的新人，在一開始的解題過程中，我還是偏向於C語言式的面向過程，慢慢轉變到面向對象，這個過程不快，導致我有一道題目並未完美解決，在未來我依然會努力加深java的代碼量，對面向對象編程的熟悉。
