수강생 관리 시스템 마지막 수정

우리팀이 static을 이용해 각각의 기능을 모듈화로 초점을 두었기에 객체지향의 느낌과는 거리가 멀었다 그래서 Molde과 View 두가지로 구분하여 객체를 나누기로 했다. 갑작스럽게 객체지향이라는 초점이 맞추기 위해서 기존 클래스들을 대폭 수정해야 하거나 일부분은 merge를 해야해서 쉬운 일이 아니였다. 그래도 일단 시작은 해봐야하기 때문에 어떻게 나눌지부터 우선순위로 정하였다. 일단 첫 부분으로 

패키지를 나누는 작업, model(점수, 수강생, 과목을 각각 map에 저장), Management(비즈니스 로직), display(사용자 메뉴 제공)로 3개의 패키지로 나누었으며 밑글에서 보다 자세한 설명으로 다룰것이다.

 

패키지 구조

1. camp.model:
   • 목적: 프로젝트의 핵심 데이터 모델을 정의하는 패키지입니다. 데이터와 관련된 클래스를 포함하여 비즈니스 로직에서 사용할 데이터를 관리합니다.
   • 주요 클래스:
     • Student: 수강생의 정보를 저장합니다.
     • Subject: 과목 정보를 저장합니다.
     • Score: 수강생의 점수와 관련된 정보를 저장합니다.
     • StudentMap, SubjectMap, ScoreMap: 각각 수강생, 과목, 점수의 데이터를 관리하는 맵을 정의합니다.
2. camp.Management:
   • 목적: 비즈니스 로직을 처리하는 관리 클래스들을 포함합니다. 각 기능별로 책임을 분리하여 코드의 유지보수성과 확장성을 높입니다.
   • 주요 클래스:
     • StudentManagement: 수강생의 등록, 수정, 삭제 등의 기능을 제공합니다.
     • ScoreManagement: 점수의 등록, 수정, 조회 등의 기능을 제공합니다.
3. camp.display:
   • 목적: 사용자와의 상호작용을 처리하는 클래스들을 포함합니다. 사용자에게 메뉴를 제공하고 입력을 처리하여 비즈니스 로직을 호출합니다.
   • 주요 클래스:
     • MainDisplay: 프로그램의 메인 화면을 관리하며, 수강생 관리와 점수 관리 메뉴로 이동할 수 있게 합니다.
     • StudentDisplay: 수강생 관련 기능의 메뉴를 제공하며, 수강생의 등록, 조회, 수정, 삭제 등의 기능을 처리합니다.
     • ScoreDisplay: 점수 관련 기능의 메뉴를 제공하며, 점수 등록, 수정, 조회 등의 기능을 처리합니다.

이렇게 패키지를 나누고 private로 캡슐화로 시켜 데이터 은닉을하고 비슷한 기능을 가진 클래스들을 모아 응집력을 높여 객체지향성을 높였다. 보다 자세한 설명은 밑글에 작성하였다.

객체지향 설계 원칙

1. 책임 분리 (Single Responsibility Principle):
   • 패키지 및 클래스 분리: 각 패키지와 클래스는 특정 책임만을 가지도록 설계되었습니다. 예를 들어, StudentManagement는 수강생의 관리 책임만을 가지고, ScoreManagement는 점수 관리만을 책임집니다.
   • 메서드 책임: 메서드는 명확한 기능을 수행하며, 각 메서드가 하나의 작업만을 처리하도록 설계되었습니다.
2. 캡슐화 (Encapsulation):
   • 데이터 은닉: 클래스 내부의 데이터는 private으로 선언되어 외부에서 직접 접근할 수 없도록 하고, 필요한 경우 public 메서드를 통해 접근하도록 설계되었습니다.
   • 메서드 사용: 데이터를 조작하는 메서드는 해당 데이터와 관련된 로직만을 포함하도록 설계되어 있습니다. 예를 들어, Student 클래스는 수강생의 정보와 관련된 메서드만을 포함합니다.
3. 상속과 다형성 (Inheritance and Polymorphism):
   • 현재 코드에서는 명시적인 상속 관계는 보이지 않지만, Student, Subject, Score 등의 클래스는 추후 상속을 고려하여 설계될 수 있습니다. 예를 들어, 공통 기능을 가진 상위 클래스가 있을 경우 이를 상속받아 기능을 확장할 수 있습니다.
4. 의존성 주입 (Dependency Injection):
   • 패키지 간 의존성 관리: StudentDisplay와 ScoreDisplay 클래스는 StudentManagement와 ScoreManagement 클래스의 인스턴스를 생성하여 사용합니다. 이는 클래스 간의 의존성을 명확히 하고, 필요에 따라 인스턴스를 교체하거나 테스트하기 용이하게 합니다.
5. 모듈화 (Modularity):
   • 패키지 및 클래스 분리: 프로젝트는 기능에 따라 패키지와 클래스를 나누어 모듈화되어 있습니다. 각 패키지와 클래스는 독립적으로 관리되고, 변경이나 확장이 필요할 때 영향을 최소화할 수 있도록 설계되었습니다.
6. 응집력 (Cohesion):
   • 클래스와 메서드 응집: 클래스는 관련된 기능을 함께 묶어 두어 높은 응집력을 가지며, 메서드 또한 하나의 작업을 명확히 수행하여 응집력을 높입니다.

결론

이 프로젝트는 객체지향 설계 원칙을 잘 따르고 있으며, 기능별로 책임을 분리하고 데이터와 로직을 잘 캡슐화하여 유지보수성과 확장성을 높였다. 패키지와 클래스를 명확하게 나누어 모듈화하고, 각 클래스와 메서드가 명확한 책임을 가지도록 설계되었다. 이러한 설계는 코드의 가독성, 유지보수성, 확장성을 개선하는 데 기여한다.

 

Model

Score (기존과 동일) ScoreMap (store를 내부 필드로 넣고, 안에서 관리하도록. 초기화 및 값 추가, 수정 모두 내부 메소드로 구현) Student (기존과 동일) StudentMap (store를 내부 필드로 넣고, 안에서 관리하도록. 초기화 및 값 추가, 수정 모두 내부 메소드로 구현) Subject (기존과 동일) SubjectMap (store를 내부 필드로 넣고, 안에서 관리하도록, 이건 set은 필요없고 get만 구현하면 된다.)

 

## checkAndUpdate (우리 기존의 Check와 update를 합쳤음, 공통 부분은 UpdateManagement에서 상속받고, 고유 기능은 각자 클래스에서 구현)

C. UpdateManagement
C. UpdateScoreManagement extends UpdateManagement
C. UpdateStudentManagement extends UpdateManagement

 

View

MainDisplay (메인화면, 전체 과목 리스트, 수강생 리스트, 수강중인 리스트 출력 함수 총 4개 위치)
MainScoreManagement (score 메인 화면, 전체회차, 특정과목, 현등록 조회 함수 위치)
MainStudentManagement (student 메인 화면, 전체 수강생, 상태 수강생, 학생 개별 출력 함수 위치)
Management (Score, Student 출력을 display, inquireAll, inquireByCon, print로 구분해서 인터페이스화)

 

 

Package camp

CampManagementApplication

package camp;

import camp.display.MainDisplay;
import camp.model.*;

public class CampManagementApplication {
    public static void main(String[] args) throws InterruptedException {
        Init();
    }

    public static void Init() throws InterruptedException {
        // 수강생, 과목, 점수 관리 객체 생성
        StudentMap studentMap = new StudentMap();
        SubjectMap subjectMap = new SubjectMap();
        ScoreMap scoreMap = new ScoreMap();

        // 메인 메뉴 호출
        MainDisplay.displayMainView(studentMap,subjectMap,scoreMap);
    }
}

 

패키지 및 임포드

package camp;

import camp.display.MainDisplay;
import camp.model.*;

 

패키지 선언 (package camp;): camp라는 패키지에 속하는 클래스를 정의합니다. 패키지는 클래스를 조직하는 방법 중 하나입니다.

 

임포트 문 (import ...): 다른 패키지에 있는 클래스를 사용하기 위해 import합니다.

• camp.display.MainDisplay: MainDisplay 클래스를 임포트합니다. 이 클래스는 메인 메뉴를 표시하는 기능을 제공할 것으로 예상됩니다.
• camp.model.*: camp.model 패키지의 모든 클래스를 임포트합니다. 이 패키지에는 StudentMap, SubjectMap, ScoreMap이 포함되어 있을 것으로 보입니다.

 

CampManagementApplication 클래스

메인 클래스 

public class CampManagementApplication {
    public static void main(String[] args) throws InterruptedException {
        Init();
    }
    
    public static void Init() throws InterruptedException {
        // 수강생, 과목, 점수 관리 객체 생성
        StudentMap studentMap = new StudentMap();
        SubjectMap subjectMap = new SubjectMap();
        ScoreMap scoreMap = new ScoreMap();

        // 메인 메뉴 호출
        MainDisplay.displayMainView(studentMap, subjectMap, scoreMap);
    }
}

클래스 정의 (public class CampManagementApplication)

• CampManagementApplication 클래스는 애플리케이션의 시작점 역할을 합니다.

main 메서드 (public static void main(String[] args))

• public static void main(String[] args): Java 애플리케이션의 진입점입니다. Java 가상 머신(JVM)은 프로그램을 실행할 때 이 메서드를 호출합니다.
• throws InterruptedException: main 메서드는 InterruptedException을 던질 수 있습니다. 이는 Init 메서드에서 발생할 수 있는 예외를 전파하기 위한 것입니다. (현재 Init 메서드에서 InterruptedException을 던지지만 실제로는 별도의 스레드나 대기 작업이 없기 때문에 이 예외는 필요 없을 수 있습니다.)
• Init();: Init 메서드를 호출하여 애플리케이션을 초기화합니다.

Init 메서드 (public static void Init() throws InterruptedException)

• public static void Init(): 애플리케이션을 초기화하는 메서드입니다.
• throws InterruptedException: 이 메서드는 InterruptedException을 던질 수 있으며, 이는 main 메서드에서 이를 처리하거나 전파할 수 있음을 나타냅니다.

 

객체 생성

StudentMap studentMap = new StudentMap();
SubjectMap subjectMap = new SubjectMap();
ScoreMap scoreMap = new ScoreMap();

 

 

StudentMap studentMap: 학생 데이터를 관리할 객체입니다.

SubjectMap subjectMap: 과목 데이터를 관리할 객체입니다.

ScoreMap scoreMap: 점수 데이터를 관리할 객체입니다.

이 객체들은 camp.model 패키지에 정의된 클래스들이며, 각각 학생, 과목, 점수와 관련된 데이터를 처리하는 역할을 합니다.

 

메인 메뉴 호출

MainDisplay.displayMainView(studentMap, subjectMap, scoreMap);

 

 

MainDisplay.displayMainView: MainDisplay 클래스의 정적 메서드를 호출하여 메인 메뉴를 표시합니다. 이 메서드는 studentMap, subjectMap, scoreMap 객체를 인수로 받아, 사용자가 데이터를 조회하거나 수정할 수 있는 인터페이스를 제공합니다.

 

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(int index, int score) {
        setScore(index, score);
    }

    public int[] getScores() {
        return scores;
    }

    public void setScore(int index, int score) {
        scores[index - 1] = score;
    }

    public boolean checkScore(int index) {
        if (scores[index - 1] == -1) return false;
        return true;
    }
}

 

필드

private int[] scores = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};

 

scores 배열: 10개의 정수 값을 저장하는 배열입니다. 초기값으로 모든 요소를 -1로 설정하여 점수가 설정되지 않았음을 나타냅니다. 일반적으로 -1은 점수가 없는 상태를 표시하는 데 사용됩니다.

 

생성자

public Score(int index, int score) {
    setScore(index, score);
}

 

Score(int index, int score): 두 개의 파라미터(index, score)를 받는 생성자입니다. 이 생성자는 객체가 생성될 때 setScore 메서드를 호출하여 특정 인덱스에 점수를 설정합니다.

 

메서드

getScores 메서드

public int[] getScores() {
    return scores;
}

기능: scores 배열을 반환합니다. 이 메서드는 배열에 저장된 모든 점수 정보를 외부에서 읽을 수 있게 해줍니다.

 

setScore 메서드

public void setScore(int index, int score) {
    scores[index - 1] = score;
}

 

• 기능: 주어진 index(1부터 시작하는 인덱스)와 score 값을 받아 scores 배열의 해당 인덱스에 점수를 설정합니다.
• 인덱스 조정: 배열의 인덱스는 0부터 시작하므로, 메서드는 index - 1을 사용하여 배열의 올바른 위치에 점수를 설정합니다.

 

checkScore 메서드

public boolean checkScore(int index) {
    if (scores[index - 1] == -1) return false;
    return true;
}

 

 

• 기능: 주어진 index(1부터 시작하는 인덱스)의 점수가 설정되었는지 확인합니다.
• 작동 방식: scores[index - 1]의 값이 -1이면 점수가 설정되지 않은 상태이므로 false를 반환합니다. 그렇지 않으면 true를 반환합니다.

 

package camp.model

ScoreMap.class

 

package camp.model;

import java.util.*;

public class ScoreMap {
    public Map<String, Map<String, Score>> scoreStore; // < 수강생 고유 번호, < 과목 고유 번호, 점수 객체 > >
    public int scoreIndex; // 고유 번호 인덱스

    public ScoreMap() {
        this.scoreIndex = 0;
        this.scoreStore = new HashMap<>();
    }

    // 수강중인 과목 Map 반환
    public Map<String, Score> getStudent(String studentId) {
        return this.scoreStore.get(studentId);
    }

    // 점수 등록
    public void setScoreStore(String studentId, String subjectId, String index, String score) {
        Map<String, Score> inner = new HashMap<>();

        // 해당 과목에 점수가 동록된 적이 없는경우 새로운 Score 객체 생성 후 점수 등록
        if (!scoreStore.containsKey(studentId) || !scoreStore.get(studentId).containsKey(subjectId)) {
            inner.put(subjectId, new Score(Integer.parseInt(index), Integer.parseInt(score)));
            scoreStore.put(studentId, inner);
        // 해당 회차에 이미 점수가 등록되어 있는 경우 등록 실패
        } else if (scoreStore.get(studentId).get(subjectId).checkScore(Integer.parseInt(index))) {
            System.out.println("* 해당 회차의 점수가 이미 등록되어 있습니다 *");
            System.out.println("============점수 등록 실패============");
            return;
        } else {
            scoreStore.get(studentId).get(subjectId).setScore(Integer.parseInt(index), Integer.parseInt(score));
        }
        System.out.println("============점수 등록 성공============");
        System.out.println("수강생 : " + studentId);
        System.out.println("과목 : " + subjectId);
        System.out.println("회차 : " + index);
        System.out.println("점수 : " + score);
        System.out.println("====================================");
    }

    // 점수 수정
    public void updateScoreStore(String studentId, String subjectId, String index, String score) {
        // 등록된 점수가 없는 경우 수정 실패
        if (!scoreStore.get(studentId).get(subjectId).checkScore(Integer.parseInt(index))) {
            System.out.println("* 해당 회차에 등록된 점수가 없습니다 *");
            System.out.println("============점수 수정 실패============");
        } else {
            scoreStore.get(studentId).get(subjectId).setScore(Integer.parseInt(index), Integer.parseInt(score));
            System.out.println("============점수 수정 성공============");
            System.out.println("수강생 : " + studentId);
            System.out.println("과목 : " + subjectId);
            System.out.println("회차 : " + index);
            System.out.println("점수 : " + score);
            System.out.println("====================================");
        }
    }
}

 

 

필드

public Map<String, Map<String, Score>> scoreStore; // < 수강생 고유 번호, < 과목 고유 번호, 점수 객체 > >
public int scoreIndex; // 고유 번호 인덱스

 

 

scoreStore: 학생 고유 번호를 키로 하고, 그 학생의 각 과목 고유 번호와 점수를 Score 객체로 저장하는 Map입니다. 이중 Map 구조를 사용하여 학생 ID를 기준으로 각 과목의 점수를 관리합니다.

• 키: 학생 고유 번호 (studentId)
• 값: 과목 고유 번호와 점수 객체 (Map<String, Score>)

scoreIndex: 점수의 인덱스를 관리하는 필드입니다. 현재 코드에서는 사용되고 있지 않지만, 점수의 고유 번호를 관리하는 데 사용할 수 있습니다.

 

생성자

public ScoreMap() {
    this.scoreIndex = 0;
    this.scoreStore = new HashMap<>();
}

 

 

기능: ScoreMap 객체를 생성할 때 호출됩니다. scoreIndex를 0으로 초기화하고, scoreStore를 새로운 HashMap으로 초기화합니다. 이를 통해 점수 데이터 저장소가 초기화됩니다.

 

메서드

getStudent 메서드

public Map<String, Score> getStudent(String studentId) {
    return this.scoreStore.get(studentId);
}

기능: 주어진 studentId에 해당하는 학생의 과목 점수 정보를 반환합니다. 반환값은 해당 학생의 각 과목과 점수 객체를 포함하는 Map입니다.

 

setScoreStore 메서드

public void setScoreStore(String studentId, String subjectId, String index, String score) {
    Map<String, Score> inner = new HashMap<>();

    if (!scoreStore.containsKey(studentId) || !scoreStore.get(studentId).containsKey(subjectId)) {
        inner.put(subjectId, new Score(Integer.parseInt(index), Integer.parseInt(score)));
        scoreStore.put(studentId, inner);
    } else if (scoreStore.get(studentId).get(subjectId).checkScore(Integer.parseInt(index))) {
        System.out.println("* 해당 회차의 점수가 이미 등록되어 있습니다 *");
        System.out.println("============점수 등록 실패============");
        return;
    } else {
        scoreStore.get(studentId).get(subjectId).setScore(Integer.parseInt(index), Integer.parseInt(score));
    }
    System.out.println("============점수 등록 성공============");
    System.out.println("수강생 : " + studentId);
    System.out.println("과목 : " + subjectId);
    System.out.println("회차 : " + index);
    System.out.println("점수 : " + score);
    System.out.println("====================================");
}

 

기능: 특정 학생(studentId)과 과목(subjectId)에 대해 점수를 등록하거나 갱신합니다.

등록 절차:

• 학생이 scoreStore에 존재하지 않거나 해당 과목이 학생의 점수 목록에 없는 경우, 새로운 Score 객체를 생성하여 점수를 등록합니다.
• 학생의 점수 목록에 과목이 이미 존재하고, 지정된 회차에 점수가 이미 등록되어 있는 경우, 점수 등록을 실패합니다.
• 점수가 등록되지 않은 경우, 점수를 갱신합니다.

출력: 점수 등록 성공 또는 실패 메시지를 출력합니다.

 

updateScoreStore 메서드

public void updateScoreStore(String studentId, String subjectId, String index, String score) {
    if (!scoreStore.get(studentId).get(subjectId).checkScore(Integer.parseInt(index))) {
        System.out.println("* 해당 회차에 등록된 점수가 없습니다 *");
        System.out.println("============점수 수정 실패============");
    } else {
        scoreStore.get(studentId).get(subjectId).setScore(Integer.parseInt(index), Integer.parseInt(score));
        System.out.println("============점수 수정 성공============");
        System.out.println("수강생 : " + studentId);
        System.out.println("과목 : " + subjectId);
        System.out.println("회차 : " + index);
        System.out.println("점수 : " + score);
        System.out.println("====================================");
    }
}

 

 

 

기능: 기존에 등록된 점수를 수정합니다.

수정 절차:

점수가 등록되어 있지 않은 경우, 수정 실패 메시지를 출력합니다.

• 등록된 점수가 있는 경우, 새로운 점수로 업데이트합니다.

출력: 점수 수정 성공 또는 실패 메시지를 출력합니다.

 

 

package camp.model

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;
private String studentName;
private String studentState; // 수강생 상태
private final ArrayList<String> subjectList; // 수강 과목

 

• studentId: 학생의 고유 식별자입니다. final로 선언되어 있어, 객체 생성 후 변경할 수 없습니다.
• studentName: 학생의 이름입니다. 객체 생성 후에 수정할 수 있습니다.
• studentState: 학생의 상태를 나타내는 문자열입니다 (예: "등록", "휴학", "졸업" 등). 객체 생성 후에 수정할 수 있습니다.
• subjectList: 학생이 수강 중인 과목들의 목록을 저장하는 ArrayList입니다. final로 선언되어 있어 객체 생성 시 초기화되며, 과목 목록을 추가하거나 수정할 수 있습니다.

생성자

public Student(String studentId, String studentName, String studentState, ArrayList<String> subjectList) {
    this.studentId = studentId;
    this.studentName = studentName;
    this.studentState = studentState;
    this.subjectList = subjectList;
}

 

 

기능: Student 객체를 생성할 때 호출됩니다. 학생의 ID, 이름, 상태, 수강 과목 목록을 초기화합니다.

매개변수:

• studentId: 학생의 고유 식별자.
• studentName: 학생의 이름.
• studentState: 학생의 상태.
• subjectList: 학생이 수강 중인 과목들의 목록.

 

메서드

getStudentId 메서드

public String getStudentId() {
    return studentId;
}

• 기능: 학생의 이름을 반환합니다.

 

getStudentState 메서드

public String getStudentState() {
    return studentState;
}

• 기능: 학생의 상태를 반환합니다.

setStudentName 메서드

public void setStudentName(String studentName) {
    this.studentName = studentName;
}

• 기능: 학생의 이름을 설정합니다.

setStudentState 메서드

public void setStudentState(String studentState) {
    this.studentState = studentState;
}

• 기능: 학생이 수강 중인 과목들의 목록을 반환합니다.

getSubjectList 메서드

public ArrayList<String> getSubjectList() {
    return subjectList;
}

• 기능: 학생이 수강 중인 과목들의 목록을 반환합니다.

 

package camp.model

StudentMap.class

package camp.model;

import java.util.*;

public class StudentMap {
    public Map<String, Student> studentStore; // < 수강생 고유 번호, 수강생 객체 >
    public int studentIndex; // 고유 번호 인덱스
    public static final String INDEX_TYPE_STUDENT = "ST"; // 수강생 코드

    public StudentMap() {
        studentStore = new HashMap<>();
        this.studentIndex = 0;
    }

    // 수강생 고유 번호 생성
    public String studentSequence() {
        this.studentIndex++;
        return INDEX_TYPE_STUDENT + studentIndex;
    }

    // Map에 저장
    public void set_Store(String studentId, String studentName, String studentState, ArrayList<String> getSubject) {
        Student student = new Student(studentId, studentName, studentState, getSubject); // 이름과 수강중인 과목 리스트를 담은 객체 생성
        this.studentStore.put(studentId, student); // Map에 저장
    }

    // 수강생 전체 출력
    public void printStudentInfo() {
        Set<String> keys = getKeys();
        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 Student getStudent(String studentId) {
        return this.studentStore.get(studentId);
    }

    // 수강생 삭제
    public void deleteKey(String Key) {
        this.studentStore.remove(Key);
        if (!this.studentStore.containsKey(Key))
            System.out.println("삭제 완료되었습니다.");
    }

    // Map 비어있는지 체크
    public boolean checkEmpty() {
        return this.studentStore.isEmpty();
    }

    // 전체 키 반환
    public Set<String> getKeys() {
        return this.studentStore.keySet();
    }

    // 상태 확인
    public boolean checkState(String key, String type) {
        return this.studentStore.get(key).getStudentState().equals(type);
    }
}

 

필드

public Map<String, Student> studentStore; // < 수강생 고유 번호, 수강생 객체 >
public int studentIndex; // 고유 번호 인덱스
public static final String INDEX_TYPE_STUDENT = "ST"; // 수강생 코드

 

studentStore: 학생의 고유 번호를 키로 하고, 학생 객체를 값으로 저장하는 Map입니다. 이 구조를 통해 학생 정보를 관리합니다.

• 키: 학생 고유 번호 (studentId)
• 값: Student 객체

studentIndex: 학생의 고유 번호를 생성하기 위한 인덱스입니다. 학생 번호는 INDEX_TYPE_STUDENT와 studentIndex 값을 결합하여 생성됩니다.

INDEX_TYPE_STUDENT: 학생 고유 번호의 접두사로 사용되는 상수입니다. 학생 번호를 생성할 때 접두사로 ST를 사용합니다.

 

생성자

public StudentMap() {
    studentStore = new HashMap<>();
    this.studentIndex = 0;
}

 

• 기능: StudentMap 객체를 생성할 때 호출됩니다. studentStore를 새로운 HashMap으로 초기화하고, studentIndex를 0으로 설정합니다.

 

메서드

studentSequence 메서드

public String studentSequence() {
    this.studentIndex++;
    return INDEX_TYPE_STUDENT + studentIndex;
}

• 기능: 학생의 고유 번호를 생성합니다. studentIndex를 증가시킨 후, INDEX_TYPE_STUDENT와 결합하여 고유 번호를 반환합니다.

 

set_Store 메서드

public void set_Store(String studentId, String studentName, String studentState, ArrayList<String> getSubject) {
    Student student = new Student(studentId, studentName, studentState, getSubject);
    this.studentStore.put(studentId, student);
}

• 기능: 주어진 학생 ID, 이름, 상태, 수강 과목 목록을 사용하여 새로운 Student 객체를 생성하고, 이를 studentStore에 저장합니다.

printStudentInfo 메서드

public void printStudentInfo() {
    Set<String> keys = getKeys();
    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와 이름을 출력합니다

getStudent 메서드

public Student getStudent(String studentId) {
    return this.studentStore.get(studentId);
}

• 기능: 주어진 학생 ID에 해당하는 Student 객체를 반환합니다.

deleteKey 메서드

public void deleteKey(String Key) {
    this.studentStore.remove(Key);
    if (!this.studentStore.containsKey(Key))
        System.out.println("삭제 완료되었습니다.");
}

 

• 기능: 주어진 학생 ID에 해당하는 학생 정보를 studentStore에서 삭제합니다. 삭제 완료 메시지를 출력합니다.

checkEmpty 메서드

public boolean checkEmpty() {
    return this.studentStore.isEmpty();
}

• 기능: studentStore가 비어 있는지 확인합니다. 비어 있으면 true, 그렇지 않으면 false를 반환합니다.

getKeys 메서드

public Set<String> getKeys() {
    return this.studentStore.keySet();
}

• 기능: studentStore에 저장된 모든 학생 ID(키)를 반환합니다.

checkState 메서드

public boolean checkState(String key, String type) {
    return this.studentStore.get(key).getStudentState().equals(type);
}

• 기능: 주어진 학생 ID에 해당하는 학생의 상태가 지정된 상태와 일치하는지 확인합니다. 일치하면 true, 그렇지 않으면 false를 반환합니다.

 

package camp.model

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;
private final String subjectName;
private final String subjectType;

 

• subjectId: 과목의 고유 식별자입니다. final로 선언되어 있어 객체 생성 후 변경할 수 없습니다.
• subjectName: 과목의 이름입니다. final로 선언되어 있어 객체 생성 후 변경할 수 없습니다.
• subjectType: 과목의 유형을 나타내는 문자열입니다. 예를 들어, "이론", "실습", "세미나" 등의 유형이 될 수 있습니다. final로 선언되어 있어 객체 생성 후 변경할 수 없습니다.

생성자

public Subject(String seq, String subjectName, String subjectType) {
    this.subjectId = seq;
    this.subjectName = subjectName;
    this.subjectType = subjectType;
}

 

 

 

기능: Subject 객체를 생성할 때 호출됩니다. 주어진 과목 ID, 이름, 유형을 사용하여 객체를 초기화합니다.

매개변수:

• seq: 과목의 고유 식별자.
• subjectName: 과목의 이름.
• subjectType: 과목의 유형.

메서드

getSubjectName 메서드

public String getSubjectName() {
    return subjectName;
}

 

 

• 기능: 과목의 이름을 반환합니다.

getSubjectType 메서드

public String getSubjectType() {
    return subjectType;
}

 

• 기능: 과목의 유형을 반환합니다.

 

 

package camp.model

SubjectMap.class

과목의 정보를 나타내는 데이터 구조

package camp.model;

import java.util.*;

public class SubjectMap {
    public Map<String, Subject> subjectStore; // < 과목 고유번호, 과목 객체 >
    public int subjectIndex; // 고유 번호 인덱스

    // 과목 타입
    public final String SUBJECT_TYPE_MANDATORY = "MANDATORY";
    public final String SUBJECT_TYPE_CHOICE = "CHOICE";
    public final String INDEX_TYPE_SUBJECT = "SU";

    // 초기화 할 때 모든 과목을 subjectStore에 저장
    public SubjectMap() {
        subjectStore = new HashMap<>();
        this.subjectIndex = 0;

        String subjectId = subjectSequence();
        subjectStore.put(subjectId, new Subject(subjectId, "Java", SUBJECT_TYPE_MANDATORY));
        subjectId = subjectSequence();
        subjectStore.put(subjectId, new Subject(subjectId, "객체지향", SUBJECT_TYPE_MANDATORY));
        subjectId = subjectSequence();
        subjectStore.put(subjectId, new Subject(subjectId, "Spring", SUBJECT_TYPE_MANDATORY));
        subjectId = subjectSequence();
        subjectStore.put(subjectId, new Subject(subjectId, "JPA", SUBJECT_TYPE_MANDATORY));
        subjectId = subjectSequence();
        subjectStore.put(subjectId, new Subject(subjectId, "MySQL", SUBJECT_TYPE_MANDATORY));
        subjectId = subjectSequence();
        subjectStore.put(subjectId, new Subject(subjectId, "디자인 패턴", SUBJECT_TYPE_CHOICE));
        subjectId = subjectSequence();
        subjectStore.put(subjectId, new Subject(subjectId, "Spring Security", SUBJECT_TYPE_CHOICE));
        subjectId = subjectSequence();
        subjectStore.put(subjectId, new Subject(subjectId, "Redis", SUBJECT_TYPE_CHOICE));
        subjectId = subjectSequence();
        subjectStore.put(subjectId, new Subject(subjectId, "MongoDB", SUBJECT_TYPE_CHOICE));
    }

    // 과목 고유 번호 생성
    public String subjectSequence() {
        subjectIndex++;
        return INDEX_TYPE_SUBJECT + subjectIndex;
    }

    // 지정된 번호로 과목 고유 번호 생성
    public String makeSequence(String val) {
        return INDEX_TYPE_SUBJECT + val;
    }

    // 필수 과목 리스트 생성
    public void makeManSubject(String val, ArrayList<String> getSubject) {
        Subject useSubject = this.subjectStore.get(val);
        if (!useSubject.getSubjectType().equals(SUBJECT_TYPE_MANDATORY)) //타 과목시 예외처리
            throw new IllegalArgumentException();
        getSubject.add(val);
    }

    // 선택 과목 리스트 생성
    public void makeSubSubject(String val, ArrayList<String> getSubject) {
        Subject useSubject = this.subjectStore.get(val);
        if (!useSubject.getSubjectType().equals(SUBJECT_TYPE_CHOICE)) //타 과목시 예외처리
            throw new IllegalArgumentException();
        getSubject.add(val);
    }

    // 수강중인 과목 전체 출력
    public void printSubjectInfoByStudentId(StudentMap studentMap, String studentId) {
        ArrayList<String> list = studentMap.studentStore.get(studentId).getSubjectList();
        System.out.println("==========수강중인 과목 리스트=========");
        for (String s : list) {
            System.out.println(s + " : " + subjectStore.get(s).getSubjectName());
        }
        System.out.println("====================================");
    }

    // 고유 번호에 매칭된 과목 반환
    public Subject getSubject(String code) {
        return this.subjectStore.get(code);
    }

    // 필수 과목 체크
    public boolean check_MANDATORY(Subject useSubject) {
        return useSubject.getSubjectType().equals(SUBJECT_TYPE_MANDATORY);
    }

    // 선택 과목 체크
    public boolean check_CHOICE(Subject useSubject) {
        return useSubject.getSubjectType().equals(SUBJECT_TYPE_CHOICE);
    }

    // 필수 과목 등급 계산
    public String gradeMandatory(int score) {
        if (score > 94) {
            return "A";
        } else if (score > 89) {
            return "B";
        } else if (score > 79) {
            return "C";
        } else if (score > 69) {
            return "D";
        } else if (score > 59) {
            return "F";
        } else {
            return "N";
        }
    }

    // 선택 과목 등급 계산
    public String gradeChoice(int score) {
        if (score > 89) {
            return "A";
        } else if (score > 79) {
            return "B";
        } else if (score > 69) {
            return "C";
        } else if (score > 59) {
            return "D";
        } else if (score > 49) {
            return "F";
        } else {
            return "N";
        }
    }

    // 과목 분류 확인
    public boolean checkSubjectType(String subjectId) {
        Subject subject = subjectStore.get(subjectId);
        if (subject.getSubjectType().equals("MANDATORY")) return true;
        return false;
    }
}

 

필드

public Map<String, Subject> subjectStore; // < 과목 고유번호, 과목 객체 >
public int subjectIndex; // 고유 번호 인덱스

// 과목 타입
public final String SUBJECT_TYPE_MANDATORY = "MANDATORY";
public final String SUBJECT_TYPE_CHOICE = "CHOICE";
public final String INDEX_TYPE_SUBJECT = "SU";

 

subjectStore: 과목의 고유 번호를 키로 하고, 과목 객체를 값으로 저장하는 Map입니다.

• 키: 과목 고유 번호 (subjectId)
• 값: Subject 객체

subjectIndex: 과목 고유 번호를 생성하기 위한 인덱스입니다.

SUBJECT_TYPE_MANDATORY: 필수 과목을 나타내는 상수입니다.

SUBJECT_TYPE_CHOICE: 선택 과목을 나타내는 상수입니다.

INDEX_TYPE_SUBJECT: 과목 고유 번호의 접두사입니다.

 

생성자

public SubjectMap() {
    subjectStore = new HashMap<>();
    this.subjectIndex = 0;

    // 초기화 시 기본 과목 등록
    String subjectId = subjectSequence();
    subjectStore.put(subjectId, new Subject(subjectId, "Java", SUBJECT_TYPE_MANDATORY));
    subjectId = subjectSequence();
    subjectStore.put(subjectId, new Subject(subjectId, "객체지향", SUBJECT_TYPE_MANDATORY));
    subjectId = subjectSequence();
    subjectStore.put(subjectId, new Subject(subjectId, "Spring", SUBJECT_TYPE_MANDATORY));
    subjectId = subjectSequence();
    subjectStore.put(subjectId, new Subject(subjectId, "JPA", SUBJECT_TYPE_MANDATORY));
    subjectId = subjectSequence();
    subjectStore.put(subjectId, new Subject(subjectId, "MySQL", SUBJECT_TYPE_MANDATORY));
    subjectId = subjectSequence();
    subjectStore.put(subjectId, new Subject(subjectId, "디자인 패턴", SUBJECT_TYPE_CHOICE));
    subjectId = subjectSequence();
    subjectStore.put(subjectId, new Subject(subjectId, "Spring Security", SUBJECT_TYPE_CHOICE));
    subjectId = subjectSequence();
    subjectStore.put(subjectId, new Subject(subjectId, "Redis", SUBJECT_TYPE_CHOICE));
    subjectId = subjectSequence();
    subjectStore.put(subjectId, new Subject(subjectId, "MongoDB", SUBJECT_TYPE_CHOICE));
}

• 기능: SubjectMap 객체를 생성할 때 호출되며, subjectStore를 초기화하고 몇 가지 기본 과목을 등록합니다.

 

메서드

subjectSequence 메서드

public String subjectSequence() {
    subjectIndex++;
    return INDEX_TYPE_SUBJECT + subjectIndex;
}

• 기능: 새로운 과목의 고유 번호를 생성합니다. subjectIndex를 증가시킨 후, INDEX_TYPE_SUBJECT와 결합하여 과목 ID를 반환합니다.

 

makeSequence 메서드

public String makeSequence(String val) {
    return INDEX_TYPE_SUBJECT + val;
}

• 기능: 지정된 값에 접두사를 붙여서 과목의 고유 번호를 생성합니다.

makeManSubject 메서드

public void makeManSubject(String val, ArrayList<String> getSubject) {
    Subject useSubject = this.subjectStore.get(val);
    if (!useSubject.getSubjectType().equals(SUBJECT_TYPE_MANDATORY)) //타 과목시 예외처리
        throw new IllegalArgumentException();
    getSubject.add(val);
}

• 기능: 주어진 과목 ID가 필수 과목(MANDATORY)인지 확인하고, 맞다면 해당 과목 ID를 목록에 추가합니다. 그렇지 않으면 예외를 발생시킵니다.

 

makeSubSubject 메서드

public void makeSubSubject(String val, ArrayList<String> getSubject) {
    Subject useSubject = this.subjectStore.get(val);
    if (!useSubject.getSubjectType().equals(SUBJECT_TYPE_CHOICE)) //타 과목시 예외처리
        throw new IllegalArgumentException();
    getSubject.add(val);
}

• 기능: 주어진 과목 ID가 선택 과목(CHOICE)인지 확인하고, 맞다면 해당 과목 ID를 목록에 추가합니다. 그렇지 않으면 예외를 발생시킵니다.

printSubjectInfoByStudentId 메서드

public void printSubjectInfoByStudentId(StudentMap studentMap, String studentId) {
    ArrayList<String> list = studentMap.studentStore.get(studentId).getSubjectList();
    System.out.println("==========수강중인 과목 리스트=========");
    for (String s : list) {
        System.out.println(s + " : " + subjectStore.get(s).getSubjectName());
    }
    System.out.println("====================================");
}

• 기능: 주어진 학생 ID에 해당하는 학생이 수강 중인 과목을 출력합니다.

getSubject 메서드

public Subject getSubject(String code) {
    return this.subjectStore.get(code);
}

• 기능: 주어진 과목 ID에 해당하는 Subject 객체를 반환합니다.

check_MANDATORY 메서드

public boolean check_MANDATORY(Subject useSubject) {
    return useSubject.getSubjectType().equals(SUBJECT_TYPE_MANDATORY);
}

• 기능: 주어진 Subject 객체가 필수 과목인지 확인합니다.

check_CHOICE 메서드

public boolean check_CHOICE(Subject useSubject) {
    return useSubject.getSubjectType().equals(SUBJECT_TYPE_CHOICE);
}

• 기능: 주어진 Subject 객체가 선택 과목인지 확인합니다.

gradeMandatory 메서드

public String gradeMandatory(int score) {
    if (score > 94) {
        return "A";
    } else if (score > 89) {
        return "B";
    } else if (score > 79) {
        return "C";
    } else if (score > 69) {
        return "D";
    } else if (score > 59) {
        return "F";
    } else {
        return "N";
    }
}

• 기능: 필수 과목의 점수에 따라 등급을 계산합니다. 점수 범위에 따라 "A", "B", "C", "D", "F", "N" 중 하나를 반환합니다.

gradeChoice 메서드

public String gradeChoice(int score) {
    if (score > 89) {
        return "A";
    } else if (score > 79) {
        return "B";
    } else if (score > 69) {
        return "C";
    } else if (score > 59) {
        return "D";
    } else if (score > 49) {
        return "F";
    } else {
        return "N";
    }
}

• 기능: 선택 과목의 점수에 따라 등급을 계산합니다. 점수 범위에 따라 "A", "B", "C", "D", "F", "N" 중 하나를 반환합니다.

 

checkSubjectType 메서드

public boolean checkSubjectType(String subjectId) {
    Subject subject = subjectStore.get(subjectId);
    if (subject.getSubjectType().equals("MANDATORY")) return true;
    return false;
}

• 기능: 주어진 과목 ID에 해당하는 과목이 필수 과목인지 확인합니다. 필수 과목이면 true, 그렇지 않으면 false를 반환합니다.

 

package camp.Management

ScoreManagement.class

package camp.Management;

import camp.model.*;

import java.util.*;


public class ScoreManagement {
    Scanner sc = new Scanner(System.in);

    // 점수 등록
    public void create(StudentManagement studentManagement, StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) {
        System.out.println("==============점수 등록==============");

        // 등록된 수강생이 있는지 확인
        if (studentMap.checkEmpty()) {
            System.out.println("등록된 수강생이 없습니다.");
            return;
        }

        // 수강생 고유 번호 확인
        studentMap.printStudentInfo();
        System.out.print("점수를 등록할 수강생의 고유 번호를 입력하세요 : ");
        String studentId = sc.next();
        Student student = studentMap.getStudent(studentId);
        if (!studentManagement.checkStudentId(student)) {
            System.out.println("============점수 등록 실패============");
            return;
        }

        // 과목 고유 번호 확인
        subjectMap.printSubjectInfoByStudentId(studentMap, studentId);
        System.out.print("점수를 등록할 과목의 고유 번호를 입력하세요 : ");
        String subjectId = sc.next();
        if (!studentManagement.checkSubjectId(student, subjectId)) {
            System.out.println("============점수 등록 실패============");
            return;
        }

        // 등록할 시험 회차 확인
        System.out.print("등록할 시험 회차를 입력하세요 : ");
        String index = sc.next();
        if (!checkTestIndex(index)) {
            System.out.println("============점수 등록 실패============");
            return;
        }

        // 등록할 시험 점수 확인
        System.out.print("점수를 입력하세요 : ");
        String score = sc.next();
        if (!checkTestScore(score)) {
            System.out.println("============점수 등록 실패============");
            return;
        }

        // 점수 등록
        scoreMap.setScoreStore(studentId, subjectId, index, score);
    }

    // 점수 수정
    public void update(StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) {
        System.out.println("==============점수 수정==============");

        // 등록된 수강생이 있는지 확인
        if (studentMap.checkEmpty()) {
            System.out.println("등록된 수강생이 없습니다.");
            return;
        }

        // 수강생 고유 번호 확인
        studentMap.printStudentInfo();
        System.out.print("점수를 수정할 수강생의 고유 번호를 입력하세요 : ");
        String studentId = sc.next();
        Map<String, Score> innerMap = scoreMap.getStudent(studentId);
        if (!checkStudentId(innerMap)) {
            System.out.println("============점수 수정 실패============");
            return;
        }

        // 과목 고유 번호 확인
        subjectMap.printSubjectInfoByStudentId(studentMap, studentId);
        System.out.print("점수를 수정할 과목의 고유 번호를 입력하세요 : ");
        String subjectId = sc.next();
        if (innerMap.get(subjectId) == null) {
            System.out.println("등록된 점수가 없는 과목입니다");
            System.out.println("============점수 수정 실패============");
            return;
        }

        // 수정할 시험 회차 확인
        System.out.print("수정할 시험 회차를 입력하세요 : ");
        String index = sc.next();
        if (!checkTestIndex(index)) {
            System.out.println("============점수 수정 실패============");
            return;
        }

        // 수정할 시험 점수 확인
        System.out.print("점수를 입력하세요 : ");
        String score = sc.next();
        if (!checkTestScore(score)) {
            System.out.println("============점수 수정 실패============");
            return;
        }

        // 점수 수정
        scoreMap.updateScoreStore(studentId, subjectId, index, score);
    }

    // 시험 회차 입력값 검증
    public boolean checkTestIndex(String index) {
        try {
            if (Integer.parseInt(index) < 1 || Integer.parseInt(index) > 10) {
                System.out.println("* 유효하지 않은 시험 회차 *");
                return false;
            }
        } catch (NumberFormatException e) {
            System.out.println("* 유효하지 않은 시험 회차 *");
            return false;
        }
        return true;
    }

    // 시험 점수 입력값 검증
    public boolean checkTestScore(String score) {
        try {
            if (Integer.parseInt(score) < 1 || Integer.parseInt(score) > 100) {
                System.out.println("* 유효하지 않은 시험 점수 *");
                return false;
            }
        } catch (NumberFormatException e) {
            System.out.println("* 유효하지 않은 시험 점수 *");
            return false;
        }
        return true;
    }

    // 수강생 점수 등록 여부 검증
    public boolean checkStudentId(Map<String, Score> innerMap) {
        if (innerMap == null) {
            System.out.println("등록된 점수가 없는 수강생입니다");
            return false;
        }
        return true;
    }
}

 

필드

Scanner sc = new Scanner(System.in);

• sc: 사용자 입력을 처리하기 위한 Scanner 객체입니다.

 

메서드

create 메서드: 점수 등록

public void create(StudentManagement studentManagement, StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) {
    System.out.println("==============점수 등록==============");

    // 등록된 수강생이 있는지 확인
    if (studentMap.checkEmpty()) {
        System.out.println("등록된 수강생이 없습니다.");
        return;
    }

    // 수강생 고유 번호 확인
    studentMap.printStudentInfo();
    System.out.print("점수를 등록할 수강생의 고유 번호를 입력하세요 : ");
    String studentId = sc.next();
    Student student = studentMap.getStudent(studentId);
    if (!studentManagement.checkStudentId(student)) {
        System.out.println("============점수 등록 실패============");
        return;
    }

    // 과목 고유 번호 확인
    subjectMap.printSubjectInfoByStudentId(studentMap, studentId);
    System.out.print("점수를 등록할 과목의 고유 번호를 입력하세요 : ");
    String subjectId = sc.next();
    if (!studentManagement.checkSubjectId(student, subjectId)) {
        System.out.println("============점수 등록 실패============");
        return;
    }

    // 등록할 시험 회차 확인
    System.out.print("등록할 시험 회차를 입력하세요 : ");
    String index = sc.next();
    if (!checkTestIndex(index)) {
        System.out.println("============점수 등록 실패============");
        return;
    }

    // 등록할 시험 점수 확인
    System.out.print("점수를 입력하세요 : ");
    String score = sc.next();
    if (!checkTestScore(score)) {
        System.out.println("============점수 등록 실패============");
        return;
    }

    // 점수 등록
    scoreMap.setScoreStore(studentId, subjectId, index, score);
}

 

기능: 수강생, 과목, 시험 회차, 점수 정보를 입력 받아서 점수를 등록합니다. 유효성 검사를 통해 입력값이 올바른지 확인하고, 점수 등록을 수행합니다.

유효성 검사:

• 수강생 등록 여부 확인
• 수강생 ID 유효성 검사
• 과목 ID 유효성 검사
• 시험 회차 범위 검사
• 점수 범위 검사

update 메서드: 점수 수정

public void update(StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) {
    System.out.println("==============점수 수정==============");

    // 등록된 수강생이 있는지 확인
    if (studentMap.checkEmpty()) {
        System.out.println("등록된 수강생이 없습니다.");
        return;
    }

    // 수강생 고유 번호 확인
    studentMap.printStudentInfo();
    System.out.print("점수를 수정할 수강생의 고유 번호를 입력하세요 : ");
    String studentId = sc.next();
    Map<String, Score> innerMap = scoreMap.getStudent(studentId);
    if (!checkStudentId(innerMap)) {
        System.out.println("============점수 수정 실패============");
        return;
    }

    // 과목 고유 번호 확인
    subjectMap.printSubjectInfoByStudentId(studentMap, studentId);
    System.out.print("점수를 수정할 과목의 고유 번호를 입력하세요 : ");
    String subjectId = sc.next();
    if (innerMap.get(subjectId) == null) {
        System.out.println("등록된 점수가 없는 과목입니다");
        System.out.println("============점수 수정 실패============");
        return;
    }

    // 수정할 시험 회차 확인
    System.out.print("수정할 시험 회차를 입력하세요 : ");
    String index = sc.next();
    if (!checkTestIndex(index)) {
        System.out.println("============점수 수정 실패============");
        return;
    }

    // 수정할 시험 점수 확인
    System.out.print("점수를 입력하세요 : ");
    String score = sc.next();
    if (!checkTestScore(score)) {
        System.out.println("============점수 수정 실패============");
        return;
    }

    // 점수 수정
    scoreMap.updateScoreStore(studentId, subjectId, index, score);
}

 

 

기능: 기존에 등록된 점수를 수정합니다. 점수 등록과 유사하게 유효성 검사를 수행하며, 점수를 수정합니다.

유효성 검사:

• 수강생 등록 여부 확인
• 수강생 ID 유효성 검사
• 과목 ID 유효성 검사
• 시험 회차 범위 검사
• 점수 범위 검사
• 등록된 점수 확인

checkTestIndex 메서드: 시험 회차 입력값 검증

public boolean checkTestIndex(String index) {
    try {
        if (Integer.parseInt(index) < 1 || Integer.parseInt(index) > 10) {
            System.out.println("* 유효하지 않은 시험 회차 *");
            return false;
        }
    } catch (NumberFormatException e) {
        System.out.println("* 유효하지 않은 시험 회차 *");
        return false;
    }
    return true;
}

 

• 기능: 시험 회차가 1에서 10 사이의 값인지 검증합니다. 잘못된 입력에 대해 오류 메시지를 출력합니다.

checkTestScore 메서드: 시험 점수 입력값 검증

public boolean checkTestScore(String score) {
    try {
        if (Integer.parseInt(score) < 1 || Integer.parseInt(score) > 100) {
            System.out.println("* 유효하지 않은 시험 점수 *");
            return false;
        }
    } catch (NumberFormatException e) {
        System.out.println("* 유효하지 않은 시험 점수 *");
        return false;
    }
    return true;
}

 

• 기능: 점수가 1에서 100 사이의 값인지 검증합니다. 잘못된 입력에 대해 오류 메시지를 출력합니다.

checkStudentId 메서드: 수강생 점수 등록 여부 검증

public boolean checkStudentId(Map<String, Score> innerMap) {
    if (innerMap == null) {
        System.out.println("등록된 점수가 없는 수강생입니다");
        return false;
    }
    return true;
}

 

• 기능: 주어진 수강생 ID가 점수 데이터에 등록되어 있는지 확인합니다. 등록되지 않은 수강생에 대해 오류 메시지를 출력합니다.

 

package camp.Management

StudentManagement.class

package camp.Management;

import camp.model.Student;
import camp.model.StudentMap;
import camp.model.SubjectMap;

import java.util.*;

public class StudentManagement {
    public static Scanner sc = new Scanner(System.in);

    // 수강생 등록
    public void create(StudentMap studentMap, SubjectMap subjectMap) {
        System.out.println("\n수강생을 등록합니다...");

        String studentName = getStudentName();
        if (studentName == null) return;

        String studentState = getStudentState();
        if (studentState == null) return;

        ArrayList<String> getSubject = getSubjects(subjectMap);
        if (getSubject == null) return;

        storeStudent(studentMap, studentName, studentState, getSubject);
    }

    // create 기능 세부화 1.
    private String getStudentName() {
        try {
            System.out.print("수강생 이름 입력: ");
            String studentName = sc.next(); // 이름
            if (studentName.length() > 10)
                throw new Exception("이름이 너무 깁니다.");
            return studentName;
        } catch (Exception e) {
            System.out.println(e.getMessage());
            return null;
        }
    }

    // create 기능 세부화 2.
    private String getStudentState() {
        try {
            System.out.print("수강생 상태 입력(Green,Red,Yellow): ");
            String studentState = sc.next();
            if (!cheackStatus(studentState)) throw new IllegalArgumentException("올바른 상태가 아닙니다");
            return studentState;
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
            return null;
        }
    }

    // create 기능 세부화 3.
    private ArrayList<String> getSubjects(SubjectMap subjectMap) {
        ArrayList<String> getSubject = new ArrayList<>();
        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("필수 과목 개수가 부족합니다.");
            for (String val : mandatorySet) {
                if (Integer.parseInt(val) < 1 || Integer.parseInt(val) > 5) {
                    throw new IllegalArgumentException("필요 과목이 아닙니다.");
                }
            }
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
            return null;
        }

        // 선택 과목 받기
        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("선택 과목 개수가 부족합니다.");
            for (String val : optionalSet) {
                if (Integer.parseInt(val) < 1 || Integer.parseInt(val) > 4) {
                    throw new IllegalArgumentException("선택 과목이 아닙니다.");
                }
            }
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
            return null;
        }

        // 필수 과목 저장
        for (String val : mandatorySet) {
            val = subjectMap.makeSequence(val);
            subjectMap.makeManSubject(val, getSubject);
        }

        // 선택 과목 저장
        for (String val : optionalSet) {
            int useVal = Integer.parseInt(val) + 5;
            val = subjectMap.makeSequence(Integer.toString(useVal));
            subjectMap.makeSubSubject(val, getSubject);
        }
        return getSubject;
    }

    // create 기능 세부화 4.
    private void storeStudent(StudentMap studentMap, String studentName, String studentState, ArrayList<String> getSubject) {
        String studentId = studentMap.studentSequence(); // 고유 번호
        studentMap.set_Store(studentId, studentName, studentState, getSubject); // 이름이랑 과목코드 리스트를 담은 객체 생성
        System.out.println("수강생 등록 성공!\n");
    }

    // 수강생 이름, 상태 수정
    public void update(StudentMap studentMap) {
        if (studentMap.checkEmpty()) {
            System.out.println("등록된 수강생이 없습니다.");
            return;
        }
        studentMap.printStudentInfo();

        System.out.print("조회할 수강생의 고유번호를 입력하세요 : ");
        String useKey = sc.nextLine();
        Student student = studentMap.getStudent(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("====업데이트 완료====");
    }

    // 수강생 삭제
    public void deleteStudent(StudentMap studentMap) {
        if (studentMap.checkEmpty()) {
            System.out.println("등록된 수강생이 없습니다.");
            return;
        }

        studentMap.printStudentInfo();  // 기능 구현

        System.out.print("삭제할 수강생의 고유 번호를 입력하세요 : ");
        String useKey = sc.nextLine();
        Student student = studentMap.getStudent(useKey);

        if (!checkStudentId(student)) return;

        studentMap.deleteKey(useKey);
    }

    // 입력된 상태 검증
    public boolean cheackStatus(String studentState) {
        return studentState.equals("Green") || studentState.equals("Red") || studentState.equals("Yellow");
    }

    // 수강생 검증
    public boolean checkStudentId(Student student) {
        if (student == null) {
            System.out.println("존재하지 않는 수강생입니다.");
            return false;
        }
        return true;
    }

    // 수강중인 과목 검증
    public boolean checkSubjectId(Student student, String subjectId) {
        if (!student.getSubjectList().contains(subjectId)) {
            System.out.println("* 수강중인 과목이 아닙니다");
            return false;
        }
        return true;
    }

    // 전체 과목 리스트 출력
    private 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 Scanner sc = new Scanner(System.in);

• sc: 사용자 입력을 처리하기 위한 Scanner 객체입니다. static으로 선언되어 있어, 클래스의 모든 인스턴스에서 공유됩니다.

 

메서드

create 메서드: 수강생 등록

public void create(StudentMap studentMap, SubjectMap subjectMap) {
    System.out.println("\n수강생을 등록합니다...");

    String studentName = getStudentName();
    if (studentName == null) return;

    String studentState = getStudentState();
    if (studentState == null) return;

    ArrayList<String> getSubject = getSubjects(subjectMap);
    if (getSubject == null) return;

    storeStudent(studentMap, studentName, studentState, getSubject);
}

 

기능: 새로운 수강생을 등록합니다. 수강생의 이름, 상태, 수강 과목을 입력받아 저장합니다.

세부화된 메서드:

• getStudentName(): 수강생의 이름을 입력받고 유효성을 검사합니다.
• getStudentState(): 수강생의 상태를 입력받고 유효성을 검사합니다.
• getSubjects(SubjectMap subjectMap): 필수 과목과 선택 과목을 입력받아 유효성을 검사하고 리스트를 반환합니다.
• storeStudent(StudentMap studentMap, String studentName, String studentState, ArrayList<String> getSubject): 수강생 정보를 저장합니다.

 

getStudentName 메서드: 수강생 이름 입력

private String getStudentName() {
    try {
        System.out.print("수강생 이름 입력: ");
        String studentName = sc.next(); // 이름
        if (studentName.length() > 10)
            throw new Exception("이름이 너무 깁니다.");
        return studentName;
    } catch (Exception e) {
        System.out.println(e.getMessage());
        return null;
    }
}

 

• 기능: 수강생의 이름을 입력받고, 이름의 길이가 10자를 초과하면 예외를 발생시킵니다.

getStudentState 메서드: 수강생 상태 입력

private String getStudentState() {
    try {
        System.out.print("수강생 상태 입력(Green,Red,Yellow): ");
        String studentState = sc.next();
        if (!cheackStatus(studentState)) throw new IllegalArgumentException("올바른 상태가 아닙니다");
        return studentState;
    } catch (IllegalArgumentException e) {
        System.out.println(e.getMessage());
        return null;
    }
}

• 기능: 수강생의 상태를 입력받고, 유효한 상태 값인지 검증합니다. 유효하지 않은 상태 값이면 예외를 발생시킵니다.

getSubjects 메서드: 과목 입력 및 검증

private ArrayList<String> getSubjects(SubjectMap subjectMap) {
    ArrayList<String> getSubject = new ArrayList<>();
    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("필수 과목 개수가 부족합니다.");
        for (String val : mandatorySet) {
            if (Integer.parseInt(val) < 1 || Integer.parseInt(val) > 5) {
                throw new IllegalArgumentException("필수 과목이 아닙니다.");
            }
        }
    } catch (IllegalArgumentException e) {
        System.out.println(e.getMessage());
        return null;
    }

    // 선택 과목 받기
    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("선택 과목 개수가 부족합니다.");
        for (String val : optionalSet) {
            if (Integer.parseInt(val) < 1 || Integer.parseInt(val) > 4) {
                throw new IllegalArgumentException("선택 과목이 아닙니다.");
            }
        }
    } catch (IllegalArgumentException e) {
        System.out.println(e.getMessage());
        return null;
    }

    // 필수 과목 저장
    for (String val : mandatorySet) {
        val = subjectMap.makeSequence(val);
        subjectMap.makeManSubject(val, getSubject);
    }

    // 선택 과목 저장
    for (String val : optionalSet) {
        int useVal = Integer.parseInt(val) + 5;
        val = subjectMap.makeSequence(Integer.toString(useVal));
        subjectMap.makeSubSubject(val, getSubject);
    }
    return getSubject;
}

 

• 기능: 필수 과목과 선택 과목을 입력받아 검증하고, 유효한 과목만을 리스트에 추가하여 반환합니다.
• 필수 과목: 3개 이상 선택해야 하며, 과목 번호가 1에서 5 사이여야 합니다.
• 선택 과목: 2개 이상 선택해야 하며, 과목 번호가 1에서 4 사이여야 합니다.

getSubjects 메서드: 과목 입력 및 검증

private ArrayList<String> getSubjects(SubjectMap subjectMap) {
    ArrayList<String> getSubject = new ArrayList<>();
    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("필수 과목 개수가 부족합니다.");
        for (String val : mandatorySet) {
            if (Integer.parseInt(val) < 1 || Integer.parseInt(val) > 5) {
                throw new IllegalArgumentException("필수 과목이 아닙니다.");
            }
        }
    } catch (IllegalArgumentException e) {
        System.out.println(e.getMessage());
        return null;
    }

    // 선택 과목 받기
    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("선택 과목 개수가 부족합니다.");
        for (String val : optionalSet) {
            if (Integer.parseInt(val) < 1 || Integer.parseInt(val) > 4) {
                throw new IllegalArgumentException("선택 과목이 아닙니다.");
            }
        }
    } catch (IllegalArgumentException e) {
        System.out.println(e.getMessage());
        return null;
    }

    // 필수 과목 저장
    for (String val : mandatorySet) {
        val = subjectMap.makeSequence(val);
        subjectMap.makeManSubject(val, getSubject);
    }

    // 선택 과목 저장
    for (String val : optionalSet) {
        int useVal = Integer.parseInt(val) + 5;
        val = subjectMap.makeSequence(Integer.toString(useVal));
        subjectMap.makeSubSubject(val, getSubject);
    }
    return getSubject;
}

 

 

• 기능: 필수 과목과 선택 과목을 입력받아 검증하고, 유효한 과목만을 리스트에 추가하여 반환합니다.
• 필수 과목: 3개 이상 선택해야 하며, 과목 번호가 1에서 5 사이여야 합니다.
• 선택 과목: 2개 이상 선택해야 하며, 과목 번호가 1에서 4 사이여야 합니다.

storeStudent 메서드: 수강생 저장

private void storeStudent(StudentMap studentMap, String studentName, String studentState, ArrayList<String> getSubject) {
    String studentId = studentMap.studentSequence(); // 고유 번호
    studentMap.set_Store(studentId, studentName, studentState, getSubject); // 이름이랑 과목코드 리스트를 담은 객체 생성
    System.out.println("수강생 등록 성공!\n");
}

 

• 기능: 새로운 수강생 정보를 저장합니다. 고유 번호를 생성하고, 이름, 상태, 과목 리스트를 저장합니다.

update 메서드: 수강생 정보 업데이트

public void update(StudentMap studentMap) {
    if (studentMap.checkEmpty()) {
        System.out.println("등록된 수강생이 없습니다.");
        return;
    }
    studentMap.printStudentInfo();

    System.out.print("조회할 수강생의 고유번호를 입력하세요 : ");
    String useKey = sc.nextLine();
    Student student = studentMap.getStudent(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("====업데이트 완료====");
}

• 기능: 수강생 정보를 수정합니다. 이름과 상태를 업데이트하며, 입력값의 유효성을 검사합니다.

deleteStudent 메서드: 수강생 삭제

public void deleteStudent(StudentMap studentMap) {
    if (studentMap.checkEmpty()) {
        System.out.println("등록된 수강생이 없습니다.");
        return;
    }

    studentMap.printStudentInfo();  // 기능 구현

    System.out.print("삭제할 수강생의 고유 번호를 입력하세요 : ");
    String useKey = sc.nextLine();
    Student student = studentMap.getStudent(useKey);

    if (!checkStudentId(student)) return;

    studentMap.deleteKey(useKey);
}

• 기능: 수강생 정보를 삭제합니다. 삭제할 수강생의 고유 번호를 입력받고 해당 수강생을 삭제합니다.

cheackStatus 메서드: 수강생 상태 검증

public boolean cheackStatus(String studentState) {
    return studentState.equals("Green") || studentState.equals("Red") || studentState.equals("Yellow");
}

• 기능: 주어진 상태 값이 유효한지 검증합니다. 유효한 상태 값(“Green”, “Red”, “Yellow”)만을 허용합니다.

checkStudentId 메서드: 수강생 검증

public boolean checkStudentId(Student student) {
    if (student == null) {
        System.out.println("존재하지 않는 수강생입니다.");
        return false;
    }
    return true;
}

• 기능: 주어진 수강생 ID가 유효한지 검증합니다. 수강생이 존재하지 않을 경우 오류 메시지를 출력합니다.

checkSubjectId 메서드: 수강 중인 과목 검증

public boolean checkSubjectId(Student student, String subjectId) {
    if (!student.getSubjectList().contains(subjectId)) {
        System.out.println("* 수강중인 과목이 아닙니다");
        return false;
    }
    return true;
}

• 기능: 수강생이 해당 과목을 수강 중인지 검증합니다. 수강 중이지 않을 경우 오류 메시지를 출력합니다.

 

printSubjectInfo 메서드: 전체 과목 리스트 출력

private 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("=======================================");
}

• 기능: 수강 가능한 과목 리스트를 출력합니다. 필수 과목과 선택 과목을 나누어 보여줍니다.

 

package camp.display

MainDisplay.class

사용자가 수강생 관리와 점수 관리 기능을 선택할 수 있는 메인 메뉴를 제공

package camp.display;

import camp.model.ScoreMap;
import camp.model.StudentMap;
import camp.model.SubjectMap;

import java.util.*;

public class MainDisplay {
    public static Scanner sc = new Scanner(System.in);

    // 메인 메뉴
    public static void displayMainView(StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) throws InterruptedException {
        StudentDisplay studentDisplay = new StudentDisplay();
        ScoreDisplay scoreDisplay = new ScoreDisplay();
        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 -> studentDisplay.display(studentMap, subjectMap); // 수강생 관리
                case 2 -> scoreDisplay.display(studentMap, subjectMap, scoreMap); // 점수 관리
                case 3 -> flag = false; // 프로그램 종료
                default -> {
                    System.out.println("잘못된 입력입니다.\n되돌아갑니다!");
                    Thread.sleep(2000);
                }
            }
        }
        System.out.println("프로그램을 종료합니다.");
    }
}

 

필드

public static Scanner sc = new Scanner(System.in);

• sc: 사용자 입력을 처리하기 위한 Scanner 객체입니다. static으로 선언되어 있어, 클래스의 모든 인스턴스에서 공유됩니다.

 

메서드

displayMainView 메서드: 메인 메뉴를 표시하고 사용자 입력을 처리합니다.

public static void displayMainView(StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) throws InterruptedException {
    StudentDisplay studentDisplay = new StudentDisplay();
    ScoreDisplay scoreDisplay = new ScoreDisplay();
    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 -> studentDisplay.display(studentMap, subjectMap); // 수강생 관리
            case 2 -> scoreDisplay.display(studentMap, subjectMap, scoreMap); // 점수 관리
            case 3 -> flag = false; // 프로그램 종료
            default -> {
                System.out.println("잘못된 입력입니다.\n되돌아갑니다!");
                Thread.sleep(2000);
            }
        }
    }
    System.out.println("프로그램을 종료합니다.");
}

 

기능: 메인 메뉴를 표시하고 사용자 입력을 처리합니다. 사용자가 선택한 옵션에 따라 수강생 관리 또는 점수 관리 기능을 실행하거나 프로그램을 종료합니다.

매개변수:

studentMap: 수강생 정보를 관리하는 StudentMap 객체.

• subjectMap: 과목 정보를 관리하는 SubjectMap 객체.
• scoreMap: 점수 정보를 관리하는 ScoreMap 객체.

로직:

• while (flag): 메뉴가 반복적으로 표시됩니다. 사용자가 프로그램 종료를 선택할 때까지 계속됩니다.
• switch (input):
  • case 1: StudentDisplay 클래스의 display 메서드를 호출하여 수강생 관리 기능을 실행합니다.
  • case 2: ScoreDisplay 클래스의 display 메서드를 호출하여 점수 관리 기능을 실행합니다.
  • case 3: flag를 false로 설정하여 루프를 종료하고 프로그램을 종료합니다.
  • default: 잘못된 입력에 대해 오류 메시지를 출력하고 2초 후에 메뉴로 돌아갑니다.

의존 관계

• StudentDisplay: 수강생 관리 기능을 제공하는 클래스입니다. display 메서드에서 studentMap과 subjectMap을 사용하여 수강생 관련 작업을 처리합니다.
• ScoreDisplay: 점수 관리 기능을 제공하는 클래스입니다. display 메서드에서 studentMap, subjectMap, 및 scoreMap을 사용하여 점수 관련 작업을 처리합니다.

예외 처리

• throws InterruptedException: Thread.sleep(2000) 호출로 인해 발생할 수 있는 InterruptedException을 처리합니다. 이 예외는 스레드가 일시 중지될 때 발생합니다.

 

package camp.display

ScoreDisplay.class

점수 관련 작업을 수행할 수 있는 메뉴

package camp.display;

import camp.Management.ScoreManagement;
import camp.Management.StudentManagement;
import camp.model.*;

import java.util.*;

public class ScoreDisplay {
    ScoreManagement scoreManagement;
    StudentManagement studentManagement;
    public Scanner sc;

    public ScoreDisplay() {
        this.studentManagement = new StudentManagement();
        this.scoreManagement = new ScoreManagement();
        this.sc = new Scanner(System.in);
    }

    // 점수 관리 메뉴
    public void display(StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) {
        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 ->
                        scoreManagement.create(studentManagement, studentMap, subjectMap, scoreMap); // 수강생의 과목별 시험 회차 및 점수 등록
                case 2 -> scoreManagement.update(studentMap, subjectMap, scoreMap); // 수강생의 과목별 회차 점수 수정
                case 3 -> inquireAll(studentMap, subjectMap, scoreMap); // 수강생의 특정 과목 회차별 등급 조회
                case 4 -> inquireByCon(studentMap, subjectMap, scoreMap); // 수강생의 특정 과목 평균 등급 조회
                case 5 -> flag = false; // 메인 화면 이동
                default -> {
                    System.out.println("잘못된 입력입니다.\n메인 화면 이동...");
                    flag = false;
                }
            }
        }
    }

    // 회차별 등급 조회
    public void inquireAll(StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) {
        System.out.println("===========회차별 등급 조회===========");

        // 등록된 수강생이 있는지 확인
        if (studentMap.checkEmpty()) {
            System.out.println("등록된 수강생이 없습니다.");
            return;
        }

        // 조회할 수강생 고유 번호 확인
        studentMap.printStudentInfo();
        System.out.print("점수를 조회할 수강생의 고유 번호를 입력하세요 : ");
        String studentId = sc.next();
        Map<String, Score> innerMap = scoreMap.getStudent(studentId);
        if (!scoreManagement.checkStudentId(innerMap)) {
            System.out.println("============점수 조회 실패============");
            return;
        }

        // 조회할 과목 고유 번호 확인
        subjectMap.printSubjectInfoByStudentId(studentMap, studentId);
        System.out.print("점수를 조회할 과목의 고유 번호를 입력하세요 : ");
        String subjectId = sc.next();
        if (innerMap.get(subjectId) == null) {
            System.out.println("조회할 점수가 없는 과목입니다");
            System.out.println("============점수 조회 실패============");
            return;
        }

        // 회차별 등급 출력
        int[] scores = innerMap.get(subjectId).getScores();
        System.out.println("============ " + studentId + " - " + subjectId + " ============");
        for (int i = 0; i < scores.length; i++) {
            String grade = "";
            if (scores[i] != -1) {
                if (subjectMap.checkSubjectType(subjectId)) {
                    grade = subjectMap.gradeMandatory(scores[i]);
                } else {
                    grade = subjectMap.gradeChoice(scores[i]);
                }
                System.out.println(i + 1 + "회차 : " + grade);
            }
        }
    }

    // 과목 평균 등급 조회
    public void inquireByCon(StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) {
        System.out.println("============평균 등급 조회============");

        // 등록된 수강생이 있는지 확인
        if (studentMap.checkEmpty()) {
            System.out.println("등록된 수강생이 없습니다.");
            return;
        }

        // 조회할 수강생 고유 번호 확인
        studentMap.printStudentInfo();
        System.out.print("평균 등급을 조회할 수강생의 고유 번호를 입력하세요 : ");
        String studentId = sc.next();
        Map<String, Score> innerMap = scoreMap.getStudent(studentId);
        if (!scoreManagement.checkStudentId(innerMap)) {
            System.out.println("============등급 조회 실패============");
            return;
        }

        // 조회할 과목 고유 번호 확인
        subjectMap.printSubjectInfoByStudentId(studentMap, studentId);
        System.out.print("평균 등급을 과목의 고유 번호를 입력하세요 : ");
        String subjectId = sc.next();
        if (innerMap.get(subjectId) == null) {
            System.out.println("등록된 점수가 없는 과목입니다");
            System.out.println("============등급 조회 실패============");
            return;
        }

        // 과목 평균값 연산
        int[] scores = innerMap.get(subjectId).getScores();
        System.out.println("============ " + studentId + " - " + subjectId + " ============");
        String grade = "";
        int scoreCount = 0;
        int totalScore = 0;

        for (int score : scores) {
            if (score != -1) {
                totalScore += score;
                scoreCount++;
            }
        }

        // 과목 평균 등급 출력
        if (subjectMap.checkSubjectType(subjectId)) {
            grade = subjectMap.gradeMandatory(totalScore / scoreCount);
        } else {
            grade = subjectMap.gradeChoice(totalScore / scoreCount);
        }
        System.out.println("평균등급 : " + grade);
    }
}

 

필드

ScoreManagement scoreManagement;
StudentManagement studentManagement;
public Scanner sc;

 

• scoreManagement: 점수 관리 기능을 처리하는 ScoreManagement 객체입니다.
• studentManagement: 수강생 관리 기능을 처리하는 StudentManagement 객체입니다.
• sc: 사용자 입력을 처리하기 위한 Scanner 객체입니다.

 

생성자

public ScoreDisplay() {
    this.studentManagement = new StudentManagement();
    this.scoreManagement = new ScoreManagement();
    this.sc = new Scanner(System.in);
}

 

• 기능: ScoreDisplay 객체를 생성할 때, StudentManagement와 ScoreManagement 객체를 초기화하고 Scanner를 생성합니다.

 

메서드

display 메서드: 점수 관리 메뉴를 표시하고 사용자 입력을 처리합니다.

public void display(StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) {
    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 ->
                    scoreManagement.create(studentManagement, studentMap, subjectMap, scoreMap); // 점수 등록
            case 2 -> scoreManagement.update(studentMap, subjectMap, scoreMap); // 점수 수정
            case 3 -> inquireAll(studentMap, subjectMap, scoreMap); // 회차별 등급 조회
            case 4 -> inquireByCon(studentMap, subjectMap, scoreMap); // 평균 등급 조회
            case 5 -> flag = false; // 메인 화면 이동
            default -> {
                System.out.println("잘못된 입력입니다.\n메인 화면 이동...");
                flag = false;
            }
        }
    }
}

 

기능: 점수 관리 메뉴를 표시하고, 사용자 입력에 따라 점수 등록, 점수 수정, 회차별 등급 조회, 평균 등급 조회 기능을 실행합니다.

매개변수:

• studentMap: 수강생 정보를 관리하는 StudentMap 객체.
• subjectMap: 과목 정보를 관리하는 SubjectMap 객체.
• scoreMap: 점수 정보를 관리하는 ScoreMap 객체.

 

inquireAll 메서드: 특정 수강생의 특정 과목에 대해 회차별 점수를 조회합니다.

public void inquireAll(StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) {
    System.out.println("===========회차별 등급 조회===========");

    // 등록된 수강생이 있는지 확인
    if (studentMap.checkEmpty()) {
        System.out.println("등록된 수강생이 없습니다.");
        return;
    }

    // 조회할 수강생 고유 번호 확인
    studentMap.printStudentInfo();
    System.out.print("점수를 조회할 수강생의 고유 번호를 입력하세요 : ");
    String studentId = sc.next();
    Map<String, Score> innerMap = scoreMap.getStudent(studentId);
    if (!scoreManagement.checkStudentId(innerMap)) {
        System.out.println("============점수 조회 실패============");
        return;
    }

    // 조회할 과목 고유 번호 확인
    subjectMap.printSubjectInfoByStudentId(studentMap, studentId);
    System.out.print("점수를 조회할 과목의 고유 번호를 입력하세요 : ");
    String subjectId = sc.next();
    if (innerMap.get(subjectId) == null) {
        System.out.println("조회할 점수가 없는 과목입니다");
        System.out.println("============점수 조회 실패============");
        return;
    }

    // 회차별 등급 출력
    int[] scores = innerMap.get(subjectId).getScores();
    System.out.println("============ " + studentId + " - " + subjectId + " ============");
    for (int i = 0; i < scores.length; i++) {
        String grade = "";
        if (scores[i] != -1) {
            if (subjectMap.checkSubjectType(subjectId)) {
                grade = subjectMap.gradeMandatory(scores[i]);
            } else {
                grade = subjectMap.gradeChoice(scores[i]);
            }
            System.out.println(i + 1 + "회차 : " + grade);
        }
    }
}

 

 

기능: 특정 수강생의 특정 과목에 대해 각 시험 회차의 점수를 조회하고 출력합니다.

로직:

• 수강생과 과목 정보 유효성 확인.
• 점수를 조회할 과목의 회차별 점수를 출력합니다.

 

inquireByCon 메서드: 특정 수강생의 특정 과목에 대한 평균 등급을 조회합니다.

public void inquireByCon(StudentMap studentMap, SubjectMap subjectMap, ScoreMap scoreMap) {
    System.out.println("============평균 등급 조회============");

    // 등록된 수강생이 있는지 확인
    if (studentMap.checkEmpty()) {
        System.out.println("등록된 수강생이 없습니다.");
        return;
    }

    // 조회할 수강생 고유 번호 확인
    studentMap.printStudentInfo();
    System.out.print("평균 등급을 조회할 수강생의 고유 번호를 입력하세요 : ");
    String studentId = sc.next();
    Map<String, Score> innerMap = scoreMap.getStudent(studentId);
    if (!scoreManagement.checkStudentId(innerMap)) {
        System.out.println("============등급 조회 실패============");
        return;
    }

    // 조회할 과목 고유 번호 확인
    subjectMap.printSubjectInfoByStudentId(studentMap, studentId);
    System.out.print("평균 등급을 과목의 고유 번호를 입력하세요 : ");
    String subjectId = sc.next();
    if (innerMap.get(subjectId) == null) {
        System.out.println("등록된 점수가 없는 과목입니다");
        System.out.println("============등급 조회 실패============");
        return;
    }

    // 과목 평균값 연산
    int[] scores = innerMap.get(subjectId).getScores();
    System.out.println("============ " + studentId + " - " + subjectId + " ============");
    String grade = "";
    int scoreCount = 0;
    int totalScore = 0;

    for (int score : scores) {
        if (score != -1) {
            totalScore += score;
            scoreCount++;
        }
    }

    // 과목 평균 등급 출력
    if (subjectMap.checkSubjectType(subjectId)) {
        grade = subjectMap.gradeMandatory(totalScore / scoreCount);
    } else {
        grade = subjectMap.gradeChoice(totalScore / scoreCount);
    }
    System.out.println("평균등급 : " + grade);
}

 

 

기능: 특정 수강생의 특정 과목에 대한 평균 점수를 계산하고, 이 평균 점수를 기반으로 평균 등급을 조회하여 출력합니다.

로직:

• 수강생과 과목 정보 유효성 확인.
• 점수 배열에서 유효한 점수만을 사용하여 평균 점수를 계산합니다.
• 평균 점수를 기반으로 등급을 결정하여 출력합니다.

 

package camp.display

StudentDisplayclass

사용자가 수강생을 등록, 조회, 수정, 삭제할 수 있도록 하는 메뉴를 제공

package camp.display;

import camp.Management.StudentManagement;
import camp.model.*;

import java.util.*;

public class StudentDisplay {
    StudentManagement studentManagement;
    public Scanner sc;

    public StudentDisplay() {
        this.studentManagement = new StudentManagement();
        this.sc = new Scanner(System.in);
    }

    // 수강생 관리 메뉴
    public void display(StudentMap studentMap, SubjectMap subjectMap) {
        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.println("6. 메인 화면 이동");
            System.out.print("관리 항목을 선택하세요...");
            int input = sc.nextInt();

            switch (input) {
                case 1 -> studentManagement.create(studentMap, subjectMap); // 수강생 등록
                case 2 -> inquireAll(studentMap, subjectMap); // 수강생 목록 조회
                case 3 -> studentManagement.update(studentMap); // 수강생 정보 수정
                case 4 -> inquireByCon(studentMap); // 상태별 수강생 목록 조회
                case 5 -> studentManagement.deleteStudent(studentMap); // 수강생 삭제
                case 6 -> flag = false; // 메인 화면 이동
                default -> {
                    System.out.println("잘못된 입력입니다.\n메인 화면 이동...");
                    flag = false;
                }
            }
        }
    }

    // 수강생 조회
    public void inquireAll(StudentMap studentMap, SubjectMap subjectMap) {
        // 등록된 수강생이 있는지 확인
        if (studentMap.checkEmpty()) {
            System.out.println("등록된 수강생이 없습니다.");
            return;
        }

        // 조회할 수강생 고유 번호 확인
        studentMap.printStudentInfo();
        sc.nextLine();
        System.out.print("조회할 수강생의 고유 번호를 입력하세요 : ");
        String useKey = sc.nextLine();
        Student student = studentMap.getStudent(useKey);

        if (!studentManagement.checkStudentId(student)) return;

        ArrayList<String> viewSubject = student.getSubjectList(); // 과목 아이디가 저장되어있음
        ArrayList<String> viewMandatory = new ArrayList<>(); // 필수 과목 리스트
        ArrayList<String> viewOptional = new ArrayList<>(); // 선택 과목 리스트

        // 과목 종류 나눠서 세팅
        for (String val : viewSubject) {
            Subject useSubject = subjectMap.getSubject(val);

            if (subjectMap.check_MANDATORY(useSubject)) {
                viewMandatory.add(useSubject.getSubjectName());
            } else if (subjectMap.check_CHOICE(useSubject)) {
                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());
    }

    // 상태별 수강생 조회
    public void inquireByCon(StudentMap studentMap) {
        if (studentMap.checkEmpty()) {
            System.out.println("등록된 수강생이 없습니다.");
            return;
        }

        Set<String> keys = studentMap.getKeys();
        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 (studentMap.checkState(key, "Green")) {
                greenStu.add(studentMap.getStudent(key));
            } else if (studentMap.checkState(key, "Red")) {
                redStu.add(studentMap.getStudent(key));
            } else {
                yellowStu.add(studentMap.getStudent(key));
            }
        }

        System.out.println("====Green 상태 수강생====");
        print(greenStu);
        System.out.println();

        System.out.println("====Red 상태 수강생====");
        print(redStu);
        System.out.println();

        System.out.println("====Yellow 상태 수강생====");
        print(yellowStu);
        System.out.println();
    }

    public void print(ArrayList<Student> stu) {
        for (Student std : stu) {
            System.out.println(std.getStudentId() + " : " + std.getStudentName());
        }
    }
}

 

 

필드

StudentManagement studentManagement;
public Scanner sc;

 

• studentManagement: 수강생 관련 작업을 처리하는 StudentManagement 객체입니다.
• sc: 사용자 입력을 처리하기 위한 Scanner 객체입니다.

 

생성자

public StudentDisplay() {
    this.studentManagement = new StudentManagement();
    this.sc = new Scanner(System.in);
}

 

• 기능: StudentDisplay 객체를 생성할 때, StudentManagement 객체와 Scanner 객체를 초기화합니다.

메서드

display 메서드: 수강생 관리 메뉴를 표시하고 사용자 입력을 처리합니다.

public void display(StudentMap studentMap, SubjectMap subjectMap) {
    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.println("6. 메인 화면 이동");
        System.out.print("관리 항목을 선택하세요...");
        int input = sc.nextInt();

        switch (input) {
            case 1 -> studentManagement.create(studentMap, subjectMap); // 수강생 등록
            case 2 -> inquireAll(studentMap, subjectMap); // 수강생 목록 조회
            case 3 -> studentManagement.update(studentMap); // 수강생 정보 수정
            case 4 -> inquireByCon(studentMap); // 상태별 수강생 목록 조회
            case 5 -> studentManagement.deleteStudent(studentMap); // 수강생 삭제
            case 6 -> flag = false; // 메인 화면 이동
            default -> {
                System.out.println("잘못된 입력입니다.\n메인 화면 이동...");
                flag = false;
            }
        }
    }
}

 

기능: 수강생 관리 메뉴를 표시하고, 사용자 입력에 따라 수강생 등록, 조회, 수정, 삭제, 상태별 조회 기능을 실행합니다.

매개변수:

• studentMap: 수강생 정보를 관리하는 StudentMap 객체.
• subjectMap: 과목 정보를 관리하는 SubjectMap 객체.

inquireAll 메서드: 특정 수강생의 정보를 조회합니다.

public void inquireAll(StudentMap studentMap, SubjectMap subjectMap) {
    // 등록된 수강생이 있는지 확인
    if (studentMap.checkEmpty()) {
        System.out.println("등록된 수강생이 없습니다.");
        return;
    }

    // 조회할 수강생 고유 번호 확인
    studentMap.printStudentInfo();
    sc.nextLine();
    System.out.print("조회할 수강생의 고유 번호를 입력하세요 : ");
    String useKey = sc.nextLine();
    Student student = studentMap.getStudent(useKey);

    if (!studentManagement.checkStudentId(student)) return;

    ArrayList<String> viewSubject = student.getSubjectList(); // 과목 아이디가 저장되어있음
    ArrayList<String> viewMandatory = new ArrayList<>(); // 필수 과목 리스트
    ArrayList<String> viewOptional = new ArrayList<>(); // 선택 과목 리스트

    // 과목 종류 나눠서 세팅
    for (String val : viewSubject) {
        Subject useSubject = subjectMap.getSubject(val);

        if (subjectMap.check_MANDATORY(useSubject)) {
            viewMandatory.add(useSubject.getSubjectName());
        } else if (subjectMap.check_CHOICE(useSubject)) {
            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());
}

 

 

기능: 특정 수강생의 과목 정보와 상태를 조회합니다.

로직:

• 등록된 수강생이 있는지 확인합니다.
• 수강생의 고유 번호를 입력받아 해당 수강생의 정보를 조회합니다.
• 수강생이 수강하는 필수 과목과 선택 과목을 구분하여 출력합니다.

 

inquireByCon 메서드: 수강생의 상태별로 목록을 조회합니다.

public void inquireByCon(StudentMap studentMap) {
    if (studentMap.checkEmpty()) {
        System.out.println("등록된 수강생이 없습니다.");
        return;
    }

    Set<String> keys = studentMap.getKeys();
    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 (studentMap.checkState(key, "Green")) {
            greenStu.add(studentMap.getStudent(key));
        } else if (studentMap.checkState(key, "Red")) {
            redStu.add(studentMap.getStudent(key));
        } else {
            yellowStu.add(studentMap.getStudent(key));
        }
    }

    System.out.println("====Green 상태 수강생====");
    print(greenStu);
    System.out.println();

    System.out.println("====Red 상태 수강생====");
    print(redStu);
    System.out.println();

    System.out.println("====Yellow 상태 수강생====");
    print(yellowStu);
    System.out.println();
}

 

 

기능: 수강생의 상태별로 목록을 조회하여 출력합니다.

로직:

• 수강생의 상태를 기준으로 Green, Red, Yellow 상태의 수강생을 각각 분리합니다.
• 상태별로 수강생 목록을 출력합니다.

print 메서드: 수강생 리스트를 출력합니다.

public void print(ArrayList<Student> stu) {
    for (Student std : stu) {
        System.out.println(std.getStudentId() + " : " + std.getStudentName());
    }
}

 

기능: 수강생 객체의 리스트를 출력합니다.

매개변수:

• stu: 출력할 수강생 객체의 리스트입니다.