학생 관리 시스템 실습 문제

📌 문제 설명

은행 애플리케이션과 유사한 구조로 학생 관리 시스템을 구현하세요.

배열을 사용하여 최대 100명의 학생 정보를 관리하는 프로그램을 작성하세요.

1️⃣ Student 클래스 작성

요구사항

다음 조건을 만족하는 Student 클래스를 작성하세요.

필드 (모두 private)

String studentId : 학번
String name : 이름
int age : 나이
String major : 전공

생성자

모든 필드를 매개변수로 받아 초기화하는 생성자

Getter 메서드

getStudentId() : 학번 반환
getName() : 이름 반환
getAge() : 나이 반환
getMajor() : 전공 반환

Setter 메서드 (선택사항)

필요한 경우에만 작성

2️⃣ StudentApplication 클래스 작성

요구사항

다음 기능을 가진 StudentApplication 클래스를 작성하세요.

필드

private static Student[] studentsArray = new Student[100] : 모든 학생 정보를 저장하는 배열
private static Scanner scanner = new Scanner(System.in) : 사용자 입력을 받기 위한 Scanner

메뉴 시스템

프로그램 실행 시 다음과 같은 메뉴를 출력하고 사용자 선택에 따라 기능을 실행합니다.

-----------------------------------------------------------------------
1. 학생등록 | 2. 학생목록 | 3. 학생검색 | 4. 학생수정 | 5. 학생삭제 | 6. 종료
-----------------------------------------------------------------------
선택>

기능 1: 학생등록 (registerStudent)

학번, 이름, 나이, 전공을 입력받습니다.
중복 체크: 이미 존재하는 학번인지 확인합니다.
중복이 아닌 경우 새 Student 객체를 생성하고 배열의 빈 자리(null)에 저장합니다.
등록 완료 메시지를 출력합니다.

입력 예시:

-----------
학생등록
-----------
학번: 2024001
이름: 홍길동
나이: 20
전공: 컴퓨터공학
결과: 학생이 등록되었습니다.

에러 처리:

이미 존재하는 학번인 경우: "이미 존재하는 학번입니다."
나이 입력 오류: "잘못된 입력입니다. 숫자를 입력하세요."

기능 2: 학생목록 (studentList)

등록된 모든 학생의 정보를 출력합니다.
학번, 이름, 나이, 전공을 표 형태로 출력합니다.
등록된 학생이 없으면 아무것도 출력하지 않습니다.

출력 예시:

-----------
학생목록
-----------
2024001 홍길동   20 컴퓨터공학
2024002 김철수   21 소프트웨어
2024003 이영희   19 정보통신

기능 3: 학생검색 (searchStudent)

학번을 입력받습니다.
해당 학번의 학생을 찾아 정보를 출력합니다.
학생을 찾지 못한 경우: "결과: 학생을 찾을 수 없습니다."

입력/출력 예시:

-----------
학생검색
-----------
학번: 2024001
결과: 학생을 찾았습니다.
학번: 2024001, 이름: 홍길동, 나이: 20, 전공: 컴퓨터공학

기능 4: 학생수정 (updateStudent)

학번을 입력받습니다.
해당 학번의 학생을 찾습니다.
이름, 나이, 전공을 새로 입력받아 수정합니다.
학생을 찾지 못한 경우: "결과: 학생을 찾을 수 없습니다."

입력/출력 예시:

-----------
학생수정
-----------
학번: 2024001
이름(수정): 홍길동
나이(수정): 21
전공(수정): 소프트웨어
결과: 학생 정보가 수정되었습니다.

기능 5: 학생삭제 (deleteStudent)

학번을 입력받습니다.
해당 학번의 학생을 찾아 배열에서 제거합니다 (해당 위치를 null로 설정).
학생을 찾지 못한 경우: "결과: 학생을 찾을 수 없습니다."
삭제 완료 메시지를 출력합니다.

입력/출력 예시:

-----------
학생삭제
-----------
학번: 2024001
결과: 학생이 삭제되었습니다.

보조 메서드: findStudent

학번(String)을 매개변수로 받습니다.
배열에서 해당 학번을 가진 Student 객체를 찾아 반환합니다.
찾지 못한 경우 null을 반환합니다.
private static Student findStudent(String studentId) 형태로 작성합니다.

종료 (6번 선택)

"프로그램 종료" 메시지를 출력하고 프로그램을 종료합니다.

3️⃣ 추가 요구사항

예외 처리

나이 입력 시 숫자가 아닌 값이 입력되면 try-catch를 사용하여 처리합니다.
잘못된 입력 시 적절한 메시지를 출력하고 다시 입력을 받을 수 있도록 합니다.

배열 관리

배열의 빈 자리(null)를 찾아 학생을 저장합니다.
학생 삭제 시 해당 위치를 null로 설정합니다.

메뉴 반복

6번(종료)을 선택할 때까지 메뉴를 반복 출력합니다.
while 반복문을 사용합니다.

4️⃣ 실행 결과 예시

-----------------------------------------------------------------------
1. 학생등록 | 2. 학생목록 | 3. 학생검색 | 4. 학생수정 | 5. 학생삭제 | 6. 종료
-----------------------------------------------------------------------
선택> 1
-----------
학생등록
-----------
학번: 2024001
이름: 홍길동
나이: 20
전공: 컴퓨터공학
결과: 학생이 등록되었습니다.

-----------------------------------------------------------------------
1. 학생등록 | 2. 학생목록 | 3. 학생검색 | 4. 학생수정 | 5. 학생삭제 | 6. 종료
-----------------------------------------------------------------------
선택> 1
-----------
학생등록
-----------
학번: 2024002
이름: 김철수
나이: 21
전공: 소프트웨어
결과: 학생이 등록되었습니다.

-----------------------------------------------------------------------
1. 학생등록 | 2. 학생목록 | 3. 학생검색 | 4. 학생수정 | 5. 학생삭제 | 6. 종료
-----------------------------------------------------------------------
선택> 2
-----------
학생목록
-----------
2024001 홍길동   20 컴퓨터공학
2024002 김철수   21 소프트웨어

-----------------------------------------------------------------------
1. 학생등록 | 2. 학생목록 | 3. 학생검색 | 4. 학생수정 | 5. 학생삭제 | 6. 종료
-----------------------------------------------------------------------
선택> 3
-----------
학생검색
-----------
학번: 2024001
결과: 학생을 찾았습니다.
학번: 2024001, 이름: 홍길동, 나이: 20, 전공: 컴퓨터공학

-----------------------------------------------------------------------
1. 학생등록 | 2. 학생목록 | 3. 학생검색 | 4. 학생수정 | 5. 학생삭제 | 6. 종료
-----------------------------------------------------------------------
선택> 4
-----------
학생수정
-----------
학번: 2024001
이름(수정): 홍길동
나이(수정): 21
전공(수정): 소프트웨어
결과: 학생 정보가 수정되었습니다.

-----------------------------------------------------------------------
1. 학생등록 | 2. 학생목록 | 3. 학생검색 | 4. 학생수정 | 5. 학생삭제 | 6. 종료
-----------------------------------------------------------------------
선택> 6
프로그램 종료

5️⃣ 힌트

Student 클래스: 은행 애플리케이션의 Account 클래스와 유사한 구조로 작성합니다.
배열 관리:
- 학생 등록 시 배열에서 null인 위치를 찾아 저장합니다.
- 학생 삭제 시 해당 위치를 null로 설정합니다.
findStudent 메서드:
- 배열을 순회하며 null이 아니고, 학번이 일치하는 Student를 찾습니다.
- 찾으면 해당 Student를 반환하고, 못 찾으면 null을 반환합니다.
예외 처리:
try { int age = Integer.parseInt(scanner.nextLine()); } catch (Exception e) { // 에러 처리 }
중복 체크:
- 학생 등록 시 findStudent() 메서드를 사용하여 중복을 확인합니다.
학생 수정:
- Student 클래스에 Setter 메서드를 추가하거나, Student 객체의 필드를 직접 수정할 수 있습니다.
- 또는 새 Student 객체를 생성하여 교체할 수도 있습니다.

</details>

6️⃣ 평가 기준

[ ] Student 클래스가 올바르게 구현되었는가?
[ ] 메뉴 시스템이 제대로 작동하는가?
[ ] 학생 등록 기능이 구현되었는가? (중복 체크 포함)
[ ] 학생 목록 기능이 구현되었는가?
[ ] 학생 검색 기능이 구현되었는가?
[ ] 학생 수정 기능이 구현되었는가?
[ ] 학생 삭제 기능이 구현되었는가?
[ ] findStudent 보조 메서드가 구현되었는가?
[ ] 예외 처리가 구현되었는가?
[ ] 코드가 깔끔하고 읽기 쉬운가?

📚 참고 자료

학생 관리 시스템 정답

📌 전체 코드

Student.java

package student.management;

/**
 * 학생 정보를 나타내는 클래스
 */
public class Student {
    private String studentId;  // 학번
    private String name;       // 이름
    private int age;          // 나이
    private String major;     // 전공

    // 생성자
    public Student(String studentId, String name, int age, String major) {
        this.studentId = studentId;
        this.name = name;
        this.age = age;
        this.major = major;
    }

    // Getter 메서드
    public String getStudentId() {
        return studentId;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getMajor() {
        return major;
    }

    // Setter 메서드 (수정 기능을 위해 필요)
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setMajor(String major) {
        this.major = major;
    }
}

StudentApplication.java

package student.management;

import java.util.Scanner;

/**
 * 학생 관리 시스템 메인 클래스
 */
public class StudentApplication {
    // 모든 학생 정보를 저장하는 배열 (최대 100명)
    private static Student[] studentsArray = new Student[100];

    // 사용자 입력을 받기 위한 Scanner
    private static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        boolean run = true;

        while (run) {
            System.out.println("-----------------------------------------------------------------------");
            System.out.println("1. 학생등록 | 2. 학생목록 | 3. 학생검색 | 4. 학생수정 | 5. 학생삭제 | 6. 종료");
            System.out.println("-----------------------------------------------------------------------");
            System.out.print("선택> ");

            int selNum = 0;
            try {
                selNum = Integer.parseInt(scanner.nextLine());
            } catch (Exception e) {
                // 잘못된 입력 처리
            }

            switch (selNum) {
                case 1:
                    registerStudent();
                    break;
                case 2:
                    studentList();
                    break;
                case 3:
                    searchStudent();
                    break;
                case 4:
                    updateStudent();
                    break;
                case 5:
                    deleteStudent();
                    break;
                case 6:
                    System.out.println("프로그램 종료");
                    run = false;
                    break;
                default:
                    break;
            }
        }

        scanner.close();
    }

    /**
     * 학생 등록
     */
    private static void registerStudent() {
        System.out.println("-----------");
        System.out.println("학생등록");
        System.out.println("-----------");

        System.out.print("학번: ");
        String studentId = scanner.nextLine();

        // 중복 체크
        if (findStudent(studentId) != null) {
            System.out.println("이미 존재하는 학번입니다.");
            return;
        }

        System.out.print("이름: ");
        String name = scanner.nextLine();

        System.out.print("나이: ");
        int age = 0;
        try {
            age = Integer.parseInt(scanner.nextLine());
        } catch (Exception e) {
            System.out.println("잘못된 입력입니다. 숫자를 입력하세요.");
            return;
        }

        System.out.print("전공: ");
        String major = scanner.nextLine();

        // Student 객체 생성
        Student newStudent = new Student(studentId, name, age, major);

        // 배열의 빈 자리에 저장
        for (int i = 0; i < studentsArray.length; i++) {
            if (studentsArray[i] == null) {
                studentsArray[i] = newStudent;
                System.out.println("결과: 학생이 등록되었습니다.");
                break;
            }
        }
    }

    /**
     * 학생 목록 출력
     */
    private static void studentList() {
        System.out.println("-----------");
        System.out.println("학생목록");
        System.out.println("-----------");

        boolean hasStudent = false;
        for (int i = 0; i < studentsArray.length; i++) {
            if (studentsArray[i] != null) {
                Student student = studentsArray[i];
                System.out.printf("%s %s   %d %s\\\\n",
                    student.getStudentId(),
                    student.getName(),
                    student.getAge(),
                    student.getMajor());
                hasStudent = true;
            }
        }

        if (!hasStudent) {
            // 등록된 학생이 없을 경우 (선택사항)
            // System.out.println("등록된 학생이 없습니다.");
        }
    }

    /**
     * 학생 검색
     */
    private static void searchStudent() {
        System.out.println("-----------");
        System.out.println("학생검색");
        System.out.println("-----------");

        System.out.print("학번: ");
        String studentId = scanner.nextLine();

        Student student = findStudent(studentId);

        if (student == null) {
            System.out.println("결과: 학생을 찾을 수 없습니다.");
        } else {
            System.out.println("결과: 학생을 찾았습니다.");
            System.out.printf("학번: %s, 이름: %s, 나이: %d, 전공: %s\\\\n",
                student.getStudentId(),
                student.getName(),
                student.getAge(),
                student.getMajor());
        }
    }

    /**
     * 학생 정보 수정
     */
    private static void updateStudent() {
        System.out.println("-----------");
        System.out.println("학생수정");
        System.out.println("-----------");

        System.out.print("학번: ");
        String studentId = scanner.nextLine();

        Student student = findStudent(studentId);

        if (student == null) {
            System.out.println("결과: 학생을 찾을 수 없습니다.");
            return;
        }

        System.out.print("이름(수정): ");
        String name = scanner.nextLine();

        System.out.print("나이(수정): ");
        int age = 0;
        try {
            age = Integer.parseInt(scanner.nextLine());
        } catch (Exception e) {
            System.out.println("잘못된 입력입니다. 숫자를 입력하세요.");
            return;
        }

        System.out.print("전공(수정): ");
        String major = scanner.nextLine();

        // Student 정보 수정
        student.setName(name);
        student.setAge(age);
        student.setMajor(major);

        System.out.println("결과: 학생 정보가 수정되었습니다.");
    }

    /**
     * 학생 삭제
     */
    private static void deleteStudent() {
        System.out.println("-----------");
        System.out.println("학생삭제");
        System.out.println("-----------");

        System.out.print("학번: ");
        String studentId = scanner.nextLine();

        Student student = findStudent(studentId);

        if (student == null) {
            System.out.println("결과: 학생을 찾을 수 없습니다.");
            return;
        }

        // 배열에서 해당 학생을 찾아 null로 설정
        for (int i = 0; i < studentsArray.length; i++) {
            if (studentsArray[i] != null && studentsArray[i].getStudentId().equals(studentId)) {
                studentsArray[i] = null;
                System.out.println("결과: 학생이 삭제되었습니다.");
                break;
            }
        }
    }

    /**
     * 학번으로 학생을 찾는 보조 메서드
     * @param studentId 학번
     * @return Student 객체 (찾지 못하면 null)
     */
    private static Student findStudent(String studentId) {
        Student student = null;

        for (int i = 0; i < studentsArray.length; i++) {
            if (studentsArray[i] != null) {
                String dbStudentId = studentsArray[i].getStudentId();
                if (dbStudentId.equals(studentId)) {
                    student = studentsArray[i];
                    break;
                }
            }
        }

        return student;
    }
}

📝 코드 설명

1. Student 클래스

필드: 학번, 이름, 나이, 전공 (모두 private)
생성자: 모든 필드를 초기화
Getter/Setter: 필드 접근 및 수정을 위한 메서드

2. StudentApplication 클래스

main 메서드

while 반복문으로 메뉴를 계속 출력
사용자 선택에 따라 해당 기능 호출
6번(종료) 선택 시 프로그램 종료

registerStudent() - 학생 등록

학번 입력 및 중복 체크 (findStudent() 사용)
이름, 나이, 전공 입력
나이 입력 예외 처리 (try-catch)
Student 객체 생성
배열의 빈 자리(null)에 저장

studentList() - 학생 목록

배열을 순회하며 null이 아닌 Student 출력
printf를 사용하여 깔끔한 출력 형식

searchStudent() - 학생 검색

학번 입력
findStudent() 메서드로 학생 찾기
찾으면 정보 출력, 못 찾으면 에러 메시지

updateStudent() - 학생 수정

학번 입력 및 학생 찾기
새 정보 입력 (이름, 나이, 전공)
Setter 메서드를 사용하여 정보 수정

deleteStudent() - 학생 삭제

학번 입력 및 학생 찾기
배열에서 해당 학생을 찾아 null로 설정

findStudent() - 보조 메서드

배열을 순회하며 학번이 일치하는 Student 찾기
찾으면 Student 반환, 못 찾으면 null 반환
다른 메서드에서 재사용

🔍 주요 포인트

1. 배열 관리

// 학생 등록: 빈 자리 찾아 저장
for (int i = 0; i < studentsArray.length; i++) {
    if (studentsArray[i] == null) {
        studentsArray[i] = newStudent;
        break;
    }
}

// 학생 삭제: 해당 위치를 null로 설정
studentsArray[i] = null;

2. 중복 체크

if (findStudent(studentId) != null) {
    System.out.println("이미 존재하는 학번입니다.");
    return;
}

3. 예외 처리

try {
    age = Integer.parseInt(scanner.nextLine());
} catch (Exception e) {
    System.out.println("잘못된 입력입니다. 숫자를 입력하세요.");
    return;
}

4. null 체크

// 배열 순회 시 null 체크 필수
if (studentsArray[i] != null) {
    // Student 처리
}

5. String 비교

// == 대신 equals() 사용
if (dbStudentId.equals(studentId)) {
    // 일치
}

🎯 은행 애플리케이션과의 비교

구분 은행 애플리케이션 학생 관리 시스템

클래스	Account	Student
배열	Account[] accountsArray	Student[] studentsArray
등록	createAccount()	registerStudent()
목록	accountList()	studentList()
검색	findAccount() (보조)	searchStudent() + findStudent()
수정	- (은행에서는 수정 없음)	updateStudent()
삭제	- (은행에서는 삭제 없음)	deleteStudent()
기능	예금, 출금, 이체	검색, 수정, 삭제

📚 학습 목표 달성 체크

✅ 클래스 설계 (Student)
✅ 배열 관리 (등록, 삭제)
✅ 메서드 분리 (findStudent)
✅ 예외 처리 (try-catch)
✅ 중복 체크
✅ 메뉴 시스템
✅ Getter/Setter 활용
✅ null 체크
✅ String 비교 (equals)

💡 개선 가능한 부분

ArrayList 사용: 배열 대신 ArrayList를 사용하면 삭제가 더 효율적
학번 유효성 검사: 학번 형식 검증 추가
나이 범위 체크: 나이의 최소/최대 값 검증
데이터 저장: 파일에 저장하여 프로그램 종료 후에도 데이터 보존
정렬 기능: 학번, 이름 등으로 정렬 기능 추가

학생 관리 시스템 데이터 흐름 시각화

📌 프로그램 구조

클래스 구조

┌─────────────────────────────────────┐
│  StudentApplication (메인 클래스)   │
├─────────────────────────────────────┤
│ - studentsArray: Student[100]       │
│ - scanner: Scanner                  │
├─────────────────────────────────────┤
│ + main()                            │
│ - registerStudent()                 │
│ - studentList()                     │
│ - searchStudent()                   │
│ - updateStudent()                   │
│ - deleteStudent()                   │
│ - findStudent()                     │
└─────────────────────────────────────┘
              │
              │ 사용
              ▼
┌─────────────────────────────────────┐
│       Student (학생 클래스)          │
├─────────────────────────────────────┤
│ - studentId: String (학번)          │
│ - name: String (이름)               │
│ - age: int (나이)                   │
│ - major: String (전공)              │
├─────────────────────────────────────┤
│ + getStudentId()                    │
│ + getName()                         │
│ + getAge()                          │
│ + getMajor()                        │
│ + setName()                         │
│ + setAge()                          │
│ + setMajor()                        │
└─────────────────────────────────────┘

1️⃣ 배열 구조

studentsArray 초기 상태

┌─────────────────────────────────────────────────────────┐
│          studentsArray (Student[100])                    │
├─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬──────┤
│ [0] │ [1] │ [2] │ [3] │ ... │[99] │     │     │      │
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼──────┤
│null │null │null │null │ ... │null │     │     │      │
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴──────┘
     ↑
   모든 요소가 null (초기 상태)

표로 표현:

인덱스 값

[0]	null
[1]	null
[2]	null
[3]	null
...	...
[99]	null

2️⃣ 학생 등록 (registerStudent)

실행 흐름

사용자 입력
    ↓
학번: "2024001"
이름: "홍길동"
나이: 20
전공: "컴퓨터공학"
    ↓
findStudent("2024001") 호출
    ↓
배열에서 학생 찾기
    ↓
학생이 없으면 → 새 Student 객체 생성
    ↓
배열의 빈 자리(null)에 저장

메모리 구조 변화

1단계: Student 객체 생성

┌─────────────────────────────────────┐
│         Heap 메모리                  │
├─────────────────────────────────────┤
│                                     │
│  ┌───────────────────────────────┐ │
│  │   Student 객체                │ │
│  │   studentId: "2024001"        │ │
│  │   name: "홍길동"              │ │
│  │   age: 20                     │ │
│  │   major: "컴퓨터공학"         │ │
│  └───────────┬───────────────────┘ │
│              │                      │
└──────────────┼──────────────────────┘
               │ 참조
               │
┌──────────────▼──────────────────────┐
│    studentsArray[0]                 │
│    = newStudent                     │
└─────────────────────────────────────┘

2-1. 첫 번째 학생 등록

입력:

학번: "2024001"
이름: "홍길동"
나이: 20
전공: "컴퓨터공학"

배열 상태 변화:

단계 [0] [1] [2] [3] ... [99]

초기 상태	null	null	null	null	...	null
등록 후	Student 객체<br>(2024001, 홍길동, 20, 컴퓨터공학)	null	null	null	...	null

상세 데이터:

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	20	컴퓨터공학
[1]	null	-	-	-	-
[2]	null	-	-	-	-
[3]	null	-	-	-	-

2-2. 두 번째 학생 등록

입력:

학번: "2024002"
이름: "김철수"
나이: 21
전공: "소프트웨어"

배열 상태 변화:

단계 [0] [1] [2] [3] ... [99]

등록 전	Student<br>(2024001)	null	null	null	...	null
등록 후	Student<br>(2024001)	Student 객체<br>(2024002, 김철수, 21, 소프트웨어)	null	null	...	null

상세 데이터:

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	20	컴퓨터공학
[1]	✅	2024002	김철수	21	소프트웨어
[2]	null	-	-	-	-
[3]	null	-	-	-	-

2-3. 세 번째 학생 등록

입력:

학번: "2024003"
이름: "이영희"
나이: 19
전공: "정보통신"

배열 상태 변화:

단계 [0] [1] [2] [3] ... [99]

등록 전	Student<br>(2024001)	Student<br>(2024002)	null	null	...	null
등록 후	Student<br>(2024001)	Student<br>(2024002)	Student 객체<br>(2024003, 이영희, 19, 정보통신)	null	...	null

상세 데이터:

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	20	컴퓨터공학
[1]	✅	2024002	김철수	21	소프트웨어
[2]	✅	2024003	이영희	19	정보통신
[3]	null	-	-	-	-

3️⃣ 학생 목록 (studentList)

실행 흐름

studentList() 호출
    ↓
배열을 순회 (0부터 99까지)
    ↓
null이 아닌 Student 객체 찾기
    ↓
각 Student의 정보 출력

현재 배열 상태

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	20	컴퓨터공학
[1]	✅	2024002	김철수	21	소프트웨어
[2]	✅	2024003	이영희	19	정보통신
[3]	null	-	-	-	-
[4]	null	-	-	-	-
...	...	...	...	...	...
[99]	null	-	-	-	-

출력 결과

-----------
학생목록
-----------
2024001 홍길동   20 컴퓨터공학
2024002 김철수   21 소프트웨어
2024003 이영희   19 정보통신

처리 과정:

i = 0: studentsArray[0] != null → 출력 (홍길동)
i = 1: studentsArray[1] != null → 출력 (김철수)
i = 2: studentsArray[2] != null → 출력 (이영희)
i = 3: studentsArray[3] == null → 건너뜀
... i = 99: 모두 null → 종료

4️⃣ 학생 검색 (searchStudent)

실행 흐름

사용자 입력: 학번 "2024002"
    ↓
findStudent("2024002") 호출
    ↓
배열을 순회하며 학번 비교
    ↓
학번이 일치하는 Student 찾기
    ↓
Student 반환 또는 null 반환

검색 과정 시각화

입력: 학번 "2024002"

배열 상태:

인덱스 Student 객체 학번 비교 결과

[0]	✅	2024001	❌ "2024001" != "2024002"
[1]	✅	2024002	✅ "2024002" == "2024002" → 찾음!
[2]	✅	2024003	(검색 종료, 이미 찾음)

검색 결과:

-----------
학생검색
-----------
학번: 2024002
결과: 학생을 찾았습니다.
학번: 2024002, 이름: 김철수, 나이: 21, 전공: 소프트웨어

검색 실패 경우

입력: 학번 "2024999" (존재하지 않는 학번)

배열 상태:

인덱스 Student 객체 학번 비교 결과

[0]	✅	2024001	❌
[1]	✅	2024002	❌
[2]	✅	2024003	❌
[3]	null	-	건너뜀
...	...	...	...
[99]	null	-	건너뜀

검색 결과:

-----------
학생검색
-----------
학번: 2024999
결과: 학생을 찾을 수 없습니다.

5️⃣ 학생 수정 (updateStudent)

실행 흐름

사용자 입력: 학번 "2024001"
    ↓
findStudent("2024001") 호출 → Student 객체 찾기
    ↓
새로운 정보 입력
    이름: "홍길동" (변경 없음)
    나이: 21 (20 → 21로 변경)
    전공: "소프트웨어" (컴퓨터공학 → 소프트웨어로 변경)
    ↓
Student 객체의 Setter 메서드 호출
    student.setName("홍길동")
    student.setAge(21)
    student.setMajor("소프트웨어")
    ↓
객체의 필드 값 변경

수정 전 배열 상태

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	20	컴퓨터공학
[1]	✅	2024002	김철수	21	소프트웨어
[2]	✅	2024003	이영희	19	정보통신

수정 과정

입력:

학번: "2024001"
이름(수정): "홍길동"
나이(수정): 21
전공(수정): "소프트웨어"

메모리 변화:

수정 전:
┌───────────────────────────────┐
│   Student 객체 (studentsArray[0]) │
│   studentId: "2024001"        │
│   name: "홍길동"              │
│   age: 20  ←───── 변경        │
│   major: "컴퓨터공학" ←── 변경 │
└───────────────────────────────┘

수정 후:
┌───────────────────────────────┐
│   Student 객체 (studentsArray[0]) │
│   studentId: "2024001"        │
│   name: "홍길동"              │
│   age: 21  ←───── 변경됨      │
│   major: "소프트웨어" ←── 변경됨 │
└───────────────────────────────┘

주의: 배열의 인덱스는 변경되지 않고, 같은 Student 객체의 필드 값만 변경됩니다!

수정 후 배열 상태

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	21 ⬆️	소프트웨어 ⬆️
[1]	✅	2024002	김철수	21	소프트웨어
[2]	✅	2024003	이영희	19	정보통신

변경 사항:

studentsArray[0]의 age: 20 → 21
studentsArray[0]의 major: "컴퓨터공학" → "소프트웨어"

6️⃣ 학생 삭제 (deleteStudent)

실행 흐름

사용자 입력: 학번 "2024002"
    ↓
findStudent("2024002") 호출 → Student 객체 찾기
    ↓
배열을 순회하며 해당 Student 객체 찾기
    ↓
해당 위치를 null로 설정
    studentsArray[i] = null;
    ↓
객체는 가비지 컬렉션에 의해 제거됨

삭제 전 배열 상태

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	21	소프트웨어
[1]	✅	2024002	김철수	21	소프트웨어
[2]	✅	2024003	이영희	19	정보통신
[3]	null	-	-	-	-

삭제 과정

입력: 학번 "2024002"

배열 상태 변화:

단계 [0] [1] [2] [3]

삭제 전	Student<br>(2024001)	Student<br>(2024002)	Student<br>(2024003)	null
삭제 후	Student<br>(2024001)	null ⬅️	Student<br>(2024003)	null

삭제 후 배열 상태

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	21	소프트웨어
[1]	null ⬅️	-	-	-	-
[2]	✅	2024003	이영희	19	정보통신
[3]	null	-	-	-	-

메모리 변화:

삭제 전:
┌───────────────────────────────┐
│   Student 객체 (김철수)        │
│   studentId: "2024002"        │
│   name: "김철수"              │
│   age: 21                     │
│   major: "소프트웨어"         │
└───────────┬───────────────────┘
            │ 참조
studentsArray[1] ──┘

삭제 후:
studentsArray[1] = null;
            │
            │ 참조 끊김
            ▼
┌───────────────────────────────┐
│   Student 객체 (김철수)        │
│   → 가비지 컬렉션 대상         │
└───────────────────────────────┘

주의:

배열의 인덱스 [1]이 null로 변경됩니다.
[2]에 있던 Student 객체는 그대로 남아있습니다. (인덱스는 이동하지 않음)

7️⃣ 전체 과정 종합 예제

시나리오: 여러 작업을 순차적으로 수행

초기 상태

인덱스 Student 객체 학번 이름 나이 전공

[0]	null	-	-	-	-
[1]	null	-	-	-	-
[2]	null	-	-	-	-
[3]	null	-	-	-	-

작업 1: 학생 3명 등록

등록 데이터:

학번: "2024001", 이름: "홍길동", 나이: 20, 전공: "컴퓨터공학"
학번: "2024002", 이름: "김철수", 나이: 21, 전공: "소프트웨어"
학번: "2024003", 이름: "이영희", 나이: 19, 전공: "정보통신"

등록 후 배열 상태:

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	20	컴퓨터공학
[1]	✅	2024002	김철수	21	소프트웨어
[2]	✅	2024003	이영희	19	정보통신
[3]	null	-	-	-	-

작업 2: 학생 1명 추가 등록

등록 데이터:

학번: "2024004", 이름: "박민수", 나이: 22, 전공: "컴퓨터공학"

등록 후 배열 상태:

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	20	컴퓨터공학
[1]	✅	2024002	김철수	21	소프트웨어
[2]	✅	2024003	이영희	19	정보통신
[3]	✅	2024004	박민수	22	컴퓨터공학
[4]	null	-	-	-	-

작업 3: 학생 정보 수정

수정 데이터:

학번: "2024001"
이름: "홍길동" (변경 없음)
나이: 21 (20 → 21)
전공: "소프트웨어" (컴퓨터공학 → 소프트웨어)

수정 후 배열 상태:

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	21 ⬆️	소프트웨어 ⬆️
[1]	✅	2024002	김철수	21	소프트웨어
[2]	✅	2024003	이영희	19	정보통신
[3]	✅	2024004	박민수	22	컴퓨터공학
[4]	null	-	-	-	-

작업 4: 학생 삭제

삭제 데이터:

학번: "2024002"

삭제 후 배열 상태:

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	21	소프트웨어
[1]	null ⬅️	-	-	-	-
[2]	✅	2024003	이영희	19	정보통신
[3]	✅	2024004	박민수	22	컴퓨터공학
[4]	null	-	-	-	-

작업 5: 학생 목록 출력

출력 결과:

-----------
학생목록
-----------
2024001 홍길동   21 소프트웨어
2024003 이영희   19 정보통신
2024004 박민수   22 컴퓨터공학

처리 과정:

i = 0: studentsArray[0] != null → 출력 (홍길동)
i = 1: studentsArray[1] == null → 건너뜀
i = 2: studentsArray[2] != null → 출력 (이영희)
i = 3: studentsArray[3] != null → 출력 (박민수)
i = 4: studentsArray[4] == null → 건너뜀

8️⃣ 핵심 개념 정리

배열 관리 패턴

1. 등록: 빈 자리 찾기

for (int i = 0; i < studentsArray.length; i++) {
    if (studentsArray[i] == null) {  // 빈 자리 찾기
        studentsArray[i] = newStudent;  // 저장
        break;
    }
}

특징:

항상 앞에서부터 빈 자리를 찾습니다.
첫 번째로 만난 null 위치에 저장합니다.

2. 삭제: null로 설정

for (int i = 0; i < studentsArray.length; i++) {
    if (studentsArray[i] != null &&
        studentsArray[i].getStudentId().equals(studentId)) {
        studentsArray[i] = null;  // null로 설정
        break;
    }
}

특징:

삭제 후에도 배열 크기는 변하지 않습니다.
인덱스는 이동하지 않습니다. (빈 공간이 생김)

3. 목록: null 체크

for (int i = 0; i < studentsArray.length; i++) {
    if (studentsArray[i] != null) {  // null 체크 필수!
        // Student 정보 출력
    }
}

특징:

null이 아닌 요소만 처리합니다.
빈 공간은 자동으로 건너뜁니다.

데이터 저장 구조

studentsArray[인덱스] → Student 객체 → 필드 값들
         │
         │ 참조 (주소)
         ▼
    Heap 메모리
    ┌─────────────┐
    │ studentId   │
    │ name        │
    │ age         │
    │ major       │
    └─────────────┘

주의사항

null 체크 필수: 배열 접근 전에 항상 null 체크
인덱스 이동 없음: 삭제 후에도 다른 요소의 인덱스는 변경되지 않음
빈 공간 발생: 삭제하면 배열에 빈 공간(null)이 생김
순차 저장: 등록 시 앞에서부터 빈 자리에 순서대로 저장

9️⃣ 은행 애플리케이션과 비교

구분 은행 애플리케이션 학생 관리 시스템

배열 타입	Account[]	Student[]
등록	계좌 생성 (예금 포함)	학생 등록
목록	계좌 목록	학생 목록
검색	계좌 찾기 (보조)	학생 검색
수정	❌ (없음)	✅ 학생 정보 수정
삭제	❌ (없음)	✅ 학생 삭제
배열 관리	동일 (null 체크, 빈 자리 찾기)	동일

📚 학습 요약

핵심 포인트

배열 초기화: 모든 요소가 null
등록: 빈 자리(null)를 찾아 Student 객체 저장
목록: null이 아닌 요소만 출력
검색: 배열 순회하며 학번 비교
수정: Student 객체의 필드 값 변경 (같은 객체)
삭제: 해당 위치를 null로 설정

데이터 흐름

등록: null → Student 객체
수정: Student 객체 (필드 값 변경)
삭제: Student 객체 → null

🔍 실습 문제

다음 작업을 순서대로 수행했을 때, 최종 배열 상태를 표로 나타내세요.

학생 등록: 학번 "2024001", 이름 "홍길동", 나이 20, 전공 "컴퓨터공학"
학생 등록: 학번 "2024002", 이름 "김철수", 나이 21, 전공 "소프트웨어"
학생 등록: 학번 "2024003", 이름 "이영희", 나이 19, 전공 "정보통신"
학생 수정: 학번 "2024001"의 나이를 21로 수정
학생 삭제: 학번 "2024002" 삭제
학생 등록: 학번 "2024004", 이름 "박민수", 나이 22, 전공 "컴퓨터공학"

답:

인덱스 Student 객체 학번 이름 나이 전공

[0]	✅	2024001	홍길동	21	컴퓨터공학
[1]	null	-	-	-	-
[2]	✅	2024003	이영희	19	정보통신
[3]	✅	2024004	박민수	22	컴퓨터공학

설명:

[0]: 홍길동 등록 → 수정 (나이 20→21)
[1]: 김철수 등록 → 삭제 (null)
[2]: 이영희 등록 (그대로)
[3]: 박민수 등록 (빈 자리 [1] 다음에 저장)

'BackEnd > Java' 카테고리의 다른 글

9_1장_도서 대여 시스템 (1)	2026.01.16
배열-vs-ArrayList-비교 (0)	2026.01.16
8_1. 회차 은행 어플리케이션 프로그램 (0)	2026.01.14
5_1 . 이차원 배열 연습문제 (0)	2026.01.06
15장. 미니 프로젝트 & 실습 (0)	2026.01.04

8_2 .학생 관리 시스템 실습 문제

학생 관리 시스템 실습 문제

📌 문제 설명

1️⃣ Student 클래스 작성

요구사항

필드 (모두 private)

생성자

Getter 메서드

Setter 메서드 (선택사항)

2️⃣ StudentApplication 클래스 작성

요구사항

필드

메뉴 시스템

기능 1: 학생등록 (registerStudent)

기능 2: 학생목록 (studentList)

기능 3: 학생검색 (searchStudent)

기능 4: 학생수정 (updateStudent)

기능 5: 학생삭제 (deleteStudent)

보조 메서드: findStudent

종료 (6번 선택)

3️⃣ 추가 요구사항

예외 처리

배열 관리

메뉴 반복

4️⃣ 실행 결과 예시

5️⃣ 힌트

6️⃣ 평가 기준

📚 참고 자료

학생 관리 시스템 정답

📌 전체 코드

Student.java

StudentApplication.java

📝 코드 설명

1. Student 클래스

2. StudentApplication 클래스

main 메서드

registerStudent() - 학생 등록

studentList() - 학생 목록

searchStudent() - 학생 검색

updateStudent() - 학생 수정

deleteStudent() - 학생 삭제

findStudent() - 보조 메서드

🔍 주요 포인트

1. 배열 관리

2. 중복 체크

3. 예외 처리

4. null 체크

5. String 비교

🎯 은행 애플리케이션과의 비교

📚 학습 목표 달성 체크

💡 개선 가능한 부분

학생 관리 시스템 데이터 흐름 시각화

📌 프로그램 구조

클래스 구조

1️⃣ 배열 구조

studentsArray 초기 상태

2️⃣ 학생 등록 (registerStudent)

실행 흐름

메모리 구조 변화

1단계: Student 객체 생성

2-1. 첫 번째 학생 등록

2-2. 두 번째 학생 등록

2-3. 세 번째 학생 등록

3️⃣ 학생 목록 (studentList)

실행 흐름

현재 배열 상태

출력 결과

4️⃣ 학생 검색 (searchStudent)

실행 흐름

검색 과정 시각화

검색 실패 경우

5️⃣ 학생 수정 (updateStudent)

실행 흐름

수정 전 배열 상태

수정 과정

수정 후 배열 상태

6️⃣ 학생 삭제 (deleteStudent)

실행 흐름

삭제 전 배열 상태

삭제 과정