[KB IT's your life 7기] Java 제어문

Switch-Case문 (Switch Statement)

등장 배경

• 문제점:
  • 다중 if문: 코드가 지저분함
  • OR 조건 만들 때 표현이 복잡함
• 해결책: Switch문으로 코드 개선

기본 문법

switch(검사값) {
    case 값1:
        // 실행 코드
        break;
    case 값2:
        // 실행 코드
        break;
    default:
        // 기본 실행 코드
}

타입 제한사항

• 사용 가능: 정수형(int, long 등), String
• 사용 불가: 실수형(double, float), 대부분의 참조 타입
• 실수 불가 이유:
  • 실수는 근삿값으로 저장됨
  • 완전 일치 비교 시 오류 발생 가능성
• String 예외:
  • 초기에는 불가능했으나
  • 사용 빈도가 높아 후에 허용됨

Break문의 역할

• Break 있을 때:
  • Switch문을 즉시 벗어남
  • 해당 case만 실행
• Break 없을 때:
  • 다음 case로 계속 진행 (Fall-through)
  • 여러 case 연속 실행 가능

시간대별 작업 예제

• 8시 출발: 출근→회의→업무→외근 (모두 실행)
• 10시 출발: 업무→외근 (10시부터 실행)
• Break 없이 시작 위치만 다르게 설정

실행 결과

OR 조건 표현 (전통적 방법)

case 8:
case 9:
    // 8 또는 9일 때 실행
    break;

• Break 없이 case 연속 나열
• 대소문자 구분 없는 문자 검사 등에 활용
• 단점: 타이핑이 많음

Java 12 이후 새로운 문법

switch(검사값) {
    case 'A', 'a' -> {
        // 실행 코드
    }
    case 'B', 'b' -> {
        // 실행 코드
    }
    default -> {
        // 기본 코드
    }
}

• 특징:
  • 콤마(,)로 OR 조건 표현
  • 콜론(:) 대신 화살표(->) 사용
  • Lambda 함수 표현식
  • Break 불필요 (자동 return)
  • 중괄호 생략 가능 (한 줄일 경우)
• 장점: 시각적으로 깔끔, 간결한 표현

예시

실행결과

Default문

• 다중 if문의 마지막 else와 동일한 역할
• 모든 case에 해당하지 않을 때 실행
• 선택사항 (옵션)

 

중첩 루프문 (Nested Loop)

중첩 루프의 원칙

• 바깥 루프: 고차원(높은 차원)의 반복
• 안쪽 루프: 저차원(낮은 차원)의 반복
• 원칙: 바깥쪽으로 갈수록 높은 차원, 안쪽으로 갈수록 낮은 차원

2차원 테이블 순회 예시

// 행(row)과 열(column)을 가진 테이블
for (행에 대한 루프) {        // 바깥 루프 = 고차원 = 행
    for (열에 대한 루프) {    // 안쪽 루프 = 저차원 = 열
        // 처리
    }
}

결과

3차원 배열 순회 구조

• 최외곽 루프: Z 차원
• 중간 루프: 행(row)
• 최내각 루프: 열(column)

while문과 반복 제어

while문 특징

• 조건식이 참(true)인 경우에만 실행
• false가 되면 루프 탈출
• 필수 조건: 루프 내에서 조건식의 변수를 반드시 수정해야 함
  • 수정하지 않으면 → 무한 루프 발생

while문 vs for문

• for문: 횟수 기반 반복에 적합
• while문: 패턴 없이 변하는 값, 입력값에 따른 종료 처리에 적합

while문 활용 예제

boolean run = true;
while(run) {
    // 메뉴 제시
    // 1. 증속, 2. 감소, 3. 정지
    Scanner scanner = new Scanner(System.in);
    String input = scanner.nextLine();

    if(input.equals("3")) {
        run = false;  // 다음 루프에서 종료
    }
}

메뉴 확장 시 문제점

• 메뉴 추가 시 if-else 문이 계속 증가
• 번호 조정 필요
• 유지보수 관점에서 좋지 않은 구조
• 해결책: 객체 지향 기법 활용 (추후 학습)

---

do-while문

구조와 특징

do {
    // 실행문 (최소 1번은 실행 보장)
} while(조건식);

• 조건식이 뒤에 위치
• 최소 1번 실행 보장 (while문과의 주요 차이점)
• while문: 처음부터 거짓이면 실행 안 될 수 있음
• do-while문: 검사를 맨 뒤에 하므로 적어도 한 번은 실행

사용 빈도

• JavaScript에서도 존재하지만 사용 빈도가 매우 낮음
• Java에서도 상대적으로 사용 빈도 낮음

---

참조 타입과 비교 연산

참조 타입의 비교 연산 (==)

• Primitive 타입: 실제 값을 비교
• 참조 타입: 참조값(Reference Value)을 비교
  • 변수 자체가 가지고 있는 참조값으로 비교
  • 실제 내용이 같아도 참조가 다르면 false

예시

// 두 개의 배열 객체가 힙에 생성
int[] array1 = new int[]{1, 2, 3};
int[] array2 = new int[]{1, 2, 3};
int[] array3 = array2;

array1 == array2  // false (참조값이 다름)
array2 == array3  // true (같은 곳을 참조)

실제 내용 비교 필요성

• 참조값 비교도 필요하지만, 실제 내용 비교가 더 일반적
• 배열, 문자열, 객체 등 모든 참조 타입에 동일하게 적용

---

null의 개념과 활용

null의 정의

• 실체: 숫자 0
• 의미: 아무것도 참조하지 않음
• 모든 참조 타입에 공통적으로 사용 가능한 값
• 연결된 실제 객체가 없음을 의미

null의 주요 용도

1. 참조 타입 초기화
   • 지역 변수는 초기화되지 않음 (쓰레기 값 존재)
   • 안전한 사용을 위해 null로 초기화 필요
   • Heap에서 생성되는 경우: 자동으로 0(null)으로 초기화
2. 메모리 반납
   • 참조를 null로 설정하면 객체가 가비지(Garbage)가 됨
   • Garbage Collector에 의해 자동 반납

null 사용 가능한 연산

• 유일한 연산: 같냐/다르냐 (== / !=)
• null에 대한 접근 시도 → NullPointerException 발생

안전한 null 처리

if(변수 != null) {
    // null이 아닐 때만 처리
}

---

메모리 영역과 초기화

Heap 영역

• 초기화: 0으로 자동 초기화
• 생성 키워드: new
• 사용 빈도가 상대적으로 낮음
• 시간을 투자해서 초기화

Stack 영역

• 초기화 없음: 이전 데이터가 그대로 남아있음 (쓰레기 값)
• 이유: 함수 호출이 빈번하고 속도가 중요하므로 초기화 시간 절약
• 함수 호출 시 사용되는 영역
• 빠른 운영 필요

초기화 값의 의미

• 기본 타입: 0으로 초기화
• boolean: false로 해석
• 참조 타입: null (0은 참조 타입에서 null을 의미)

---

가비지 컬렉션 (Garbage Collection)

가비지 생성 방법

1. null 배정
2. array = null; // 기존 참조 제거
3. 다른 객체 참조
4. array = new int[5]; // 기존 참조 잃어버림

가비지 컬렉션의 획기적 메커니즘

• 이전 (C/C++): malloc/free, new/delete를 개발자가 직접 관리
  • 메모리 누수(Memory Leak) 문제 빈번
• Java: Garbage Collector가 자동 관리
  • 메모리 반납에 대한 신경 불필요
  • 이후 대부분의 언어가 채택

가비지 컬렉션 실행 시점

• 즉시 사라지지 않음
• JVM에 의해 Garbage Collector가 스케줄링됨
• 스캔 후 발견되면 그때 메모리 반납
• 개발자는 신경 쓸 필요 없음

---

문자열 (String)

문자열의 특징

• 불변 객체 (Immutable Object)
• 한 번 생성되면 데이터 수정 불가
• 불변 객체로 운영하는 언어: Java, JavaScript, Python
• 변경 허용 언어: C, C++ (원본 수정 가능)

문자열 생성 방법

리터럴 방식 (대입)

String name1 = "홍길동";
String name2 = "홍길동";
// 같은 리터럴은 한 번만 생성되어 공유됨
// name1 == name2 → true (같은 참조)

• 리터럴은 상수 처리
• 동일한 리터럴은 재사용 (한 벌만 생성)
• 편리하지만 참조가 동일함

new 키워드 방식 (명시적 객체 생성)

String name3 = new String("홍길동");
// 별도의 객체 생성
// name1 == name3 → false (다른 참조)

• 명시적으로 객체 생성
• 서로 다른 참조를 가짐

문자열 비교

// 참조값 비교
name1 == name2    // 리터럴: true
name1 == name3    // 다른 객체: false

// 실제 내용 비교
name1.equals(name3)  // true (내용이 같음)

결과

주요 문자열 메서드

charAt() - 문자 추출

char c = str.charAt(0);  // 0번째 글자 추출
// Java는 배열식 접근(str[0]) 불가
// 이유: 연산자 오버로딩 미지원

length() - 문자열 길이

int len = str.length();
// 주민등록번호 자릿수 확인 등에 활용

replace() - 문자열 대체

String result = str.replace("Java", "java");
// 불변 객체: 원본 변경 불가
// 새로운 문자열 생성하여 리턴

substring() - 문자열 추출

String sub1 = str.substring(시작인덱스);           // 시작~끝까지
String sub2 = str.substring(시작인덱스, 끝인덱스);  // 끝인덱스는 미포함

// 주민등록번호 앞 6자리
String front = ssn.substring(0, 6);  // 0~5까지

• 끝인덱스는 미포함 (헷갈리기 쉬운 부분)

---

배열 (Array)

배열의 기본 특징

• 참조 타입
• 크기 고정: 한 번 생성되면 크기 변경 불가
• 동일 타입: 같은 타입의 데이터만 저장

배열 선언 방법

권장 방식

int[] array;        // 타입[] 변수명
double[] scores;    // 참조 타입임을 명확히 표현

가능하지만 비권장

int array[];        // C 스타일

• 첫 번째 방식 선호 이유: "Integer 배열에 대한 참조 변수"임이 명확

배열 생성과 초기화

선언과 동시에 초기화 (new 생략 가능)

int[] array = {1, 2, 3};
// 선언문에서만 중괄호만으로 초기화 가능

선언과 할당 분리

int[] array;                    // 선언
array = new int[]{1, 2, 3};     // new 필수
// array = {1, 2, 3};           // 에러! (코드 블록으로 해석)

크기만 지정

int[] array = new int[30];
// 0으로 초기화됨 (힙에 생성되므로)

메서드 매개변수로 전달

// 잘못된 방법
printItem({1, 2, 3});           // 에러!

// 올바른 방법
printItem(new int[]{1, 2, 3});  // new 필수

배열의 length

int len = array.length;  // 괄호 없음 (메서드가 아닌 필드/상수)

• 메서드가 아닌 상수 (final 변수)
• 배열 생성 시 자동으로 초기화
• 읽기 전용 (Read-only): 값 변경 불가
• for문 종료 조건으로 자주 사용

배열 순회

for(int i = 0; i < array.length; i++) {
    // array[i] 처리
}

다차원 배열

Java 다차원 배열의 특징

• 고차원 배열 = 저차원 배열에 대한 참조변수의 배열
• 각 차원의 배열 길이가 다를 수 있음 (C/C++와의 차이점)
• 타입은 동일하지만 길이는 제각각 가능

결과

2차원 배열 선언과 초기화

동시 초기화

int[][] scores = {
    {1, 2, 3},      // 첫 번째 배열 (길이 3)
    {4, 5}          // 두 번째 배열 (길이 2)
};

길이만 지정 (모든 차원)

int[][] scores = new int[2][3];
// 2개의 배열, 각각 3개의 요소
// 모든 배열의 길이가 동일

고차원만 지정 (단계별 생성)

// 1단계: 고차원 배열만 생성
int[][] scores = new int[2][];
// scores[0] = null, scores[1] = null

// 2단계: 각 배열을 개별 생성 (길이가 달라질 수 있음)
scores[0] = new int[3];   // 길이 3
scores[1] = new int[2];   // 길이 2

다차원 배열 접근

개별 배열 길이 확인

scores.length           // 고차원 배열의 길이 (2)
scores[0].length        // 첫 번째 배열의 길이 (3)
scores[1].length        // 두 번째 배열의 길이 (2)

이중 루프로 순회

for(int i = 0; i < scores.length; i++) {           // 바깥 루프
    for(int j = 0; j < scores[i].length; j++) {   // 안쪽 루프 (길이가 다를 수 있음)
        // scores[i][j] 처리
    }
}

• 주의: 하드코딩하면 안 됨 (각 배열의 길이가 다를 수 있으므로)
• 반드시 scores[i].length 사용

차원별 인덱스 의미

• 앞쪽 인덱스: 고차원
• 뒤쪽 인덱스: 저차원
• 예: scores[i][j]
  • i: 행 (고차원)
  • j: 열 (저차원)

Java 기본 자료형

자료형의 분류

• 기본 자료형(Primitive Type): 8가지
• 참조 자료형(Reference Type): 기본형 이외 모든 것

•  

단일 문자형

• char: 2 bytes
  • 2바이트 체계 유니코드 사용
  • 한 글자 표현

논리형

• boolean: 1 byte
  • 값: true 또는 false만 가능
  • 형변환 불가: 다른 자료형과 절대 변환 안 됨
  • JavaScript와 달리 0을 false로 인식 안 함
  • 오직 true/false(소문자)만 허용

형변환 규칙

• 자동 형변환: 작은 타입 → 큰 타입
  • 예: byte → short → int → long → float → double
• 강제 형변환: 큰 타입 → 작은 타입 (데이터 손실 가능)
• 예외: boolean은 어떤 타입과도 형변환 불가