수강생 과목 점수 관리 프로그램 프로젝트
캠프에는 필수 과목과 선택이 존재
- 조건
- 최소 3개 이상의 필수 과목, 2개 이상의 선택 과목을 선택합니다.
- 캠프 기간동안 선택한 과목별로 총 10회의 시험을 봅니다.
- 캠프 매니저는 수강생을 등록 및 관리할 수 있습니다.
- 캠프 매니저는 수강생들의 과목과 시험 점수를 등록 및 관리할 수 있습니다.
- 점수 데이터 타입 : 정수형
- 점수에 따라 등급이 매겨집니다.
- 과목: Java1회차 2회차 3회차 …
D D B … - 등급 산정 기준
- 필수 과목A B C D F N
95 ~ 100 90 ~ 94 80 ~ 89 70 ~ 79 60 ~ 69 60점 미만 - 선택 과목A B C D F N
90 ~ 100 80 ~ 89 70 ~ 79 60 ~ 69 50 ~ 59 50점 미만
- 필수 과목A B C D F N
- 모델 정보 예시수강생
점수고유 번호 이름 과목 목록
과목과목 고유 번호 수강생 고유 번호 회차 점수 등급 (A, B, C, D, E, F, N) 고유 번호 과목명 과목타입 (필수, 선택)
필수 요구 사항
수강생의 고유번호는 중복불가!
1. 수강생의 정보 등록 가능
| 등록 필수 정보 |
| 고유 번호 |
| 이름 |
| 과목 목록 |
2. 수강생 목록 조회 가능
| 조회 필수 정보 |
| 고유 번호 |
| 이름 |
점수 관리
- 등록하려는 과목의 회차 점수가 이미 등록되어 있다면 등록할 수 없습니다. 과목의 회차 점수가 중복되어 등록될 수 없습니다.
- 회차에 10 초과 및 1 미만의 수가 저장될 수 없습니다. (회차 범위: 1 ~ 10)
- 점수에 100 초과 및 음수가 저장될 수 없습니다. (점수 범위: 0 ~ 100)
- 수강생의 과목별 시험 회차 및 점수를 등록할 수 있습니다.
- 점수를 등록하면 자동으로 등급이 추가 저장됩니다.
- 수강생의 과목별 회차 점수를 수정할 수 있습니다.
- 수강생의 특정 과목 회차별 등급을 조회할 수 있습니다.
수강생 관리
1. 수강생 상채를 관리할 수 있다.
| 상태 종류 |
| Green |
| Red |
| Yellow |
2. 수강생 정보 조회가능
| 조회 필수 정보 |
| 고유 번호 |
| 이름 |
| 상태 |
| 선택한 과목명 |
3. 수강생 정보 수정 가능
이름 또는 상태를 받아 수정 가능
| 수정 가능한 정보 |
| 고유 번호 |
| 이름 |
4. 상태별로 수강생 목록 조회가능
| 조회 필수 정보 |
| 고유 번호 |
| 이름 |
5. 수강생 목록 삭제 가능
1. 수강생의 과목별 평균 등급 조회 가능
| 조회 필수 정보 |
| 과목명 |
| 평균 등급 |
이번 프로젝트의 의미는 자바에 대해 더 친숙해지고 자바의 꽃인 객체를 다루기 위한 연습을 하라는 의미이니 객체를 여러군데 나누고 패키지 또한 클래스의 속성에 맞게 분류를 해놓았다. (아마 내일 시간적 여유가 좀 있다면 인터페이스를 적용시킬 예정이다.)
그리고 우리팀은 점수나 과목, 수강생 명단을 불러올때 List를 사용하는게 아닌 Map을 사용하였다. 그 이유는
1.고유 식별자 기반 접근
Map을 사용하면 고유 식별자(key)를 통해 데이터에 빠르게 접근할 수 있습니다. 이는 데이터를 조회하거나 수정할 때 매우 효율적입니다. 예를 들어:
- 학생 정보: studentStore는 Map<String, Student> 형태로 되어 있어, 학생 ID(String)를 사용하여 해당 학생의 정보를 직접 찾을 수 있습니다. 학생 ID를 키로 사용하면 학생 정보를 매우 빠르게 조회할 수 있습니다.
- 과목 정보: subjectStore도 Map<String, Subject> 형태로 되어 있어, 과목 ID를 통해 과목 정보를 신속하게 접근할 수 있습니다.
- 점수 정보: scoreStore는 Map<String, Map<String, Score>> 형태로 되어 있습니다. 학생 ID를 통해 해당 학생의 점수 맵을 찾고, 그 안에서 과목 ID를 통해 특정 과목의 점수를 조회할 수 있습니다.
2. 중복 방지 및 유일성 보장
Map은 키-값 쌍으로 구성되어 있기 때문에 각 키는 유일해야 합니다. 이를 통해 데이터의 중복을 방지할 수 있습니다:
- 학생 ID: 학생 ID는 유일해야 하며, Map을 사용하면 중복된 학생 ID가 저장되지 않도록 보장할 수 있습니다.
- 과목 ID: 과목 ID 역시 유일해야 하며, Map을 사용하면 동일한 과목 ID를 가진 두 개의 과목이 저장되지 않도록 할 수 있습니다.
3. 효율적인 데이터 조회 및 수정
Map은 데이터의 조회와 수정에 있어 O(1)의 시간 복잡도를 가지므로, 데이터의 접근이 매우 빠릅니다:
- 학생 정보 조회: 특정 학생 ID로 학생 정보를 조회할 때, Map을 사용하면 해당 ID의 학생 정보를 즉시 가져올 수 있습니다.
- 점수 수정: 점수 수정 시에도 학생 ID와 과목 ID를 사용하여 Map을 통해 직접 접근할 수 있습니다.
4. 유연한 데이터 구조
Map을 사용하면 다양한 데이터 구조를 손쉽게 다룰 수 있습니다:
- 중첩된 데이터: scoreStore는 학생 ID를 키로 하여, 각 학생의 점수를 저장하는 또 다른 Map을 값으로 가집니다. 이 중첩된 구조를 통해 학생별, 과목별 점수를 관리할 수 있습니다.
- 다양한 조회 방식: 학생 ID와 과목 ID를 통해 점수를 조회할 수 있으며, 이 구조는 점수 기록을 체계적으로 관리하고 접근할 수 있게 해줍니다.
간단히 요약하면....
Map은 고유 식별자를 기반으로 데이터에 빠르게 접근할 수 있게 해주며, 중복 방지와 유일성 보장을 통해 데이터의 일관성을 유지합니다. 또한, 효율적인 조회와 수정, 유연한 데이터 구조를 제공하므로, 학생 정보, 과목 정보, 점수 정보를 효과적으로 관리할 수 있습니다. List는 순서가 중요하거나 인덱스 기반 접근이 필요한 경우에 적합하지만, 고유 식별자 기반의 빠른 접근이 필요한 경우 Map이 더 적합합니다.
아직 최종적인 코드는 아니지만 현 코드 상황에 대해 각 패키지, 클래스, 필드, 메서드, 생성자에 대해 자세 설명하고자 한다.
package camp.studentManagement
CampManagementApplication(Main class).class
이 클래스의 주요 기능은 수강생 관리와 점수 관리, 그리고 메인 메뉴의 UI를 제공한다
package camp;
import camp.model.Student;
import camp.scoreManagement.MainScoreManagement;
import camp.studentManagement.MainStudentManagement;
import java.util.*;
import static camp.storeManagement.Stores.*;
// UI관련 Field & Method
public class CampManagementApplication {
// 스캐너
public static Scanner sc = new Scanner(System.in); //메인에 두기
// main
public static void main(String[] args) throws InterruptedException {
setInitData();
displayMainView();
}
// 메인 메뉴
private static void displayMainView() throws InterruptedException { // 메인에 둬야함
boolean flag = true;
while (flag) {
System.out.println("\n==================================");
System.out.println("내일배움캠프 수강생 관리 프로그램 실행 중...");
System.out.println("1. 수강생 관리");
System.out.println("2. 점수 관리");
System.out.println("3. 프로그램 종료");
System.out.print("관리 항목을 선택하세요...");
int input = sc.nextInt();
switch (input) {
case 1 -> MainStudentManagement.displayStudentView(); // 수강생 관리
case 2 -> MainScoreManagement.displayScoreView(); // 점수 관리
case 3 -> flag = false; // 프로그램 종료
default -> {
System.out.println("잘못된 입력입니다.\n되돌아갑니다!");
Thread.sleep(2000);
}
}
}
System.out.println("프로그램을 종료합니다.");
}
// 전체 과목 리스트 출력 --> 김창민
public static void printSubjectInfo() {
System.out.println("===== 수강 가능한 과목 리스트 입니다. =====");
System.out.println("=======================================");
System.out.println("===== 필수 과목 =====");
System.out.println("===== 1. Java =====");
System.out.println("===== 2. 객체지향 =====");
System.out.println("===== 3. Spring =====");
System.out.println("===== 4. JPA =====");
System.out.println("===== 5. MySQL =====");
System.out.println("=======================================");
System.out.println("===== 선택 과목 =====");
System.out.println("===== 1. 디자인 패턴 =====");
System.out.println("===== 2. Spring Security =====");
System.out.println("===== 3. Redis =====");
System.out.println("===== 4. MongoDB =====");
System.out.println("=======================================");
}
// 수강생 리스트 출력 --> 김창민
public static void printStudentInfo() {
Set<String> keys = studentStore.keySet();
List<String> keyList = new ArrayList<>(keys);
Collections.sort(keyList);
System.out.println("=============수강생 리스트============");
for (String key : keyList) {
System.out.println(key + " : " + studentStore.get(key).getStudentName());
}
System.out.println("===================================");
}
// 수강생이 수강중인 과목 리스트 출력 --> 이봄
public static void printSubjectInfoByStudentId(String studentId) {
try {
Student student = studentStore.get(studentId);
ArrayList<String> keys = student.getSubjectList();
System.out.println("==============수강중인 과목==============");
for (String key : keys) {
System.out.println(key + " : " + subjectStore.get(key).getSubjectName());
}
System.out.println("=======================================");
} catch (NullPointerException e) {
System.out.println(e.getMessage());
}
}
}
스캐너 객체:
public static Scanner sc = new Scanner(System.in); // 메인에 두기
사용자로부터 입력을 받기 위해 Scanner 객체를 생성합니다. 프로그램 전체에서 이 객체를 사용하여 입력을 처리합니다.
메인 메소드:
public static void main(String[] args) throws InterruptedException {
setInitData();
displayMainView();
}
main 메소드에서는 초기 데이터를 설정하는 setInitData() 메소드와 메인 메뉴를 표시하는 displayMainView() 메소드를 호출합니다.
메인 메뉴 표시:
private static void displayMainView() throws InterruptedException {
boolean flag = true;
while (flag) {
System.out.println("\n==================================");
System.out.println("내일배움캠프 수강생 관리 프로그램 실행 중...");
System.out.println("1. 수강생 관리");
System.out.println("2. 점수 관리");
System.out.println("3. 프로그램 종료");
System.out.print("관리 항목을 선택하세요...");
int input = sc.nextInt();
switch (input) {
case 1 -> MainStudentManagement.displayStudentView(); // 수강생 관리
case 2 -> MainScoreManagement.displayScoreView(); // 점수 관리
case 3 -> flag = false; // 프로그램 종료
default -> {
System.out.println("잘못된 입력입니다.\n되돌아갑니다!");
Thread.sleep(2000);
}
}
}
System.out.println("프로그램을 종료합니다.");
}
사용자가 선택할 수 있는 메뉴를 출력하고, 입력을 처리하여 해당 기능을 실행합니다.
사용자가 1을 입력할 경우 MainStudentManagement 클래스의 displayStudentView() 메소드가 호출되어 수강생 관리 화면을 표시합니다.
2를 입력하면 MainScoreManagement 클래스의 displayScoreView() 메소드가 호출되어 점수 관리 화면을 표시합니다.
3을 입력하면 프로그램이 종료됩니다. 잘못된 입력에 대해서는 경고 메시지를 출력하고 2초간 대기합니다.
전체 과목 리스트 출력:
public static void printSubjectInfo() {
System.out.println("===== 수강 가능한 과목 리스트 입니다. =====");
System.out.println("=======================================");
System.out.println("===== 필수 과목 =====");
System.out.println("===== 1. Java =====");
System.out.println("===== 2. 객체지향 =====");
System.out.println("===== 3. Spring =====");
System.out.println("===== 4. JPA =====");
System.out.println("===== 5. MySQL =====");
System.out.println("=======================================");
System.out.println("===== 선택 과목 =====");
System.out.println("===== 1. 디자인 패턴 =====");
System.out.println("===== 2. Spring Security =====");
System.out.println("===== 3. Redis =====");
System.out.println("===== 4. MongoDB =====");
System.out.println("=======================================");
}현재 수강 가능한 과목 리스트를 출력합니다. 필수 과목과 선택 과목이 구분되어 있으며, 과목 ID와 이름을 나열합니다.
수강생 리스트 출력:
public static void printStudentInfo() {
Set<String> keys = studentStore.keySet();
List<String> keyList = new ArrayList<>(keys);
Collections.sort(keyList);
System.out.println("=============수강생 리스트============");
for (String key : keyList) {
System.out.println(key + " : " + studentStore.get(key).getStudentName());
}
System.out.println("===================================");
}
현재 등록된 모든 수강생의 리스트를 출력합니다. 학생 ID를 기준으로 정렬된 후, 각 학생의 ID와 이름을 출력합니다.
수강생이 수강중인 과목 리스트 출력:
public static void printSubjectInfoByStudentId(String studentId) {
try {
Student student = studentStore.get(studentId);
ArrayList<String> keys = student.getSubjectList();
System.out.println("==============수강중인 과목==============");
for (String key : keys) {
System.out.println(key + " : " + subjectStore.get(key).getSubjectName());
}
System.out.println("=======================================");
} catch (NullPointerException e) {
System.out.println(e.getMessage());
}
}
특정 학생 ID를 입력받아 해당 학생이 수강중인 과목 리스트를 출력합니다. 학생의 수강 과목 리스트를 가져와 과목 ID와 이름을 출력합니다. 학생 ID가 존재하지 않거나 과목 정보가 없는 경우 NullPointerException이 발생할 수 있으며, 이 경우 예외 메시지를 출력합니다.
CheckStudentManagement.class
학생 관리 관련 기능을 제공하는 유틸리티 클래스입니다.
package camp.studentManagement;
import camp.model.Student;
import static camp.storeManagement.Stores.studentStore;
public class CheckStudentManagement {
// 수강생 존재 검증
public static boolean checkStudentId(Student student) {
if (student == null) {
System.out.println("존재하지 않는 학생입니다.");
return false;
}
return true;
}
// 중복 studentStore 검증 기능 메소드화
public static boolean checkStudentStore() {
System.out.println("\n수강생 목록을 조회합니다...");
if (studentStore.isEmpty()) {
System.out.println("수강생이 없습니다");
return false;
}
return true;
}
// 중복 Status 검증 기능 메소드화
public static boolean cheackStatus(String studentState) {
return studentState.equals("Green") || studentState.equals("Red") || studentState.equals("Yellow");
}
}
- 패키지: camp.studentManagement
- 이 코드는 camp.studentManagement 패키지에 속합니다. 패키지는 관련된 클래스를 그룹화하여 관리하는 데 사용됩니다.
- 임포트:
- import camp.model.Student;는 Student 클래스가 camp.model 패키지에 정의되어 있음을 의미합니다.
- import static camp.storeManagement.Stores.studentStore;는 studentStore 객체가 camp.storeManagement.Stores 클래스에 정의되어 있고, 이를 정적 멤버로 가져오겠다는 의미입니다.
checkStudentId 메서드
public static boolean checkStudentId(Student student) {
if (student == null) {
System.out.println("존재하지 않는 학생입니다.");
return false;
}
return true;
}
- 목적: 주어진 Student 객체가 null인지 확인하여, 학생이 존재하는지 검증합니다.
- 매개변수:
- Student student: 검증할 학생 객체입니다.
- 반환값:
- boolean: 학생이 null이 아닌 경우 true, 그렇지 않으면 false.
- 기능:
- student가 null이면 "존재하지 않는 학생입니다."라는 메시지를 출력하고 false를 반환합니다.
- student가 null이 아니면 true를 반환합니다.
checkStudentStore 메서드
public static boolean checkStudentStore() {
System.out.println("\n수강생 목록을 조회합니다...");
if (studentStore.isEmpty()) {
System.out.println("수강생이 없습니다");
return false;
}
return true;
}
- 목적: studentStore가 비어 있는지 확인합니다.
- 반환값:
- boolean: studentStore가 비어 있으면 false, 그렇지 않으면 true.
- 기능:
- studentStore가 비어 있으면 "수강생이 없습니다"라는 메시지를 출력하고 false를 반환합니다.
- studentStore에 학생이 있으면 true를 반환합니다.
cheackStatus 메서드
public static boolean cheackStatus(String studentState) {
return studentState.equals("Green") || studentState.equals("Red") || studentState.equals("Yellow");
}
- 목적: 주어진 학생 상태 문자열이 유효한 상태인지 확인합니다.
- 매개변수:
- String studentState: 검증할 학생 상태 문자열입니다.
- 반환값:
- boolean: 상태가 "Green", "Red", 또는 "Yellow" 중 하나일 때 true, 그렇지 않으면 false.
- 기능:
- studentState가 "Green", "Red", "Yellow" 중 하나와 일치하는지 확인합니다. 일치하면 true, 그렇지 않으면 false를 반환합니다.
MainStudentManangement.class
수강생 관리 및 조회 클래스
package camp.studentManagement;
import camp.model.Student;
import camp.model.Subject;
import java.util.*;
import static camp.CampManagementApplication.*;
import static camp.storeManagement.Stores.*;
import static camp.studentManagement.CheckStudentManagement.*;
import static camp.studentManagement.UpdateStudentManagement.*;
public class MainStudentManagement {
// 수강생 관리 메뉴
public static void displayStudentView() {
boolean flag = true;
while (flag) {
System.out.println("==================================");
System.out.println("수강생 관리 실행 중...");
System.out.println("1. 수강생 등록");
System.out.println("2. 수강생 목록 조회");
System.out.println("3. 수강생 정보 수정"); //추가 기능 1.
System.out.println("4. 상태별 수강생 목록 조회"); //추가 기능 2.
System.out.println("5. 수강생 삭제");
System.out.println("6. 메인 화면 이동");
System.out.print("관리 항목을 선택하세요...");
int input = sc.nextInt();
switch (input) {
case 1 -> createStudent(); // 수강생 등록
case 2 -> inquireStudent(); // 수강생 목록 조회
case 3 -> updateStudent(); // 수강생 정보 수정
case 4 -> inquireStudentByState(); // 상태별 수강생 목록 조회
case 5 -> deleteStudent(); // 수강생 삭제
case 6 -> flag = false; // 메인 화면 이동
default -> {
System.out.println("잘못된 입력입니다.\n메인 화면 이동...");
flag = false;
}
}
}
}
// 수강생 목록 조회
private static void inquireStudent() {
if (!checkStudentStore()) return;
printStudentInfo();
sc.nextLine();//개행문자 날리기
System.out.print("조회 학생의 고유번호를 입력하세요 : ");
String useKey = sc.nextLine();
Student student = studentStore.get(useKey);
if (!checkStudentId(student)) return;
ArrayList<String> viewSubject = studentStore.get(useKey).getSubjectList();//과목 아이디가 저장되어있음
ArrayList<String> viewMandatory = new ArrayList<>(); // 필수 과목 리스트
ArrayList<String> viewOptional = new ArrayList<>(); // 선택 과목 리스트
// 과목 종류 나눠서 세팅
for (String val : viewSubject) {
Subject useSubject = subjectStore.get(val);
if (useSubject.getSubjectType().equals(SUBJECT_TYPE_MANDATORY)) {
viewMandatory.add(useSubject.getSubjectName());
} else if (useSubject.getSubjectType().equals(SUBJECT_TYPE_CHOICE)) {
viewOptional.add(useSubject.getSubjectName());
}
}
System.out.println("==============검색완료===============");
System.out.println("[이름]: " + student.getStudentName() + " [번호]: " + useKey + " [상태]: " + student.getStudentState());
StringBuilder sb = new StringBuilder();
sb.append("[필수 과목] :");
for (String vM : viewMandatory) {
sb.append(vM + ", ");
}
sb.deleteCharAt(sb.length() - 1);// 공백 삭제
sb.deleteCharAt(sb.length() - 1);// , 삭제
sb.append("\n");
sb.append("[선택 과목] :");
for (String vO : viewOptional) {
sb.append(vO + ", ");
}
sb.deleteCharAt(sb.length() - 1);// 공백 삭제
sb.deleteCharAt(sb.length() - 1);// , 삭제
System.out.println(sb.toString());
}
// 상태별 수강생 조회
private static void inquireStudentByState() {
if (!checkStudentStore()) return;
Set<String> keys = studentStore.keySet();
List<String> keyList = new ArrayList<>(keys);
Collections.sort(keyList);
ArrayList<Student> greenStu = new ArrayList<>();
ArrayList<Student> redStu = new ArrayList<>();
ArrayList<Student> yellowStu = new ArrayList<>();
for (String key : keyList) {
if (studentStore.get(key).getStudentState().equals("Green")) {
greenStu.add(studentStore.get(key));
} else if (studentStore.get(key).getStudentState().equals("Red")) {
redStu.add(studentStore.get(key));
} else {
yellowStu.add(studentStore.get(key));
}
}
System.out.println("====Green 상태 학생====");
printInquireStudentByState(greenStu);
System.out.println();
System.out.println("====Red 상태 학생====");
printInquireStudentByState(redStu);
System.out.println();
System.out.println("====Yellow 상태 학생====");
printInquireStudentByState(yellowStu);
System.out.println();
}
// 중복 출력 기능 메소드화
private static void printInquireStudentByState(ArrayList<Student> stu) {
for (Student std : stu) {
System.out.println(std.getStudentId() + " : " + std.getStudentName());
}
}
}
displayStudentView 메소드
public static void displayStudentView() {
boolean flag = true;
while (flag) {
System.out.println("==================================");
System.out.println("수강생 관리 실행 중...");
System.out.println("1. 수강생 등록");
System.out.println("2. 수강생 목록 조회");
System.out.println("3. 수강생 정보 수정"); //추가 기능 1.
System.out.println("4. 상태별 수강생 목록 조회"); //추가 기능 2.
System.out.println("5. 수강생 삭제");
System.out.println("6. 메인 화면 이동");
System.out.print("관리 항목을 선택하세요...");
int input = sc.nextInt();
switch (input) {
case 1 -> createStudent(); // 수강생 등록
case 2 -> inquireStudent(); // 수강생 목록 조회
case 3 -> updateStudent(); // 수강생 정보 수정
case 4 -> inquireStudentByState(); // 상태별 수강생 목록 조회
case 5 -> deleteStudent(); // 수강생 삭제
case 6 -> flag = false; // 메인 화면 이동
default -> {
System.out.println("잘못된 입력입니다.\n메인 화면 이동...");
flag = false;
}
}
}
}
- 목적: 학생 관리 메뉴를 사용자에게 제공하고, 사용자의 입력에 따라 적절한 기능을 호출합니다.
- 기능:
- 사용자가 메뉴에서 옵션을 선택하면 switch 문을 통해 해당 기능을 실행합니다.
- flag 변수를 사용하여 사용자가 메뉴를 선택할 때까지 반복적으로 메뉴를 표시합니다.
inquireStudent 메소드
private static void inquireStudent() {
if (!checkStudentStore()) return;
printStudentInfo();
sc.nextLine();//개행문자 날리기
System.out.print("조회 학생의 고유번호를 입력하세요 : ");
String useKey = sc.nextLine();
Student student = studentStore.get(useKey);
if (!checkStudentId(student)) return;
ArrayList<String> viewSubject = studentStore.get(useKey).getSubjectList();//과목 아이디가 저장되어있음
ArrayList<String> viewMandatory = new ArrayList<>(); // 필수 과목 리스트
ArrayList<String> viewOptional = new ArrayList<>(); // 선택 과목 리스트
// 과목 종류 나눠서 세팅
for (String val : viewSubject) {
Subject useSubject = subjectStore.get(val);
if (useSubject.getSubjectType().equals(SUBJECT_TYPE_MANDATORY)) {
viewMandatory.add(useSubject.getSubjectName());
} else if (useSubject.getSubjectType().equals(SUBJECT_TYPE_CHOICE)) {
viewOptional.add(useSubject.getSubjectName());
}
}
System.out.println("==============검색완료===============");
System.out.println("[이름]: " + student.getStudentName() + " [번호]: " + useKey + " [상태]: " + student.getStudentState());
StringBuilder sb = new StringBuilder();
sb.append("[필수 과목] :");
for (String vM : viewMandatory) {
sb.append(vM + ", ");
}
sb.deleteCharAt(sb.length() - 1);// 공백 삭제
sb.deleteCharAt(sb.length() - 1);// , 삭제
sb.append("\n");
sb.append("[선택 과목] :");
for (String vO : viewOptional) {
sb.append(vO + ", ");
}
sb.deleteCharAt(sb.length() - 1);// 공백 삭제
sb.deleteCharAt(sb.length() - 1);// , 삭제
System.out.println(sb.toString());
}
- 목적: 상태별로 학생 목록을 조회하고 출력합니다.
- 기능:
- checkStudentStore()를 호출하여 학생 저장소에 학생이 있는지 확인합니다.
- 학생의 상태에 따라 학생 목록을 greenStu, redStu, yellowStu로 분류합니다.
- 각 상태별 학생 목록을 출력합니다.
printInquireStudentByState 메소드
private static void printInquireStudentByState(ArrayList<Student> stu) {
for (Student std : stu) {
System.out.println(std.getStudentId() + " : " + std.getStudentName());
}
}
- 목적: 중복 출력 기능 메서드
- 매개변수:
- ArrayList<Student> stu: 출력할 학생 목록입니다.
- 기능:
- 학생의 ID와 이름을 출력합니다.
UpdateStudentManagement.class
수강생의 등록, 정보 수정, 삭제를 담당하며, 과목 정보를 저장하는 기능도 제공한다
package camp.studentManagement;
import camp.CampManagementApplication;
import camp.model.Student;
import camp.model.Subject;
import java.util.*;
import static camp.CampManagementApplication.*;
import static camp.storeManagement.Stores.*;
import static camp.studentManagement.CheckStudentManagement.*;
public class UpdateStudentManagement {
// 수강생 등록
public static void createStudent() {
String studentName;
String studentId;
String studentState;
ArrayList<String> getSubject = new ArrayList<>(); //수강하는 과목코드를 저장할 리스트
// 수강생 이름 등록, 이름 길이가 10이 넘으면 예외처리
System.out.println("\n수강생을 등록합니다...");
try {
System.out.print("수강생 이름 입력: ");
studentName = sc.next(); //이름
if (studentName.length() > 10)
throw (new Exception("이름이 너무 깁니다."));
} catch (Exception e) {
System.out.println(e.getMessage());
return;
}
// 상태 저장
try {
System.out.print("수강생 상태 입력(Green,Red,Yellow): ");
studentState = sc.next();
if (!cheackStatus(studentState)) throw new IllegalArgumentException("올바른 상태가 아닙니다");
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
return;
}
// 과목 입력
CampManagementApplication.printSubjectInfo();//과목 출력
sc.nextLine(); //개행문자 날리기
/*필수 과목 받기*/
System.out.println("수강하실 필수 과목의 번호를 입력해 주세요 (필수 : 3개 이상)(띄어쓰기로 구분)");
String[] mandatorySubjects = sc.nextLine().split(" ");
Set<String> mandatorySet = new HashSet<>(Arrays.asList(mandatorySubjects));
try {
int mandatorySize = mandatorySet.size();
if (mandatorySize < 3) throw new IllegalArgumentException("필수 과목 개수가 부족합니다.");
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
return;
}
/*선택 과목 받기*/
System.out.println("수강하실 선택 과목의 번호를 입력해 주세요 (선택 : 2개 이상)(띄어쓰기로 구분)");
String[] optionalSubjects = sc.nextLine().split(" ");
Set<String> optionalSet = new HashSet<>(Arrays.asList(optionalSubjects));
try {
int optionalSize = optionalSet.size();
if (optionalSize < 2) throw new IllegalArgumentException("선택 과목 개수가 부족합니다.");
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
return;
}
//필수 과목 저장
for (String val : mandatorySet) {
val = INDEX_TYPE_SUBJECT + val;
makeSubject(val, getSubject, SUBJECT_TYPE_MANDATORY);
}
//선택 과목 저장
for (String val : optionalSet) {
int useVal = Integer.parseInt(val) + 5;
val = INDEX_TYPE_SUBJECT + useVal;
makeSubject(val, getSubject, SUBJECT_TYPE_CHOICE);
}
studentId = sequence(INDEX_TYPE_STUDENT); //고유번호
Student student = new Student(studentId, studentName, studentState, getSubject); //이름이랑 과목코드 리스트를 담은 객체 생성
studentStore.put(studentId, student); //맵에 저장
System.out.println("수강생 등록 성공!\n");
}
// 수강생 정보 수정
static void updateStudent() {
if (!checkStudentStore()) return;
printStudentInfo(); // 기능 구현
sc.nextLine();// 개행문자 날리기
System.out.print("조회 학생의 고유번호를 입력하세요 : ");
String useKey = sc.nextLine();
Student student = studentStore.get(useKey);
if (!checkStudentId(student)) return;
System.out.println("====[현재 정보]====");
System.out.println("[이름]: " + student.getStudentName() + "\n[상태]: " + student.getStudentState());
System.out.println("====[덮어씌울 정보]====\n이름과 상태 순으로 입력하세요\n(상태: Green,Red,Yellow)(띄어쓰기 구분): ");
String[] newNameAndState = new String[2];
try {
newNameAndState = sc.nextLine().split(" ");
if (newNameAndState.length != 2) {
throw new IllegalArgumentException("이름과 상태를 모두 입력해야 합니다.");
}
if (!cheackStatus(newNameAndState[1])) {
throw new IllegalArgumentException("올바른 상태가 아닙니다.");
}
if (newNameAndState[0].length() > 10) {
throw new IllegalArgumentException("이름이 너무 깁니다.");
}
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
return;
}
student.setStudentName(newNameAndState[0]);
student.setStudentState(newNameAndState[1]);
System.out.println("====[업데이트 된 정보]====\n");
System.out.println("[이름]: " + student.getStudentName() + "\n[상태]: " + student.getStudentState());
System.out.println("====업데이트 완료====");
}
// 수강생 삭제
static void deleteStudent() {
if (!checkStudentStore()) return;
printStudentInfo(); // 기능 구현
sc.nextLine();//개행문자 날리기
System.out.print("삭제 학생의 고유번호를 입력하세요 : ");
String useKey = sc.nextLine();
Student student = studentStore.get(useKey);
if (!checkStudentId(student)) return;
studentStore.remove(useKey);
if (!studentStore.containsKey(useKey))
System.out.println("삭제 완료되었습니다.");
}
// 중복 Subject 저장 기능 메소드화
private static void makeSubject(String val, ArrayList<String> getSubject, String type) {
Subject useSubject = subjectStore.get(val);
if (!useSubject.getSubjectType().equals(type)) //타 과목시 예외처리
throw new IllegalArgumentException();
getSubject.add(val);
}
}
createStudent 메소드
public static void createStudent() {
String studentName;
String studentId;
String studentState;
ArrayList<String> getSubject = new ArrayList<>(); //수강하는 과목코드를 저장할 리스트
// 수강생 이름 등록, 이름 길이가 10이 넘으면 예외처리
System.out.println("\n수강생을 등록합니다...");
try {
System.out.print("수강생 이름 입력: ");
studentName = sc.next(); //이름
if (studentName.length() > 10)
throw (new Exception("이름이 너무 깁니다."));
} catch (Exception e) {
System.out.println(e.getMessage());
return;
}
// 상태 저장
try {
System.out.print("수강생 상태 입력(Green,Red,Yellow): ");
studentState = sc.next();
if (!cheackStatus(studentState)) throw new IllegalArgumentException("올바른 상태가 아닙니다");
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
return;
}
// 과목 입력
CampManagementApplication.printSubjectInfo();//과목 출력
sc.nextLine(); //개행문자 날리기
/*필수 과목 받기*/
System.out.println("수강하실 필수 과목의 번호를 입력해 주세요 (필수 : 3개 이상)(띄어쓰기로 구분)");
String[] mandatorySubjects = sc.nextLine().split(" ");
Set<String> mandatorySet = new HashSet<>(Arrays.asList(mandatorySubjects));
try {
int mandatorySize = mandatorySet.size();
if (mandatorySize < 3) throw new IllegalArgumentException("필수 과목 개수가 부족합니다.");
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
return;
}
/*선택 과목 받기*/
System.out.println("수강하실 선택 과목의 번호를 입력해 주세요 (선택 : 2개 이상)(띄어쓰기로 구분)");
String[] optionalSubjects = sc.nextLine().split(" ");
Set<String> optionalSet = new HashSet<>(Arrays.asList(optionalSubjects));
try {
int optionalSize = optionalSet.size();
if (optionalSize < 2) throw new IllegalArgumentException("선택 과목 개수가 부족합니다.");
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
return;
}
//필수 과목 저장
for (String val : mandatorySet) {
val = INDEX_TYPE_SUBJECT + val;
makeSubject(val, getSubject, SUBJECT_TYPE_MANDATORY);
}
//선택 과목 저장
for (String val : optionalSet) {
int useVal = Integer.parseInt(val) + 5;
val = INDEX_TYPE_SUBJECT + useVal;
makeSubject(val, getSubject, SUBJECT_TYPE_CHOICE);
}
studentId = sequence(INDEX_TYPE_STUDENT); //고유번호
Student student = new Student(studentId, studentName, studentState, getSubject); //이름이랑 과목코드 리스트를 담은 객체 생성
studentStore.put(studentId, student); //맵에 저장
System.out.println("수강생 등록 성공!\n");
}
- 목적: 새로운 수강생을 등록합니다.
- 기능:
- 수강생 이름, 상태, 필수 과목, 선택 과목을 입력받아 검증합니다.
- 과목은 필수 과목과 선택 과목으로 나누어 처리합니다.
- makeSubject 메소드를 호출하여 과목 정보를 리스트에 추가합니다.
- 학생 ID를 생성하고 Student 객체를 생성하여 studentStore에 저장합니다.
updateStudent 메소드
static void updateStudent() {
if (!checkStudentStore()) return;
printStudentInfo(); // 기능 구현
sc.nextLine();// 개행문자 날리기
System.out.print("조회 학생의 고유번호를 입력하세요 : ");
String useKey = sc.nextLine();
Student student = studentStore.get(useKey);
if (!checkStudentId(student)) return;
System.out.println("====[현재 정보]====");
System.out.println("[이름]: " + student.getStudentName() + "\n[상태]: " + student.getStudentState());
System.out.println("====[덮어씌울 정보]====\n이름과 상태 순으로 입력하세요\n(상태: Green,Red,Yellow)(띄어쓰기 구분): ");
String[] newNameAndState = new String[2];
try {
newNameAndState = sc.nextLine().split(" ");
if (newNameAndState.length != 2) {
throw new IllegalArgumentException("이름과 상태를 모두 입력해야 합니다.");
}
if (!cheackStatus(newNameAndState[1])) {
throw new IllegalArgumentException("올바른 상태가 아닙니다.");
}
if (newNameAndState[0].length() > 10) {
throw new IllegalArgumentException("이름이 너무 깁니다.");
}
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
return;
}
student.setStudentName(newNameAndState[0]);
student.setStudentState(newNameAndState[1]);
System.out.println("====[업데이트 된 정보]====\n");
System.out.println("[이름]: " + student.getStudentName() + "\n[상태]: " + student.getStudentState());
System.out.println("====업데이트 완료====");
}- 목적: 기존 수강생의 정보를 수정합니다.
- 기능:
- 수강생 ID를 입력받아 해당 학생 정보를 조회합니다.
- 현재 정보를 출력하고, 새 정보를 입력받아 검증 후 업데이트합니다.
- 이름과 상태의 길이 및 값이 올바른지 검증합니다.
deleteStudent 메소드
static void deleteStudent() {
if (!checkStudentStore()) return;
printStudentInfo(); // 기능 구현
sc.nextLine();//개행문자 날리기
System.out.print("삭제 학생의 고유번호를 입력하세요 : ");
String useKey = sc.nextLine();
Student student = studentStore.get(useKey);
if (!checkStudentId(student)) return;
studentStore.remove(useKey);
if (!studentStore.containsKey(useKey))
System.out.println("삭제 완료되었습니다.");
}
- 목적: 수강생을 삭제합니다.
- 기능:
- 수강생 ID를 입력받아 해당 학생 정보를 조회합니다.
- studentStore에서 해당 학생 정보를 삭제합니다.
- 삭제가 완료된 후 결과를 출력합니다.
makeSubject 메소드
private static void makeSubject(String val, ArrayList<String> getSubject, String type) {
Subject useSubject = subjectStore.get(val);
if (!useSubject.getSubjectType().equals(type)) //타 과목시 예외처리
throw new IllegalArgumentException();
getSubject.add(val);
}
- 목적: 과목 정보를 검증하고 저장합니다.
- 매개변수:
- String val: 과목 코드입니다.
- ArrayList<String> getSubject: 과목 코드를 추가할 리스트입니다.
- String type: 과목의 타입(필수 또는 선택)입니다.
- 기능:
- 주어진 과목 코드가 올바른 타입인지 검증하고, 맞다면 리스트에 추가합니다.
- 과목 코드가 잘못된 타입일 경우 예외를 발생시킵니다.
package storeManagement
Store.class
수강생, 과목, 성적 정보를 저장하는 맵을 관리, 데이터의 초기화와 고유 ID 생성 등의 기능을 포함
package camp.storeManagement;
import camp.model.Score;
import camp.model.Student;
import camp.model.Subject;
import java.util.HashMap;
import java.util.Map;
public class Stores {
public static Map<String, Student> studentStore;
public static Map<String, Subject> subjectStore;
public static Map<String, Map<String, Score>> scoreStore;
// 과목 타입
public static String SUBJECT_TYPE_MANDATORY = "MANDATORY";
public static String SUBJECT_TYPE_CHOICE = "CHOICE";
// index 관리 필드
public static int studentIndex;
public static final String INDEX_TYPE_STUDENT = "ST";
public static int subjectIndex;
public static final String INDEX_TYPE_SUBJECT = "SU";
public static int scoreIndex;
public static final String INDEX_TYPE_SCORE = "SC";
public static void setInitData() {
studentStore = new HashMap<>();
scoreStore = new HashMap<>();
subjectStore = new HashMap<>();
String subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "Java", SUBJECT_TYPE_MANDATORY));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "객체지향", SUBJECT_TYPE_MANDATORY));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "Spring", SUBJECT_TYPE_MANDATORY));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "JPA", SUBJECT_TYPE_MANDATORY));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "MySQL", SUBJECT_TYPE_MANDATORY));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "디자인 패턴", SUBJECT_TYPE_CHOICE));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "Spring Security", SUBJECT_TYPE_CHOICE));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "Redis", SUBJECT_TYPE_CHOICE));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "MongoDB", SUBJECT_TYPE_CHOICE));
}
public static String sequence(String type) {
switch (type) {
case INDEX_TYPE_STUDENT -> {
studentIndex++;
return INDEX_TYPE_STUDENT + studentIndex;
}
case INDEX_TYPE_SUBJECT -> {
subjectIndex++;
return INDEX_TYPE_SUBJECT + subjectIndex;
}
default -> {
scoreIndex++;
return INDEX_TYPE_SCORE + scoreIndex;
}
}
}
}
필드
public static Map<String, Student> studentStore;
public static Map<String, Subject> subjectStore;
public static Map<String, Map<String, Score>> scoreStore;
- studentStore: Student 객체를 저장하는 HashMap입니다. 학생의 고유 ID를 키로 사용합니다.
- subjectStore: Subject 객체를 저장하는 HashMap입니다. 과목의 고유 ID를 키로 사용합니다.
- scoreStore: Score 객체를 저장하는 HashMap입니다. 과목 ID를 키로 하고, 해당 과목에 대한 학생들의 성적 정보를 저장하는 맵을 값으로 사용합니다.
과목 타입 상수
public static String SUBJECT_TYPE_MANDATORY = "MANDATORY";
public static String SUBJECT_TYPE_CHOICE = "CHOICE";
- SUBJECT_TYPE_MANDATORY: 필수 과목을 나타내는 상수입니다.
- SUBJECT_TYPE_CHOICE: 선택 과목을 나타내는 상수입니다.
인덱스 관리 필드
public static int studentIndex;
public static final String INDEX_TYPE_STUDENT = "ST";
public static int subjectIndex;
public static final String INDEX_TYPE_SUBJECT = "SU";
public static int scoreIndex;
public static final String INDEX_TYPE_SCORE = "SC";
- studentIndex: 학생 ID의 인덱스를 관리하는 필드입니다.
- INDEX_TYPE_STUDENT: 학생 ID의 접두사입니다.
- subjectIndex: 과목 ID의 인덱스를 관리하는 필드입니다.
- INDEX_TYPE_SUBJECT: 과목 ID의 접두사입니다.
- scoreIndex: 성적 ID의 인덱스를 관리하는 필드입니다.
- INDEX_TYPE_SCORE: 성적 ID의 접두사입니다.
메소드
setInitData 메소드
public static void setInitData() {
studentStore = new HashMap<>();
scoreStore = new HashMap<>();
subjectStore = new HashMap<>();
String subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "Java", SUBJECT_TYPE_MANDATORY));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "객체지향", SUBJECT_TYPE_MANDATORY));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "Spring", SUBJECT_TYPE_MANDATORY));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "JPA", SUBJECT_TYPE_MANDATORY));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "MySQL", SUBJECT_TYPE_MANDATORY));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "디자인 패턴", SUBJECT_TYPE_CHOICE));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "Spring Security", SUBJECT_TYPE_CHOICE));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "Redis", SUBJECT_TYPE_CHOICE));
subjectId = sequence(INDEX_TYPE_SUBJECT);
subjectStore.put(subjectId, new Subject(subjectId, "MongoDB", SUBJECT_TYPE_CHOICE));
}
- 목적: 초기 데이터를 설정합니다.
- 기능:
- studentStore, scoreStore, subjectStore를 초기화합니다.
- subjectStore에 몇 가지 기본 과목을 추가합니다. 과목의 ID는 sequence 메소드를 사용하여 생성됩니다.
sequence 메소드
public static String sequence(String type) {
switch (type) {
case INDEX_TYPE_STUDENT -> {
studentIndex++;
return INDEX_TYPE_STUDENT + studentIndex;
}
case INDEX_TYPE_SUBJECT -> {
subjectIndex++;
return INDEX_TYPE_SUBJECT + subjectIndex;
}
default -> {
scoreIndex++;
return INDEX_TYPE_SCORE + scoreIndex;
}
}
}- 목적: 고유 ID를 생성합니다.
- 매개변수:
- type: 생성할 ID의 타입을 나타냅니다 (학생, 과목, 성적).
- 기능:
- 주어진 타입에 따라 인덱스를 증가시키고, 타입과 인덱스를 조합하여 새로운 ID를 반환합니다.
package camp.scoreManagement
CheckScoreManagement.class
학생과 과목의 정보를 검증하는 기능을 제공
package camp.scoreManagement;
import camp.CampManagementApplication;
import camp.model.Student;
import java.util.ArrayList;
import static camp.CampManagementApplication.*;
import static camp.storeManagement.Stores.*;
public class CheckScoreManagement {
// 수강생 고유 번호 입력값 검증
public static String checkStudentId() {
printStudentInfo();
System.out.print("\n관리할 수강생의 고유 번호를 입력하세요 (ex. ST) : ");
String studentId = sc.next();
try {
if (!scoreStore.containsKey(studentId))
throw new IllegalArgumentException("해당 학생은 존재하지 않습니다.");
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
}
return studentId;
}
// 수강중인 과목 고유 번호 입력값 검증
public static String checkSubjectId(String studentId) {
CampManagementApplication.printSubjectInfoByStudentId(studentId);
Student student = studentStore.get(studentId);
ArrayList<String> scores = student.getSubjectList();
System.out.print("\n관리할 과목의 고유 번호를 입력하세요 (ex. SU1) : ");
String subjectId = sc.next(); //SU1
try {
if (!scores.contains(subjectId)) {
throw new IllegalArgumentException("선택한 수강생이 수강중인 과목이 아닙니다.");
}
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
}
return subjectId;
}
}
checkStudentId 메소드
public static String checkStudentId() {
printStudentInfo();
System.out.print("\n관리할 수강생의 고유 번호를 입력하세요 (ex. ST) : ");
String studentId = sc.next();
try {
if (!scoreStore.containsKey(studentId))
throw new IllegalArgumentException("해당 학생은 존재하지 않습니다.");
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
}
return studentId;
}
- 목적: 입력된 학생의 고유 번호가 존재하는지 검증합니다.
- 작동 과정:
- printStudentInfo()를 호출하여 학생 정보를 출력합니다.
- 사용자에게 학생의 고유 번호를 입력받습니다.
- scoreStore에서 해당 학생의 ID가 존재하는지 확인합니다.
- 학생 ID가 존재하지 않으면 예외를 던지고, 오류 메시지를 출력합니다.
- 유효한 학생 ID를 반환합니다.
- 예외 처리:
- IllegalArgumentException을 사용하여 학생이 존재하지 않는 경우 오류 메시지를 출력합니다.
checkSubjectId 메소드
public static String checkSubjectId(String studentId) {
CampManagementApplication.printSubjectInfoByStudentId(studentId);
Student student = studentStore.get(studentId);
ArrayList<String> scores = student.getSubjectList();
System.out.print("\n관리할 과목의 고유 번호를 입력하세요 (ex. SU1) : ");
String subjectId = sc.next();
try {
if (!scores.contains(subjectId)) {
throw new IllegalArgumentException("선택한 수강생이 수강중인 과목이 아닙니다.");
}
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
}
return subjectId;
}
- 목적: 입력된 과목의 고유 번호가 해당 학생이 수강 중인 과목인지 검증합니다.
- 작동 과정:
- printSubjectInfoByStudentId(studentId)를 호출하여 학생이 수강 중인 과목 정보를 출력합니다.
- 학생의 ID를 사용하여 studentStore에서 Student 객체를 가져옵니다.
- 학생이 수강 중인 과목 목록을 가져옵니다.
- 사용자에게 관리할 과목의 고유 번호를 입력받습니다.
- 입력된 과목 ID가 학생의 수강 과목 목록에 있는지 확인합니다.
- 과목 ID가 목록에 없으면 예외를 던지고, 오류 메시지를 출력합니다.
- 유효한 과목 ID를 반환합니다.
- 예외 처리:
- IllegalArgumentException을 사용하여 학생이 수강 중이지 않은 과목을 선택한 경우 오류 메시지를 출력합니다.
MainScoreManagement.class
점수와 관련된 관리 작업을 처리
package camp.scoreManagement;
import camp.model.Score;
import static camp.scoreManagement.UpdateScoreManagement.*;
import static camp.scoreManagement.CheckScoreManagement.*;
import java.util.*;
import static camp.CampManagementApplication.*;
import static camp.storeManagement.Stores.*;
public class MainScoreManagement {
// 점수 관리 메뉴
public static void displayScoreView() {
System.out.println(scoreStore.size());
boolean flag = true;
while (flag) {
System.out.println("==================================");
System.out.println("점수 관리 실행 중...");
System.out.println("1. 수강생의 과목별 시험 회차 및 점수 등록");
System.out.println("2. 수강생의 과목별 회차 점수 수정");
System.out.println("3. 수강생의 특정 과목 회차별 등급 조회");
System.out.println("4. 수강생의 특정 과목 평균 등급 조회");
System.out.println("5. 메인 화면 이동");
System.out.print("관리 항목을 선택하세요...");
int input = sc.nextInt();
switch (input) {
case 1 -> createScore(); // 수강생의 과목별 시험 회차 및 점수 등록
case 2 -> updateScore(); // 수강생의 과목별 회차 점수 수정
case 3 -> inquireRoundGradeBySubject(); // 수강생의 특정 과목 회차별 등급 조회
case 4 -> inquireAverageGradeBySubject();
case 5 -> flag = false; // 메인 화면 이동
default -> {
System.out.println("잘못된 입력입니다.\n메인 화면 이동...");
flag = false;
}
}
}
}
// 수강생의 특정 과목 회차별 등급 조회
private static void inquireRoundGradeBySubject() {
Scanner sc = new Scanner(System.in);
String studentId = checkStudentId(); // 관리할 수강생 고유 번호
// 기능 구현
try {
//scoreStore 맵에 입력한 학생고유번호가 존재할경우
if (scoreStore.containsKey(studentId)) {
System.out.println("회차별 등급을 조회합니다...");
System.out.println("점수 조회를 원하는 과목의 고유번호를 입력하세요");
//전체보유중인 subject 의 고유번호 전체를 보여줌
printSubjectInfoByStudentId(studentId);
String inputSubjectId = sc.nextLine();
//필수과목인지 확인시켜주는 변수
int indicator = Character.getNumericValue(inputSubjectId.charAt(2));
//수강생 수강목록확인
ArrayList<String> scores = studentStore.get(studentId).getSubjectList();
//scoreStore안에있는 Map 을 지정해줌
Map<String, Score> innerScoreStore = scoreStore.get(studentId);
//수강하지않을경우 예외처리
if (!scores.contains(inputSubjectId)) {
throw new Exception("선택한 수강생이 수강중인 과목이 아닙니다.");
}
//만약 2중 맵안에 고유학생번호키가 가진 Value의 Map안에 고유 과목 키값이 존재할경우
if (innerScoreStore.containsKey(inputSubjectId) && indicator < 6) {
int[] d = innerScoreStore.get(inputSubjectId).getScores();
for (int i = 0; i < d.length; i++) {
int num = d[i];
if (num > 94) {
System.out.println((i + 1) + "회차 등급: A");
} else if (num > 89) {
System.out.println((i + 1) + "회차 등급: B");
} else if (num > 79) {
System.out.println((i + 1) + "회차 등급 : C");
} else if (num > 69) {
System.out.println((i + 1) + "회차 등급 : D");
} else if (num > 59) {
System.out.println((i + 1) + "회차 등급 : F");
} else if (num > 0) {
System.out.println((i + 1) + "회차 등급 : N");
} else {
continue;
}
}
System.out.println("\n등급 조회 성공!");
} else if (innerScoreStore.containsKey(inputSubjectId) && indicator > 5) {
int[] d = innerScoreStore.get(inputSubjectId).getScores();
for (int i = 0; i < d.length; i++) {
int num = d[i];
if (num > 89) {
System.out.println((i + 1) + "회차 등급: A");
} else if (num > 79) {
System.out.println((i + 1) + "회차 등급: B");
} else if (num > 69) {
System.out.println((i + 1) + "회차 등급 : C");
} else if (num > 59) {
System.out.println((i + 1) + "회차 등급 : D");
} else if (num > 49) {
System.out.println((i + 1) + "회차 등급 : F");
} else if (num > 0) {
System.out.println((i + 1) + "회차 등급 : N");
} else {
continue;
}
}
System.out.println("\n등급 조회 성공!");
} else {
//해당 등록된 과목에 등록된 점수가없을시
throw new Exception("해당 과목에 등록된 점수가 없습니다");
}
}//해당 고유번호를지닌 학생이 없을시
else {
throw new Exception("해당 고유번호를 가진 수강생이 존재하지않습니다");
}
} catch (Exception e) {
System.out.println(e);
}
}
// 과목별 전체 회차 점수 조회
private static void inquireAverageGradeBySubject() {
Scanner sc = new Scanner(System.in);
String studentId = checkStudentId(); // 관리할 수강생 고유 번호
// 기능 구현 (조회할 특정 과목)
int totalScore = 0;
int totalRound = 0;
int averageScore = 0;
// 기능 구현
try {
//scoreStore 맵에 입력한 학생고유번호가 존재할경우
if (scoreStore.containsKey(studentId)) {
System.out.println("회차별 등급을 조회합니다...");
System.out.println("평균 점수 조회를 원하는 과목의 고유번호를 입력하세요");
//전체보유중인 subject 의 고유번호 전체를 보여줌
printSubjectInfoByStudentId(studentId);
String inputSubjectId = sc.nextLine();
//수강생 수강목록확인
ArrayList<String> scores = studentStore.get(studentId).getSubjectList();
int indicator = Character.getNumericValue(inputSubjectId.charAt(2));
//수강생이 입력한 과목을 수강하지않을시 예외처리
if (!scores.contains(inputSubjectId)) {
throw new Exception("선택한 수강생이 수강중인 과목이 아닙니다.");
}
//수강 과목의 점수가 등록되지않을시 예외처리
if (!scoreStore.get(studentId).containsKey(inputSubjectId)) {
System.out.println("등록된 점수가 없는 학생입니다");
return;
}
//scoreStore안에있는 Map 을 지정해줌
Map<String, Score> innerScoreStore = scoreStore.get(studentId);
int[] d = innerScoreStore.get(inputSubjectId).getScores();
//평균점수를 위한 총 점수 및 총횟수를 구해줌
for (int i = 0; i < d.length; i++) {
if (d[i] > 0) {
totalScore += d[i];
totalRound++;
} else {
continue;
}
}
//평균점수를 구해줌
averageScore = totalScore / totalRound;
//평균점수를 기반으로한 등급을 구해줌
if (innerScoreStore.containsKey(inputSubjectId) && indicator < 6) {
if (averageScore > 94) {
System.out.println("평균 등급: A");
} else if (averageScore > 89) {
System.out.println("평균 등급: B");
} else if (averageScore > 79) {
System.out.println("평균 등급 : C");
} else if (averageScore > 69) {
System.out.println("평균 등급 : D");
} else if (averageScore > 59) {
System.out.println("평균 등급 : F");
} else if (averageScore > 0) {
System.out.println("평균 등급 : N");
}
} else if (innerScoreStore.containsKey(inputSubjectId) && indicator > 5) {
if (averageScore > 89) {
System.out.println("평균 등급: A");
} else if (averageScore > 79) {
System.out.println("평균 등급: B");
} else if (averageScore > 69) {
System.out.println("평균등급 : C");
} else if (averageScore > 59) {
System.out.println("평균 등급 : D");
} else if (averageScore > 49) {
System.out.println("평균 등급 : F");
} else if (averageScore > 0) {
System.out.println("평균 등급 : N");
}
}
System.out.println("\n등급 조회 성공!");
} else {
throw new Exception("해당 고유번호를 가진 수강생이 존재하지않습니다");
}
} catch (Exception e) {
System.out.println(e);
}
}
// 현재 등록 된 과목 점수
public static void printsScoreInfoByStudentId(String studentId) {
Map<String, Score> scores = scoreStore.get(studentId);
System.out.println("=================현재 점수=================");
for (Map.Entry<String, Score> entry : scores.entrySet()) {
String subjectId = entry.getKey();
Score score = entry.getValue();
System.out.println("과목 ID: " + subjectId);
System.out.println("회차별 점수: ");
for (int i = 0; i < score.getScores().length; i++) {
if (-1 < score.getScores()[i]) {
System.out.println((i + 1) + "회차: " + score.getScores()[i]);
}
}
System.out.println("=======================================");
}
}
}
displayScoreView 메소드
public static void displayScoreView() {
System.out.println(scoreStore.size());
boolean flag = true;
while (flag) {
System.out.println("==================================");
System.out.println("점수 관리 실행 중...");
System.out.println("1. 수강생의 과목별 시험 회차 및 점수 등록");
System.out.println("2. 수강생의 과목별 회차 점수 수정");
System.out.println("3. 수강생의 특정 과목 회차별 등급 조회");
System.out.println("4. 수강생의 특정 과목 평균 등급 조회");
System.out.println("5. 메인 화면 이동");
System.out.print("관리 항목을 선택하세요...");
int input = sc.nextInt();
switch (input) {
case 1 -> createScore(); // 수강생의 과목별 시험 회차 및 점수 등록
case 2 -> updateScore(); // 수강생의 과목별 회차 점수 수정
case 3 -> inquireRoundGradeBySubject(); // 수강생의 특정 과목 회차별 등급 조회
case 4 -> inquireAverageGradeBySubject(); // 수강생의 특정 과목 평균 등급 조회
case 5 -> flag = false; // 메인 화면 이동
default -> {
System.out.println("잘못된 입력입니다.\n메인 화면 이동...");
flag = false;
}
}
}
}
- 목적: 점수 관리 메뉴를 표시하고 사용자가 선택한 작업을 수행합니다.
- 작동 과정:
- 점수 저장소의 크기를 출력합니다.
- 사용자에게 점수 관리 작업을 선택하라는 메뉴를 표시합니다.
- 사용자의 입력을 받아 해당 작업을 수행합니다.
- 잘못된 입력에 대한 예외 처리를 수행하고, 메인 화면으로 이동합니다.
inquireRoundGradeBySubject 메소드
private static void inquireRoundGradeBySubject() {
Scanner sc = new Scanner(System.in);
String studentId = checkStudentId(); // 관리할 수강생 고유 번호
try {
if (scoreStore.containsKey(studentId)) {
System.out.println("회차별 등급을 조회합니다...");
System.out.println("점수 조회를 원하는 과목의 고유번호를 입력하세요");
printSubjectInfoByStudentId(studentId);
String inputSubjectId = sc.nextLine();
int indicator = Character.getNumericValue(inputSubjectId.charAt(2));
ArrayList<String> scores = studentStore.get(studentId).getSubjectList();
Map<String, Score> innerScoreStore = scoreStore.get(studentId);
if (!scores.contains(inputSubjectId)) {
throw new Exception("선택한 수강생이 수강중인 과목이 아닙니다.");
}
if (innerScoreStore.containsKey(inputSubjectId) && indicator < 6) {
int[] d = innerScoreStore.get(inputSubjectId).getScores();
for (int i = 0; i < d.length; i++) {
int num = d[i];
System.out.println((i + 1) + "회차 등급: " + getGrade(num, indicator));
}
System.out.println("\n등급 조회 성공!");
} else if (innerScoreStore.containsKey(inputSubjectId) && indicator > 5) {
int[] d = innerScoreStore.get(inputSubjectId).getScores();
for (int i = 0; i < d.length; i++) {
int num = d[i];
System.out.println((i + 1) + "회차 등급: " + getGrade(num, indicator));
}
System.out.println("\n등급 조회 성공!");
} else {
throw new Exception("해당 과목에 등록된 점수가 없습니다");
}
} else {
throw new Exception("해당 고유번호를 가진 수강생이 존재하지않습니다");
}
} catch (Exception e) {
System.out.println(e);
}
}
- 목적: 특정 과목의 회차별 등급을 조회합니다.
- 작동 과정:
- 사용자의 학생 ID를 확인합니다.
- 해당 학생이 등록된 과목의 정보를 출력합니다.
- 사용자가 조회할 과목의 ID를 입력받습니다.
- 입력된 과목 ID가 해당 학생의 수강 과목 목록에 있는지 확인합니다.
- 점수를 바탕으로 등급을 계산하고 출력합니다. (등급 계산은 getGrade 메소드를 사용)
inquireAverageGradeBySubject 메소드
private static void inquireAverageGradeBySubject() {
Scanner sc = new Scanner(System.in);
String studentId = checkStudentId(); // 관리할 수강생 고유 번호
int totalScore = 0;
int totalRound = 0;
int averageScore = 0;
try {
if (scoreStore.containsKey(studentId)) {
System.out.println("회차별 등급을 조회합니다...");
System.out.println("평균 점수 조회를 원하는 과목의 고유번호를 입력하세요");
printSubjectInfoByStudentId(studentId);
String inputSubjectId = sc.nextLine();
ArrayList<String> scores = studentStore.get(studentId).getSubjectList();
int indicator = Character.getNumericValue(inputSubjectId.charAt(2));
if (!scores.contains(inputSubjectId)) {
throw new Exception("선택한 수강생이 수강중인 과목이 아닙니다.");
}
if (!scoreStore.get(studentId).containsKey(inputSubjectId)) {
System.out.println("등록된 점수가 없는 학생입니다");
return;
}
Map<String, Score> innerScoreStore = scoreStore.get(studentId);
int[] d = innerScoreStore.get(inputSubjectId).getScores();
for (int i = 0; i < d.length; i++) {
if (d[i] > 0) {
totalScore += d[i];
totalRound++;
}
}
averageScore = totalScore / totalRound;
String averageGrade = getGrade(averageScore, indicator);
System.out.println("평균 등급: " + averageGrade);
System.out.println("\n등급 조회 성공!");
} else {
throw new Exception("해당 고유번호를 가진 수강생이 존재하지않습니다");
}
} catch (Exception e) {
System.out.println(e);
}
}
- 목적: 특정 과목의 평균 점수를 계산하고 해당 평균 점수에 대한 등급을 조회합니다.
- 작동 과정:
- 사용자의 학생 ID를 확인합니다.
- 해당 학생이 수강 중인 과목의 정보를 출력합니다.
- 사용자가 조회할 과목의 ID를 입력받습니다.
- 입력된 과목 ID가 해당 학생의 수강 과목 목록에 있는지 확인합니다.
- 점수 배열을 바탕으로 평균 점수를 계산하고, 해당 평균 점수에 대한 등급을 출력합니다. (등급 계산은 getGrade 메소드를 사용)
printsScoreInfoByStudentId 메소드
public static void printsScoreInfoByStudentId(String studentId) {
Map<String, Score> scores = scoreStore.get(studentId);
System.out.println("=================현재 점수=================");
for (Map.Entry<String, Score> entry : scores.entrySet()) {
String subjectId = entry.getKey();
Score score = entry.getValue();
System.out.println("과목 ID: " + subjectId);
System.out.println("회차별 점수: ");
for (int i = 0; i < score.getScores().length; i++) {
if (-1 < score.getScores()[i]) {
System.out.println((i + 1) + "회차: " + score.getScores()[i]);
}
}
System.out.println("=======================================");
}
}
- 목적: 특정 학생의 현재 점수를 출력합니다.
- 작동 과정:
- 학생의 ID를 기반으로 scoreStore에서 점수를 조회합니다.
- 점수를 과목별로 출력합니다.
UpdateScoreManagement.class
수강생의 점수를 등록하고 수정하는 기능을 담당
package camp.scoreManagement;
import camp.model.Score;
import java.util.*;
import static camp.CampManagementApplication.sc;
import static camp.storeManagement.Stores.scoreStore;
public class UpdateScoreManagement {
// 수강생의 과목별 시험 회차 및 점수 등록
public static void createScore() {
try {
String studentId = CheckScoreManagement.checkStudentId(); // 관리할 수강생 고유 번호
String subjectId = CheckScoreManagement.checkSubjectId(studentId); // 등록할 과목 고유 번호
System.out.println("등록할 시험 회차를 입력하시오...");
String index = sc.next();
System.out.println("점수를 입력하시오...");
String score = sc.next();
Map<String, Score> inner = new HashMap<>();
if (!scoreStore.containsKey(studentId) || !scoreStore.get(studentId).containsKey(subjectId)) {
inner.put(subjectId, new Score(index, score));
scoreStore.put(studentId, inner);
} else {
scoreStore.get(studentId).get(subjectId).setScores(index, score);
}
System.out.println("\n점수 등록 성공!");
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
// 수강생의 과목별 회차 점수 수정 --> 김민주
public static void updateScore() {
String studentId = CheckScoreManagement.checkStudentId(); // 관리할 수강생 고유 번호
if (!scoreStore.containsKey(studentId)) {
System.out.println("등록된 점수가 없는 학생입니다");
return;
}
String subjectId = CheckScoreManagement.checkSubjectId(studentId); // 등록할 과목 고유 번호
if (!scoreStore.get(studentId).containsKey(subjectId)) {
System.out.println("등록된 점수가 없는 학생입니다");
return;
}
MainScoreManagement.printsScoreInfoByStudentId(studentId);
System.out.println("등록할 시험 회차를 입력하시오...");
String index = sc.next();
System.out.println("점수를 입력하시오...");
String score = sc.next();
int indexInt; //번호
int ScoreInt; //점수
// 인덱스 예외처리
try {
indexInt = Integer.parseInt(index) - 1;
ScoreInt = Integer.parseInt(score);
if (indexInt < 0 || indexInt > 9 || ScoreInt < 0 || ScoreInt > 100) {
throw new NumberFormatException();
}
int[] scores = scoreStore.get(studentId).get(subjectId).getScores();
if (scores[indexInt] != -1) {
scores[indexInt] = ScoreInt;
} else {
System.out.println(index + "회차의 점수는 이미 등록되어 있습니다");
}
} catch (NumberFormatException e) {
System.out.println("숫자가 아닌 값이 입력됨");
}
}
}
createScore 메소드
public static void createScore() {
try {
String studentId = CheckScoreManagement.checkStudentId(); // 관리할 수강생 고유 번호
String subjectId = CheckScoreManagement.checkSubjectId(studentId); // 등록할 과목 고유 번호
System.out.println("등록할 시험 회차를 입력하시오...");
String index = sc.next();
System.out.println("점수를 입력하시오...");
String score = sc.next();
Map<String, Score> inner = new HashMap<>();
if (!scoreStore.containsKey(studentId) || !scoreStore.get(studentId).containsKey(subjectId)) {
inner.put(subjectId, new Score(index, score));
scoreStore.put(studentId, inner);
} else {
scoreStore.get(studentId).get(subjectId).setScores(index, score);
}
System.out.println("\n점수 등록 성공!");
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
- 목적: 수강생의 특정 과목에 대한 시험 회차 및 점수를 등록합니다.
- 작동 과정:
- CheckScoreManagement 클래스의 checkStudentId 메소드를 호출하여 학생 ID를 확인합니다.
- checkSubjectId 메소드를 호출하여 과목 ID를 확인합니다.
- 사용자가 입력한 시험 회차와 점수를 읽어옵니다.
- scoreStore에서 해당 학생과 과목에 대한 점수를 등록하거나 수정합니다.
- 점수가 새로 등록되면 새로운 Score 객체를 생성하고 scoreStore에 추가합니다. 기존 점수가 있는 경우에는 setScores 메소드를 호출하여 점수를 업데이트합니다.
- 성공 메시지를 출력합니다.
updateScore 메소드
public static void updateScore() {
String studentId = CheckScoreManagement.checkStudentId(); // 관리할 수강생 고유 번호
if (!scoreStore.containsKey(studentId)) {
System.out.println("등록된 점수가 없는 학생입니다");
return;
}
String subjectId = CheckScoreManagement.checkSubjectId(studentId); // 등록할 과목 고유 번호
if (!scoreStore.get(studentId).containsKey(subjectId)) {
System.out.println("등록된 점수가 없는 학생입니다");
return;
}
MainScoreManagement.printsScoreInfoByStudentId(studentId);
System.out.println("등록할 시험 회차를 입력하시오...");
String index = sc.next();
System.out.println("점수를 입력하시오...");
String score = sc.next();
int indexInt; // 번호
int ScoreInt; // 점수
// 인덱스 예외처리
try {
indexInt = Integer.parseInt(index) - 1;
ScoreInt = Integer.parseInt(score);
if (indexInt < 0 || indexInt > 9 || ScoreInt < 0 || ScoreInt > 100) {
throw new NumberFormatException();
}
int[] scores = scoreStore.get(studentId).get(subjectId).getScores();
if (scores[indexInt] != -1) {
scores[indexInt] = ScoreInt;
} else {
System.out.println(index + "회차의 점수는 이미 등록되어 있습니다");
}
} catch (NumberFormatException e) {
System.out.println("숫자가 아닌 값이 입력됨");
}
}
- 목적: 수강생의 특정 과목에 대한 시험 회차 점수를 수정합니다.
- 작동 과정:
- CheckScoreManagement 클래스의 checkStudentId 메소드를 호출하여 학생 ID를 확인합니다.
- checkSubjectId 메소드를 호출하여 과목 ID를 확인합니다.
- 학생의 점수 정보를 출력합니다 (MainScoreManagement.printsScoreInfoByStudentId).
- 사용자로부터 시험 회차와 점수를 입력받습니다.
- 입력된 값을 정수로 변환하고, 유효성을 검사합니다. (시험 회차는 1~10 과목 점수 범위 1~100)
- scoreStore에서 해당 학생의 과목 점수 배열을 가져와 수정합니다. 회차가 이미 등록되어 있는 경우 오류 메시지를 출력합니다.
- 숫자가 아닌 값이 입력된 경우 예외 처리합니다.
package camp.model
Score.class
학생의 특정 과목에 대한 시험 회차별 점수를 관리
package camp.model;
public class Score {
private int[] scores = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
public Score(String index, String score) { setScores(index, score); }
public int[] getScores() { return scores; }
// 점수 등록
public void setScores(String index, String score) {
int indexInt; //번호
int ScoreInt; //점수
// 인덱스 예외처리
try {
indexInt = Integer.parseInt(index) - 1;
ScoreInt = Integer.parseInt(score);
if (indexInt < 0 || indexInt > 9 || ScoreInt < 0 || ScoreInt > 100) {
throw new NumberFormatException("입력값이 잘못되었습니다");
}
if (scores[indexInt] == -1) {
scores[indexInt] = ScoreInt;
} else {
System.out.println(index + "회차의 점수는 이미 등록되어 있습니다");
}
} catch (NumberFormatException e) {
System.out.println(e.getMessage());
}
}
}
생성자
public Score(String index, String score) { setScores(index, score); }주어진 index와 score 값을 사용하여 점수를 설정하는 생성자입니다.
메서드
public int[] getScores()- 현재 저장된 점수 배열을 반환합니다.
public void setScores(String index, String score)
- 시험 회차(index)와 점수(score)를 설정합니다.
- index는 회차 번호로, 1부터 시작하며 배열의 인덱스는 0부터 시작하므로 index - 1로 변환됩니다.
- score는 시험 점수로, 0부터 100 사이의 정수여야 합니다.
- 예외 처리를 통해 입력 값이 범위를 벗어나거나 숫자가 아닐 경우 오류 메시지를 출력합니다.
- 이미 점수가 등록된 회차에 대해 다시 점수를 등록하려 하면 "회차의 점수는 이미 등록되어 있습니다"라는 메시지를 출력합니다.
코드 설명
- setScores 메서드는 점수를 설정하는 과정에서 다음과 같은 예외 처리를 합니다:
- index가 1에서 10 사이가 아니거나 score가 0에서 100 사이가 아닌 경우 NumberFormatException을 발생시킵니다.
- scores 배열의 해당 인덱스에 이미 점수가 등록되어 있으면, "회차의 점수는 이미 등록되어 있습니다"라는 메시지를 출력합니다.
Student.class
각 학생의 고유 정보와 수강 과목 목록을 관리
package camp.model;
import java.util.ArrayList;
public class Student {
private final String studentId;
private String studentName;
private String studentState; //수강생 상태
private final ArrayList<String> subjectList; // 수강 과목
public Student(String studentId,String studentName, String studentState,ArrayList<String> subjectList) {
this.studentId=studentId;
this.subjectList = subjectList;
this.studentState = studentState;
this.studentName = studentName;
}
public String getStudentId() { return studentId; }
public String getStudentName() { return studentName; }
public String getStudentState() { return studentState; }
public void setStudentName(String studentName) { this.studentName = studentName; }
public void setStudentState(String studentState) { this.studentState = studentState; }
public ArrayList<String> getSubjectList() { return subjectList; }
}필드
private final String studentId- 학생의 고유 ID로, 변경할 수 없는 값입니다.
private String studentName- 학생의 이름입니다.
private String studentState
- 학생의 상태를 나타냅니다 (예: 수강 중, 졸업, 휴학 등).
private final ArrayList<String> subjectList- 학생이 수강하고 있는 과목들의 리스트입니다. ArrayList를 사용하여 동적으로 과목을 추가하거나 삭제할 수 있습니다.
생성자
public Student(String studentId, String studentName, String studentState, ArrayList<String> subjectList) {
this.studentId = studentId;
this.studentName = studentName;
this.studentState = studentState;
this.subjectList = subjectList;
}
학생의 ID, 이름, 상태, 수강 과목 리스트를 초기화하는 생성자입니다.
메서드
public String getStudentId()학생의 ID를 반환합니다.
public String getStudentName()학생의 이름을 반환합니다.
public String getStudentState()학생의 상태를 반환합니다.
public void setStudentName(String studentName)학생의 이름을 설정합니다.
public void setStudentState(String studentState)학생의 상태를 설정합니다.
public ArrayList<String> getSubjectList()학생의 수강 과목 리스트를 반환합니다.
코드 설명
- 변경 불가능한 필드: studentId와 subjectList는 final로 선언되어 있으며, 객체가 생성된 후에는 변경할 수 없습니다. 이는 학생의 ID와 수강 과목 리스트가 불변임을 보장합니다.
- 변경 가능한 필드: studentName과 studentState는 객체 생성 후에도 변경할 수 있습니다. 이 필드는 setStudentName 및 setStudentState 메서드를 통해 수정할 수 있습니다.
- 수강 과목 리스트: ArrayList<String> 타입의 subjectList는 학생이 수강 중인 과목들의 목록을 저장합니다. 이 리스트는 학생의 과목 수강 정보를 동적으로 관리할 수 있게 해줍니다.
Subject.class
과목에 대한 정보를 저장하고 관리하는 클래스
package camp.model;
public class Subject {
private final String subjectId;
private final String subjectName;
private final String subjectType;
public Subject(String seq, String subjectName, String subjectType) {
this.subjectId = seq;
this.subjectName = subjectName;
this.subjectType = subjectType;
}
public String getSubjectName() { return subjectName; }
public String getSubjectType() { return subjectType; }
}필드
private final String subjectId과목의 고유 ID로, 변경할 수 없는 값입니다. final로 선언되어 객체 생성 후에는 변경되지 않습니다.
private final String subjectName과목의 이름입니다. final로 선언되어 초기화 후 변경할 수 없습니다.
private final String subjectType과목의 타입을 나타냅니다. 예를 들어, 필수 과목(MANDATORY) 또는 선택 과목(CHOICE) 등이 될 수 있습니다. 이 값도 final로 선언되어 초기화 후 변경되지 않습니다.
생성자
public Subject(String seq, String subjectName, String subjectType) {
this.subjectId = seq;
this.subjectName = subjectName;
this.subjectType = subjectType;
}
과목의 ID, 이름, 타입을 초기화하는 생성자입니다. 이 생성자는 클래스의 필드를 초기화하는 데 사용됩니다.
메서드
public String getSubjectName()과목의 이름을 반환합니다.
public String getSubjectType()과목의 타입을 반환합니다.
코드 설명
- 변경 불가능한 필드: subjectId, subjectName, subjectType은 모두 final로 선언되어 있습니다. 이는 객체 생성 후에 이 필드들이 변경되지 않음을 보장합니다.
- 생성자: 생성자는 과목의 ID, 이름, 타입을 초기화합니다. 이 정보는 객체 생성 시에만 설정할 수 있으며, 이후에는 변경할 수 없습니다.
- 조회 메서드: getSubjectName과 getSubjectType 메서드는 각각 과목의 이름과 타입을 반환합니다. 이 메서드들은 필드 값을 읽기 위한 getter 메서드입니다.
'미니 프로젝트 > 수강생 관리 프로그램(Java)' 카테고리의 다른 글
| KPT회고(수강생 관리 프로그램) (0) | 2024.08.08 |
|---|---|
| 수강생 관리 시스템 마지막 수정 (0) | 2024.08.08 |
| 수강생 시스템 알고리즘 (0) | 2024.08.06 |