https://www.youtube.com/watch?v=DNCBaeCoMug
1. 이건 꼭 알아야 한다[^1]
[? 질문] 자바를 “빠르게 훑되” 실제로 코드를 읽고 쓸 수 있으려면 어떤 범위를 알아야 하는가[^2]
[= 답] 자료형/변수 → 연산자 → 문자열 → 제어문 → 배열(다차원 포함) → 메소드 → 클래스(OOP 핵심) → 추상/인터페이스 → 제네릭/컬렉션 → 익명/람다/스트림 → 예외 → 스레드 → 입출력/파일까지, 자바를 다루는 데 필수인 주제를 한 번씩은 전부 지나가야 한다.[^2]
[? 질문] 자바에서 “값”과 “객체(참조)”를 헷갈리지 않으려면 무엇을 구분해야 하는가[^3]
[= 답] 기본 자료형은 실제 값을 저장하고, 참조 자료형은 값이 있는 메모리 주소(참조)를 저장한다는 차이를 먼저 잡아야 하며, 이 차이가 문자열 비교(== vs equals), 대입/복사 동작, 클래스/객체 개념으로 계속 이어진다.[^3]
[? 질문] 초보가 가장 빨리 실수하는 문법 포인트(비교, 형변환, 조건/반복, 예외, 동시성)는 무엇이며 어떻게 피하는가[^4]
[= 답] =(대입)와 ==(비교)를 구분하고, 문자열은 equals로 비교하며, 작은 타입으로 바꿀 때는 명시적 형변환을 하고, 반복문에서는 **무한루프(증감 누락)**를 조심하며, 예외는 try-catch(-finally) 또는 throws로 다루고, 스레드 공유 자원은 synchronized로 동기화한다.[^4]
2. 큰 그림[^5]
이 강의는 “핵심만 빠르게” 자바 문법과 표준 라이브러리의 필수 요소를 2시간 분량으로 한 번에 훑어, 초보자는 자바 전체 지형도를 만들고 경험자는 복습할 수 있게 구성되어 있다.[^2][^5] 환경 설정은 강의 범위에 포함하지 않으며(별도 안내), 문법/개념/예제 중심으로 진행된다.[^6]
- 기초 문법부터 실무에 자주 닿는 기능까지(예외, 스레드, 파일 I/O, 컬렉션, 스트림)를 한 흐름으로 연결해 “자바로 개발할 때 필요한 최소 체력”을 마련한다.[^2]
- **“값 vs 참조”**처럼 자바에서 반복적으로 등장하는 핵심 원리를 여러 주제(문자열 비교, 클래스/객체, 참조 복사, final 등)에서 계속 재확인한다.[^3]
- 단순 문법 나열이 아니라, 각 기능이 왜 필요한지(예: 반복문으로 중복 제거, switch로 경우 분기, try-catch로 문제 상황 처리, synchronized로 경쟁 상태 방지)를 짧은 사례로 보여준다.[^7]
3. 하나씩 살펴보기[^8]
3.1 강의 소개와 학습 전제(환경 설정 안내 제외)[^9]
강의자는 “핵심만 빠르게 자바를 공부”할 수 있는 2시간 분량 강의를 준비했다고 밝히며, 자료형부터 시작해 연산자/제어문/배열/클래스/예외/스레드/파일까지 자바 필수 내용을 포함한다고 소개한다.[^2] 이미 자바를 공부한 사람에게는 복습용, 처음 보는 사람에게는 빠른 훑어보기용으로 적합하다고 안내한다.[^5] 다만 자바 개발 환경 설정은 따로 다루지 않으니, 실습 희망자는 인프런 무료 미리보기 등을 통해 PC 환경에 맞는 설정을 진행하라고 한다.[^6]
3.2 자료형(Data Type)과 기본/참조 자료형 구분[^10]
3.2.1 자료형이란 무엇인가[^11]
자료형은 “자료의 형태”이며 영어로 데이터 타입이라고도 부른다.[^11] 예시로 "Hello World", "안녕하세요" 같은 텍스트는 문자열(String) 자료형이라고 설명한다.[^12] 숫자는 정수/실수 형태로 나뉘며 int/long/double/float 등이 있고, 참/거짓은 boolean(tru/false)만 갖는다고 한다.[^13]
3.2.2 기본 자료형 vs 참조 자료형[^14]
자료형은 기본 자료형과 참조 자료형으로 나뉜다.[^14]
- 기본 자료형: 실제 데이터 값을 바로 저장한다.[^14]
- 참조 자료형: 데이터가 저장된 메모리 주소 값(참조)을 저장한다.[^14]
기본 자료형 예시는 int, long, float, double, boolean, char 등을 들고, 참조 자료형은 기본 자료형을 제외한 “모든 것들”, 즉 클래스/인터페이스/배열/열거형 등이 해당한다고 한다.[^15] 문자열 String 역시 참조 자료형임을 따로 강조한다.[^16]
3.2.3 기본 자료형의 크기/정밀도 예시[^17]
강의는 각 타입의 “크기(바이트)와 표현 범위/정밀도” 감각을 잡게 한다.[^17]
int: 정수, 4바이트, 대략 -21억 ~ +21억 범위.[^17]long: 정수, 8바이트, 더 큰 범위의 수 저장.[^18]float: 실수, 4바이트, 약 6~7자리 정도 정확히 표현.[^19]double: 실수, 8바이트, 약 15자리 정도 정확히 표현.[^20]boolean: 참/거짓, 1바이트, 값은true/false.[^21]char: 문자 1개, 2바이트.[^22]
[!NOTE] “얼마나 큰 수/정밀도가 필요한가”는 타입 선택의 기준
강의는int ↔ long,float ↔ double의 크기/정밀도 차이를 수치로 제시해, “왜 타입이 여러 개인지”를 범위/정확도 관점에서 이해하게 한다.[^17][^20]
3.3 변수: 선언, 초기화, 분리해서 대입[^23]
변수는 값을 저장하기 위한 “공간”으로 설명한다.[^23] 변수를 만들 때는 자료형 변수명 = 값; 형태로 선언과 동시에 초기화할 수 있다.[^24] 예시로 문자열 name, 정수 hour, 실수 score, 문자 grade, 불리언 pass 같은 변수를 각각 타입에 맞는 값으로 넣는 패턴을 보여준다.[^25]
또한 선언과 대입을 분리할 수도 있다.[^26] 예를 들어 int a;로 먼저 변수를 만든 뒤, 다음 줄에서 a = 15;처럼 값을 나중에 넣는 방식도 가능하다고 한다.[^27]
3.4 주석: 한 줄 주석과 여러 줄 주석[^28]
주석은 코드에 설명을 달기 위한 것이며, 실행되지 않고 무시된다고 설명한다.[^28][^29]
- 한 줄 주석:
//를 문장 뒤에 붙여 설명을 달거나, 문장 앞에 붙여 그 줄 실행을 막는다.[^30] - 여러 줄 주석:
/* ... */로 여러 문장을 감싸 한꺼번에 주석 처리한다.[^31]
예시로 int hour = 15; 뒤에 “현재 시각은 15시” 같은 설명을 달거나, 특정 줄(예: double score = 90.5;)을 잠시 비활성화하는 방식이 나온다.[^30]
3.5 변수 이름 짓기 규칙(제약/권장)과 예약어[^32]
변수명은 “값을 가장 잘 표현하는 이름”이 좋다고 전제하고, 자바의 제약을 정리한다.[^33]
- 사용 가능 문자: 문자/숫자/밑줄(underscore)만 가능.[^34]
- 공백 불가.[^35]
- 시작: 밑줄 또는 문자로 시작(숫자로 시작 불가).[^36]
- 권장: 한 단어 또는 여러 단어 조합으로 의미 있게.[^37]
- 자바 관례: 소문자로 시작, 여러 단어면 뒤 단어 첫 글자를 대문자(카멜 케이스).[^38]
- 예약어 사용 불가:
public,static,void,int등 이미 자바에서 의미를 가진 키워드는 변수명 불가.[^39] - 대소문자 구분:
myName과myname은 서로 다른 변수.[^40]
3.6 상수(final): “변하지 않는 값” 만들기[^41]
상수는 변하지 않는 값이며, 변수 선언 앞에 final을 붙여 만든다고 한다.[^41][^42] 예시로 final int a = 15;처럼 만들면, 이후 a = 20;처럼 값을 바꾸는 시도는 불가능해진다.[^43] “코드에서 딱 한 번 정의하고 더 이상 바뀔 일이 없는 데이터”에 상수를 쓰라고 정리한다.[^44]
3.7 형 변환(Casting): 명시적/묵시적 변환과 데이터 손실[^45]
형 변환은 정수/실수/문자열 등 자료형 간 변환이며, 변환 대상 앞에 (타입)을 붙여 명시한다고 설명한다.[^45]
- 예:
int score = 93;을float로 바꾸고 싶으면(float) score형태로 변환해floatScore에 저장.[^46] - 값 자체(리터럴)도
(double) 93처럼 변환 가능.[^47]
묵시적 형 변환(자동 변환)[^48]
컴파일러가 손실이 없다고 판단하면 타입 표기를 생략해도 자동 변환이 일어난다.[^48] 예시로 int → long, long → float, float → double 같은 “작은 범위/정밀도에서 큰 쪽으로” 가는 방향을 든다.[^49]
명시적 형 변환(필수)과 손실[^50]
반대로 double → int처럼 “큰 타입에서 작은 타입”으로 바꾸면 소수점이 버려지는 등 데이터 손실이 발생할 수 있어 반드시 타입을 명시해야 한다.[^50] 예로 98.8을 int로 바꾸면 98이 되며 소수점이 사라진다고 설명한다.[^51]
[!IMPORTANT] 형 변환 판단 기준
“손실이 없으면 자동(묵시적), 손실 가능성이 있으면 반드시 명시”가 강의의 핵심 규칙이다.[^48][^50]
3.8 연산자: 산술/대입(복합)/비교/논리/삼항[^52]
3.8.1 연산자 개념과 산술 연산자[^53]
연산자는 값을 계산하는 기호이며 +, - 같은 것이 예시로 제시된다.[^53] 산술 연산자로 +, -, *(곱셈), /(나눗셈), %(나머지)를 설명한다.[^54][^55] 프로그래밍에서 곱하기는 x가 아니라 *를 쓰고, 나누기는 /를 쓴다는 점을 강조한다.[^55]
3.8.2 증가/감소 연산자(전위/후위)[^56]
++, --는 증가/감소 연산자이며, 변수 앞에 붙이면 전위(먼저 증가/감소), 뒤에 붙이면 **후위(다른 연산 후 증가/감소)**라고 설명한다.[^56][^57]
3.8.3 대입 연산자와 복합 대입 연산자[^58]
=는 오른쪽 값을 왼쪽 변수에 대입한다.[^58] 예로 num = 10; 이후 num = num + 2;는 12가 되고, 다시 num = num - 2;면 10이 된다는 식으로 “오른쪽 계산 후 왼쪽에 저장” 흐름을 보여준다.[^59]
반복되는 패턴은 +=, -=, *=, /=, %= 같은 복합 대입 연산자로 줄일 수 있다고 한다.[^60][^61]
3.8.4 비교 연산자: >, >=, <, <=, ==, !=[^62]
비교 연산자는 결과가 boolean으로 나온다.[^62]
>는 왼쪽이 더 큰지, >=는 크거나 같은지, <, <=도 동일하게 설명한다.[^63]
특히 “같다” 비교는 ==(등호 두 번)이고, = 한 번은 대입이라는 점을 수학과 다르다고 강조한다.[^64]
다름 비교는 !=로 한다.[^65]
3.8.5 논리 연산자: &&, ||, ![^66]
&&: 둘 다 참이어야 참.[^66]||: 하나라도 참이면 참.[^67]!: 참/거짓 반전.[^68]
3.8.6 삼항 연산자(?:)[^69]
형태는 조건 ? 참일 때 값 : 거짓일 때 값이며, 조건이 참이면 콜론 왼쪽, 거짓이면 오른쪽이 선택된다.[^69][^70]
예시로 x=3, y=5에서 더 큰 값을 max에 넣기 위해 (x > y) ? x : y를 사용하고, 결과는 5가 된다고 설명한다.[^71]
3.9 문자열(String): 기본 기능, 비교, 이스케이프 시퀀스[^72]
3.9.1 문자열 기본과 주요 메소드[^73]
문자열은 여러 문자들의 집합이며 "I like Java" 같은 형태로 큰따옴표로 감싼다.[^73][^74] 강의는 자주 쓰는 기능을 예시 중심으로 소개한다.[^75]
- 길이:
s.length()→ 공백 포함 길이(예: 11) 확인.[^76] - 대/소문자:
toUpperCase(),toLowerCase().[^77] - 포함 여부:
contains("...")→ 있으면true.[^78] - 위치 찾기:
indexOf("Java")→ 시작 인덱스 반환(인덱스는 0부터).[^79] - 마지막 위치:
lastIndexOf("A")→ 마지막으로 등장한 위치.[^80] - 시작/끝:
startsWith("I"),endsWith(".").[^81] - 치환:
replace("like", "love").[^82] - 자르기:
substring(7)→ 7 인덱스 이후만 잘라 출력.[^83] - 앞뒤 공백 제거:
trim().[^84] - 결합:
concat(" ...").[^85]
[!TIP] 인덱스는 0부터 시작
indexOf/substring예시에서 “0 1 2 …”로 세는 방식이 반복해서 등장한다.[^79][^83]
3.9.2 문자열 비교: ==가 아니라 equals[^86]
정수는 ==로 값 비교가 가능함을 먼저 보여준다.[^87]
하지만 문자열은 ==로 비교하면 안 된다고 강조한다.[^86]
- 리터럴로 만든 문자열(
String s1="Java"; String s2="Java";)은 같은 곳을 참조할 수 있어==가true가 될 수 있다.[^88] new String("Java")로 만들면 같은 내용이어도 서로 다른 공간을 참조하므로==비교 결과가false가 된다.[^89][^90]
따라서 자바에서 문자열 “값” 비교는 s1.equals(s2)를 써야 한다고 결론낸다.[^91] 이 부분은 헷갈리기 쉬우니 주의하라고 덧붙인다.[^92]
3.9.3 특수 문자(escape sequence)[^93]
특수 문자는 특별한 기능을 수행하는 문자이며 대표 예시는 다음과 같다.[^93]
\n: 줄바꿈.[^94]\t: 탭.[^95]\\: 역슬래시 자체 표현(경로 표기 등에서 필요).[^96]\": 큰따옴표 출력.[^97]\': 작은따옴표 출력.[^98]
3.10 제어문: if/else/else if, switch-case, 반복문, break/continue[^99]
3.10.1 if: 조건 분기와 블록(중괄호) 사용[^100]
if는 조건에 따른 분기이며 if(조건) { ... } 형태로 설명한다.[^100] 실행 문장이 1줄이면 중괄호를 생략할 수 있고, 2줄 이상이면 {}로 감싼다.[^101]
예시로 int num=3;일 때 num>0이면 특정 출력이 실행되고, num<0이면 다른 출력이 실행되는 방식으로 “조건이 참인 블록만 실행”됨을 보여준다.[^102]
또한 조건을 &&(AND) 또는 ||(OR)로 여러 개 묶을 수 있음을 예시로 연결한다.[^103]
3.10.2 else: 조건 불만족 시 실행[^104]
if 조건이 참이 아닐 때 실행되는 블록이 else다.[^104] 예시에서 num=3이고 num<0 조건이 거짓이므로 if 블록은 건너뛰고 else 블록(“0보다 작지 않아요”)이 실행된다.[^105]
3.10.3 else if: 여러 조건을 순차 검사[^106]
else if는 첫 조건이 거짓일 때 다음 조건을 추가로 검사하는 구조이며 여러 번 사용할 수 있다.[^106][^107]
예시로 num=3일 때 <3, >3, ==3을 순서대로 비교해 마지막 조건이 참이 되어 해당 문장이 실행되는 흐름을 보여준다.[^108]
정리로, if는 여러 번 가능하지만 else는 “없거나 마지막에 한 번만” 가능하다고 주의점을 준다.[^109]
3.10.4 switch-case: “경우(case)” 기반 분기와 break/default[^110]
switch-case는 특정 값에 따른 분기이며 switch(조건) { case ...: ... break; default: ... } 형태를 제시한다.[^110][^111]
예시로 게임 메뉴 값 menu=2에서:
- case 1: “시작” 출력
- case 2: “설정” 출력
- default: “잘못된 메뉴” 출력
이라는 동작을 설명한다.[^112]
break가 없으면 다음 case로 넘어가 실행될 수 있으며, default도 필요 없으면 생략 가능하다고 한다.[^113]
3.10.5 반복문: for / while / do-while[^114]
for문 구조(선언; 조건; 증감)[^115]
for는 반복문으로, 괄호 안에 선언, 조건, 증감 3요소가 들어간다.[^115]
예시로 i=0; i<5; i++ 동안 “안녕”을 출력하면 5번 출력된다고 설명하며, 순서를 “선언 → 조건 확인 → 실행 → 증감”으로 정리한다.[^116]
while문: 조건이 참인 동안 반복[^117]
while(조건) { ... }이며, 선언이 필요하면 밖에서 선언할 수 있다고 한다.[^118] 예시로 i=0부터 i<5 동안 출력 후 i++ 해서 총 5번 출력한다.[^119]
do-while: 무조건 1번 실행 후 조건 검사[^120]
do { ... } while(조건); 형태로, 먼저 1회 실행한 뒤 조건을 검사한다.[^120][^121]
while은 처음 조건이 거짓이면 한 번도 실행되지 않지만, do-while은 일단 한 번 실행된다는 차이를 강조한다.[^121]
또한 i++ 같은 증감이 없으면 무한 루프가 될 수 있다고 경고한다.[^122]
3.10.6 이중 반복문: 반복문 중첩과 실행 횟수 곱셈[^123]
바깥 for가 2번, 안쪽 for가 3번 실행되는 예시로 “안녕”이 총 6번 출력되는 과정을 단계적으로 풀어 설명한다.[^124][^125]
3.10.7 break: 반복문 탈출[^126]
원래 5번 인사하는 for문에서, 결석 등 이유로 3번만 인사하려면 if(i==3) break;로 반복을 중단할 수 있다고 한다.[^126][^127]
3.10.8 continue: 해당 회차 건너뛰기[^128]
특정 회차만 인사를 생략하려면 if(i==2) continue;로 그 회차의 아래 코드를 실행하지 않고 다음 반복으로 넘어간다고 설명한다.[^129]
3.11 배열: 선언/초기화/순회/다차원 배열/아스키 코드[^130]
3.11.1 배열 개념과 선언/생성[^131]
배열은 같은 자료형의 값 여러 개를 저장하는 연속된 공간이다.[^131]
선언/생성은 int[] numbers = new int[5];, String[] names = new String[3];처럼 한다.[^132]
3.11.2 인덱스로 값 대입(0부터 시작)[^133]
numbers[0]=1, numbers[1]=5처럼 인덱스로 각 위치에 값을 넣으며, 인덱스는 0부터 시작한다.[^133][^134] 강의는 크기 5 배열이면 인덱스가 0~4라는 그림 설명을 곁들인다.[^134]
3.11.3 대괄호 위치 대안과 선언과 동시에 초기화[^135]
대괄호는 int[] numbers뿐 아니라 int numbers[]처럼 변수명 뒤로 옮겨도 된다고 한다.[^136]
또한 중괄호로 값을 나열하면 크기를 따로 쓰지 않고 초기화 가능하며, new int[]{1,2,3,4,5}뿐 아니라 int[] numbers = {1,2,3,4,5};처럼 new 부분 생략도 가능하다고 설명한다.[^137][^138]
3.11.4 배열 순회: 일반 for vs 향상된 for-each[^139]
- 일반 for:
for(i=0; i<numbers.length; i++)로 인덱스를 돌며numbers[i]접근.[^140] - for-each:
for(int number : numbers)처럼 요소를 직접 꺼내며, 변수명을i보다 의미 있는number로 쓰면 덜 헷갈린다고 조언한다.[^141][^142]
3.11.5 다차원 배열: 2차원 구조, 인덱스 2개, 초기화/순회[^143]
2차원 배열은 “가로+세로”의 면 형태로 설명하며, 3차원은 높이까지 더해지는 공간 형태라고 비유한다.[^144]
생성은 int[][] numbers = new int[2][5];처럼 세로 2, 가로 5를 지정한다.[^145] 값 접근은 numbers[row][col]처럼 인덱스를 2개 쓴다.[^146]
선언과 동시에 초기화는 바깥 중괄호 안에 행(세로줄) 단위로 중괄호를 한 번 더 넣어 { {1,2,3,4,5}, {6,7,8,9,10} } 같은 구조로 한다.[^147]
순회는 for를 2번 중첩해서 numbers[i][j]에 접근하며, 크기는 numbers.length(세로), numbers[i].length(가로)로 얻는 방법을 소개한다.[^148][^149]
3.11.6 아스키 코드: 숫자/대문자/소문자 시작값[^150]
아스키 코드는 정보 교환을 위한 미국 표준 코드라고 소개하고, 외워두면 좋은 시작값을 제시한다.[^150]
- 숫자
'0'시작: 48[^151] - 대문자
'A'시작: 65[^152] - 소문자
'a'시작: 97[^153]
강의는 “이 정도 시작값만 알아도 도움이 된다”고 정리한다.[^154]
3.12 메소드: 정의/호출, 파라미터, return, 오버로딩, 변수 범위(scope)[^155]
3.12.1 메소드 정의와 호출[^156]
메소드는 특정 기능 수행 코드의 묶음이며, 접근제어자/반환형/이름/전달값(파라미터)/본문 블록으로 구성된다.[^156]
예시로 print() 메소드를 만들어 “안녕”을 출력하게 하고, print(); 호출 시 메인 실행 흐름이 메소드로 들어가 해당 문장을 실행한다고 설명한다.[^157][^158]
3.12.2 전달값(파라미터): 1개/여러 개[^159]
파라미터는 호출 시 전달하는 값이며, 메소드 정의의 괄호 안에 타입과 함께 선언한다.[^159]
print(int a)처럼 정의하면 호출할 때 print(3), print(10)처럼 정수값을 전달할 수 있다.[^160]
여러 개는 add(int a, int b)처럼 콤마로 구분하며, 호출도 add(1,2), add(3,5)처럼 한다.[^161][^162]
3.12.3 반환값(return)과 반환형[^163]
반환값은 메소드 실행 결과를 호출한 쪽으로 돌려주는 값이다.[^163]
반환형이 void가 아닌 경우, 메소드 안에서 return 값;이 반드시 있어야 한다고 말한다.[^164]
예시로 로또 최대값 45를 반환하는 getMaxLottoNumber()(반환형 int)를 만들고 int num = getMaxLottoNumber();처럼 받아서 출력하면 45가 출력된다고 설명한다.[^165][^166]
3.12.4 전달값+반환값 함께: add가 결과 반환[^167]
add(int a, int b)가 return a + b;로 정수 합을 반환하고, 호출부에서 int result = add(1,2);로 받아 출력하는 예시를 든다.[^168]
3.12.5 메소드 오버로딩: 이름 동일, 매개변수 개수/타입 다르게[^169]
오버로딩은 같은 메소드 이름을 가지되 매개변수 개수 또는 자료형을 다르게 해서 여러 버전을 만드는 것이라고 정의한다.[^169]
예시로 add(int,int), add(int,int,int), add(double,double)을 만들고, 호출 시 인자 형태에 맞는 메소드가 선택되어 실행된다고 설명한다.[^170][^171]
3.12.6 변수 범위(scope): 중괄호 블록 단위 유효[^172]
변수는 선언된 중괄호 블록 내부에서만 유효하다.[^172]
- 메인에서 선언한
a는 다른 메소드(예: scope 메소드)에서 사용 불가.[^173] - scope 메소드에서 선언한
b는 메인에서 사용 불가.[^174] - if 블록 안에서 선언한
d는 if 내부에서만 사용 가능하고 밖에서는 사용 불가.[^175]
3.13 클래스(OOP): 객체/인스턴스, static, this, 생성자, getter/setter, 접근제어자, 패키지, 상속/다형성/super, 참조, final, enum[^176]
3.13.1 클래스와 객체(설계도 vs 결과물) 비유[^177]
클래스는 데이터와 기능을 포함하는 코드 묶음이며, 설계도/설명서 역할을 한다.[^177]
클래스로부터 만들어진 실체가 객체이고, 객체는 여러 개 만들 수 있다.[^178]
비유로 “종이접기 책(학 접는 방법 설명)이 클래스, 책을 보고 접은 종이학이 객체”라고 설명한다.[^179]
3.13.2 클래스 정의와 객체 생성(new)[^180]
class Person {}처럼 정의하고, Person person = new Person();처럼 new로 객체를 생성한다고 설명한다.[^180][^181]
3.13.3 인스턴스 변수: 객체마다 다른 값[^182]
인스턴스 변수는 클래스 내부(중괄호 안)에 선언된 변수이며, String name; int age;처럼 정의한다.[^182]
객체를 만든 뒤 person.name = ...; person.age = ...;처럼 점(.)으로 접근해 값을 설정한다.[^183] 인스턴스 변수는 객체마다 서로 다른 값을 가질 수 있다고 한다.[^184]
3.13.4 클래스 변수(static): 모든 객체가 공유[^185]
클래스 변수는 static으로 선언된 변수로, 모든 객체가 공유한다.[^185]
예시로 static int personCount;를 만들고, 객체 생성 없이 Person.personCount = 10;처럼 클래스명으로 직접 접근한다고 설명한다.[^186][^187]
3.13.5 인스턴스 메소드 vs 클래스 메소드(static 메소드)[^188]
- 인스턴스 메소드: 객체를 만든 뒤
person.introduce();처럼 호출한다.[^189] 예시 결과로 “이름: 철수, 나이: 20” 형태를 출력하는 introduce 동작을 보여준다.[^190] - 클래스 메소드(static): 메소드 앞에
static을 붙이며,Person.printPersonCount();처럼 클래스명으로 호출한다.[^191][^192]
3.13.6 this: 자기 자신(인스턴스) 구분[^193]
this는 자기 자신을 의미하며, 인스턴스 변수와 지역 변수(파라미터) 이름이 같을 때 구분에 사용한다.[^193]
예시로 setName(String name)에서 this.name = name;로 “인스턴스 변수 name”에 “전달값 name”을 대입한다.[^194][^195]
3.13.7 생성자: 객체 생성 시 호출, 초기화 수행[^196]
생성자는 객체가 생성될 때 호출되는 메소드이며, 클래스명과 같은 이름을 가진다.[^196]
예시로 Person(String name, int age) 생성자에서 this.name = name; this.age = age;로 초기화하고, 객체 생성 시 new Person("철수", 20)처럼 인자를 넣어 생성한다고 설명한다.[^197][^198]
3.13.8 getter/setter: 값 반환/설정 메소드 패턴[^199]
- getter: 인스턴스 변수 값을 반환하는 메소드로
getAge()처럼return age;를 한다.[^199][^200] - setter: 인스턴스 변수 값을 설정하는 메소드로 보통 반환형이
void이며setAge(int age)에서this.age = age;로 설정한다.[^201][^202]
사용 예로person.setAge(20);후person.getAge()로 가져와 출력한다.[^203]
3.13.9 접근 제어자: public/private/default/protected 범위[^204]
접근 제어자는 클래스/변수/메소드의 접근 권한을 지정한다.[^204]
예시로 setter 앞의 public을 보여주고, private int age;처럼 하면 클래스 외부에서 직접 접근이 불가하다고 설명한다.[^205]
표로 정리한 범위는 다음과 같다.[^206]
private: 해당 클래스 내부만.[^206]public: 어디서나 접근 가능.[^206]default(아무것도 안 쓰면): 같은 패키지 내에서만.[^206]protected: 같은 패키지 또는 다른 패키지라도 상속한 자식 클래스에서 접근.[^206]
3.13.10 패키지와 import: 폴더처럼 그룹화[^207]
패키지는 관련 클래스/인터페이스를 묶는 것으로 “폴더 관리”에 비유한다.[^207]
package sample;처럼 파일 상단에 정의하며, 폴더 구조와 패키지명이 일치한다고 설명한다.[^208]
다른 패키지 클래스를 쓰려면 import 패키지명.클래스명;이 필요하고, 예로 java.util.Random을 import해 사용하는 흐름을 보여준다.[^209] import java.util.*;처럼 와일드카드로 여러 클래스를 한 번에 가져올 수도 있다고 한다.[^210]
3.13.11 상속(extends)과 확장[^211]
상속은 특정 클래스 기능을 재사용/확장하는 것이며 부모/자식 클래스로 표현한다.[^211]
class Student extends Person처럼 extends로 부모를 지정하고, 자식이 부모 기능(예: 기능1/2)을 물려받은 뒤 자신만의 기능(기능3)을 추가하는 구조를 설명한다.[^212][^213]
3.13.12 오버라이딩: 부모 메소드 재정의[^214]
오버라이딩은 부모 클래스 메소드를 “덮어써서” 자식 클래스에서 재정의하는 것이라고 설명한다.[^214]
예시로 Person.introduce()는 “사람입니다”를 출력하지만, Student에서 같은 이름 introduce()를 정의하면 “학생입니다”가 출력되며, 각 객체에서 호출 시 다른 결과가 나온다.[^215][^216]
3.13.13 다형성: 부모 타입 참조로 자식 객체를 가리킴[^217]
다형성은 여러 형태로 동작할 수 있는 성질이며, Person p = new Student();처럼 “참조 변수 타입은 부모지만 실제 객체는 자식”이 가능하다고 설명한다.[^217][^218] 이후 introduce() 호출 결과가 객체 실제 타입에 따라 “사람입니다/학생입니다”로 다르게 나온다고 한다.[^219]
3.13.14 super: 부모 클래스 접근(변수/메소드/생성자)[^220]
super는 부모 클래스에 접근하기 위해 사용한다.[^220]
super(...)로 부모 생성자를 호출해 중복 초기화 코드를 줄이는 예시를 든다. Student 생성자에서 나이 초기화는 부모 Person 생성자에 맡기고, 학교 정보만 자식에서 설정하는 구조로 설명한다.[^221][^222]
3.13.15 참조(reference): 기본형 복사 vs 참조 복사[^223]
기본형은 값이 복사되어 a=b 시 값 자체가 들어가며, 예로 a=10, b=20에서 a=b면 a가 20으로 바뀐다고 설명한다.[^224]
참조형(예: String)은 값이 아니라 **참조(주소)**가 복사된다.[^225] s1="사과", s2="바나나"에서 s1=s2를 하면 s1이 “바나나 문자열이 있는 위치”를 s2와 함께 참조하게 된다고 설명한다.[^226]
3.13.16 final: 변수/메소드에 적용[^227]
final은 변경 불가 키워드다.[^227]
- 변수에
final: 값 변경 불가이며, 처음에 초기값을 설정해야 한다고 설명한다.[^228] - 메소드에
final: 자식 클래스에서 오버라이딩 불가(예: introduce를 학생용으로 바꾸고 싶어도 못 바꿈)라고 설명한다.[^229][^230]
3.13.17 enum(열거형): 상수 묶음, switch와 궁합[^231]
열거형은 상수들을 묶은 특수한 형태의 클래스라고 설명한다.[^231]
예시로 Gender { MALE, FEMALE } 같은 성별 열거형을 만들고, Person 클래스에 Gender gender;를 두며 setGender(Gender gender)로 설정한다.[^232][^233] 사용 시 Gender.MALE처럼 지정한다.[^234]
또한 enum은 switch-case에서 유용하며 switch(person.gender)로 남/여에 따라 “남자/여자”를 출력하는 예시를 제시한다.[^235]
3.14 추상 클래스와 인터페이스: 미완성 설계와 구현 강제[^236]
3.14.1 추상 클래스(abstract class): 미완성 클래스 + 자식에서 완성[^237]
추상 클래스는 아직 완성되지 않은 클래스이며 abstract 키워드를 붙인다고 설명한다.[^237]
예로 도형 Shape 추상 클래스를 만들고 “면적 계산” 메소드 calculateArea()를 추상으로 선언한다.[^238]
Square extends Shape, Circle extends Shape가 각각 가로/세로 또는 반지름 값을 받아 면적 계산 로직(정사각형: 가로×세로, 원: πr²)을 구현해 추상 메소드를 완성한다.[^239][^240]
3.14.2 인터페이스(interface): 클래스의 뼈대, implements로 구현[^241]
인터페이스는 클래스를 작성할 때 기본이 되는 뼈대라고 설명한다.[^241]
추상 클래스 예제를 인터페이스로 바꾸어 interface Shape { double calculateArea(); } 같은 형태로 제시하고, 구현 클래스는 implements Shape로 선언한 뒤 반드시 메소드를 구현해야 한다고 한다.[^242][^243]
Square/Circle 예시는 동일하게 면적 계산을 각각 구현한다.[^244]
3.15 제네릭스, 래퍼 클래스, 컬렉션(리스트/셋/맵), 이터레이터[^245]
3.15.1 제네릭스: 타입 일반화로 재사용성과 타입 안정성[^246]
제네릭스는 다양한 형태 데이터를 “일반화”하여 다룰 수 있게 하며, 코드 재사용성과 타입 안정성을 높인다고 설명한다.[^246]
정수/실수/문자열을 출력하는 메소드를 각각 오버로딩하면 동작은 같은데 타입만 다른 중복이 생기며, 이를 T로 일반화한 printValueLine(T value) 같은 형태로 하나로 처리할 수 있다고 설명한다.[^247][^248]
3.15.2 제네릭 클래스: Box로 통합[^249]
정수용 BoxInteger, 문자열용 BoxString처럼 비슷한 클래스를 여러 개 만들면 중복이 생기므로, class Box<T>로 만들고 T data; void setData(T data) 같은 형태로 통합할 수 있다고 한다.[^250][^251]
사용 시 Box<Integer> iBox = new Box<>();, Box<String> sBox = new Box<>();처럼 클래스 뒤에 타입을 지정한다.[^252]
3.15.3 래퍼 클래스(Wrapper): 기본형을 객체로 감싸 기능 제공[^253]
래퍼 클래스는 기본 자료형을 객체로 래핑해 추가 기능을 제공한다.[^253]
예시로 Integer, Double, Character를 들어 intValue() 같은 메소드로 값을 꺼내거나 변환하는 기능을 보여준다.[^254][^255]
3.15.4 ArrayList: 배열 기반 리스트(접근 빠름) + 주요 메소드[^256]
ArrayList는 배열 기반 리스트로 빠른 접근과 순차 저장이 가능하다고 설명한다.[^256]
ArrayList<String> list = new ArrayList<>();로 만들고 add("철수"), add("영희")로 추가, for-each로 순회 출력하는 예시를 든다.[^257][^258]
주요 기능:
add(추가)[^259]get(index)(가져오기)[^260]size()(크기)[^261]set(index, value)(수정)[^262]contains(value)(포함 여부)[^263]remove(value)(삭제)[^264]clear()(전체 삭제)[^265]
3.15.5 LinkedList: 노드 연결, 삽입/삭제 빠름 + 기능[^266]
LinkedList는 노드로 연결된 리스트라 삽입/삭제가 빠르다고 설명한다.[^266]
LinkedList<String> list = new LinkedList<>();로 만들고 add 후 순회 출력한다.[^267]
주요 기능:
add,get(index)[^268]getFirst(),getLast()[^269]addFirst(value),addLast(value)[^270]clear()[^271]
3.15.6 HashSet: 순서/중복 없음[^272]
HashSet은 순서 보장 X, 중복 허용 X 집합이라고 설명한다.[^272]
add("철수"), add("영희"), add("철수")처럼 중복 추가 시 변화가 없음을 예시로 보여준다.[^273]
기능:
add[^274]contains[^275]size[^276]remove[^277]clear[^278]
3.15.7 HashMap: key-value 쌍, 키 중복 불가, 순서 보장 X[^279]
HashMap은 키와 밸류를 쌍으로 저장하며, 키 중복은 허용하지 않고 순서도 보장하지 않는다고 설명한다.[^279]
예시로 이름-점수 매핑: HashMap<String, Integer> map을 만들고 put("철수",100), put("영희",90)을 넣는 흐름을 보여준다.[^280][^281]
기능:
put(key,value)[^282]size()[^283]get(key)[^284]containsKey(key)[^285]remove(key)[^286]clear()[^287]
3.15.8 Iterator: 컬렉션을 순차 접근하며 필요 시 삭제[^288]
Iterator는 컬렉션 데이터를 하나씩 차례대로 접근하기 위해 사용된다.[^288]
리스트에서 iterator()로 이터레이터를 얻고, while(it.hasNext()) { it.next(); } 형태로 순회한다고 설명한다.[^289]
기능:
hasNext()다음 요소 존재 여부 확인[^290]next()다음 요소 가져오기[^291]remove()순회 중 현재 요소 삭제[^292]
3.16 익명 클래스, 람다, 함수형 인터페이스, 스트림[^293]
3.16.1 익명 클래스: 한 번만 쓰는 이름 없는 클래스[^294]
익명 클래스는 한 번만 사용되는 이름 없는 클래스라고 설명한다.[^294]
Person 객체를 new Person(){ ... } 형태로 생성하면서 introduce() 메소드를 @Override로 재정의해, 원래 “사람입니다” 대신 “익명입니다” 같은 다른 문장이 출력되게 할 수 있음을 예시로 보여준다.[^295][^296]
3.16.2 람다식: 메소드 동작을 간단 표현[^297]
람다식은 간결한 코드 묶음으로, 메소드 동작을 짧게 표현한다.[^297]
두 수 합을 반환하는 메소드를 람다로 바꾸는 과정에서 접근제어자/반환형/이름 제거, 타입 생략, 중괄호/return 생략 등을 통해 (x, y) -> x + y 형태로 단순화된다는 흐름을 설명한다.[^298][^299]
3.16.3 함수형 인터페이스: 추상 메소드 1개 제약[^300]
함수형 인터페이스는 람다식을 위한 인터페이스이며, 추상 메소드를 딱 하나만 가져야 한다고 설명한다.[^300] @FunctionalInterface 어노테이션으로 표시할 수 있다고 한다.[^301]
예시로 Calculator 인터페이스에 calculate(x,y) 하나를 두고, 메인에서 Calculator c = (x,y) -> x+y;처럼 람다를 대입해 사용한다.[^302]
3.16.4 스트림: 컬렉션/배열 데이터 처리(필터→맵→출력)[^303]
스트림은 배열/컬렉션 데이터를 효과적으로 처리하는 데 사용한다.[^303]
예시로 리스트 [1,2,3,4,5]에서:
stream()으로 스트림 생성[^304]filter(n -> n % 2 == 0)로 짝수(2,4)만 남김[^305]map(n -> n * 2)로 2배 변환(4,8)[^306]forEach(System.out::println)로 출력[^307]
결과가 4와 8로 찍힌다고 설명한다.[^308]
3.17 예외 처리: try-catch, 다중 catch, throw, finally, try-with-resources, 사용자 정의 예외, throws로 미루기[^309]
3.17.1 try-catch: 문제 상황 처리 기본[^310]
예외 처리는 프로그램에서 발생 가능한 문제 상황을 처리하는 것이며, try 블록의 코드 수행 중 문제가 생기면 catch로 넘어가 처리한다.[^310]
예시로 길이 3 배열에서 인덱스 5 접근 시 문제가 발생해 catch에서 “문제 발생”을 출력한다.[^311][^312]
3.17.2 catch를 예외 종류별로 여러 개 사용[^313]
catch는 예외 종류에 따라 다르게 처리할 때 사용하며, 여러 개 둘 수 있다고 설명한다.[^313]
존재하지 않는 인덱스 접근은 ArrayIndexOutOfBoundsException 같은 예외로 잡는다는 식으로 예외 타입을 catch 괄호에 명시한다.[^314]
3.17.3 throw: 의도적으로 예외 발생시키기[^315]
throw new 예외타입("메시지")로 의도적으로 예외를 만들 수 있다고 설명한다.[^315]
예시로 나이 age=-5처럼 음수가 들어오면 if(age < 0)에서 “나이는 음수일 수 없습니다” 메시지와 함께 예외를 던지고, catch에서 e.getMessage()로 메시지를 출력한다.[^316][^317]
3.17.4 finally: 예외 여부와 무관하게 항상 실행[^318]
finally는 예외가 발생하든 안 하든 항상 실행되는 블록이며 리소스 해제/정리 작업에 쓴다고 설명한다.[^318]
예시로 3/0은 예외가 발생해 catch 실행 후 finally(“실행 종료”)가 실행되고, 4/2처럼 예외가 없으면 catch는 건너뛰지만 finally는 실행된다는 비교를 보여준다.[^319][^320]
3.17.5 try-with-resources: 자동 자원 해제[^321]
try(자원할당) 형태로 괄호 안에서 할당한 자원이 자동으로 해제되는 편한 방식이라고 설명한다.[^321]
예시로 FileWriter로 파일을 열고 write("안녕")을 수행한 뒤, finally로 close를 직접 하지 않아도 자동 해제된다고 설명한다.[^322][^323]
3.17.6 사용자 정의 예외: Exception 상속해서 만들기[^324]
개발자가 직접 정의한 예외 클래스로 특정 상황에서 발생시키기 위해 사용한다.[^324]
class MyException extends Exception 형태로 만들고, 음수 나이 같은 조건에서 throw new MyException(...)을 던져 catch에서 처리하는 흐름을 예시로 든다.[^325][^326]
3.17.7 throws: 예외 처리 미루기(호출한 쪽에서 처리)[^327]
메소드 선언 뒤에 throws Exception을 붙여, 메소드 내부에서 발생한 예외를 호출한 쪽으로 던져 처리하게 할 수 있다고 설명한다.[^327]
예시로 divide(a,b)가 b=0일 때 예외가 나면, 메인에서 try-catch로 받아 처리하는 구조를 제시한다.[^328][^329]
3.18 스레드: Thread 상속, Runnable 구현, join, 멀티스레드, synchronized 동기화[^330]
3.18.1 Thread 상속: run에 작업 정의, start로 실행[^331]
스레드는 여러 작업을 동시에 수행할 때 사용하며, Thread 클래스를 상속한 뒤 run() 메소드에 동작을 정의하고 start()로 실행하면 새 스레드에서 run이 수행된다고 설명한다.[^331][^332]
예시로 1~5까지 “Thread 1…5”를 출력하는 반복 작업 스레드를 만든다.[^333]
3.18.2 Runnable: 인터페이스 구현 방식(다중 상속 제한 회피)[^334]
Runnable도 동시 작업을 위한 방법이며, Thread 상속 대신 implements Runnable로 구현하고 run()을 정의한다.[^334]
Thread 상속은 자바의 다중 상속 불가 때문에 다른 클래스를 상속할 수 없지만, Runnable 구현은 다른 클래스 상속이 가능하다는 장점을 설명한다.[^335]
실행은 Runnable r = new MyRunnable(); Thread t = new Thread(r); t.start();처럼 Thread에 Runnable을 전달해 start 한다.[^336]
3.18.3 join: 스레드 종료까지 대기[^337]
join은 스레드 실행이 끝날 때까지 대기해, 작업 순서를 제어할 수 있다고 설명한다.[^337]
예시로 스레드 작업과 메소드 작업이 섞여 출력되는 상황에서 thread.join()을 넣으면 스레드가 1~5를 끝낸 뒤 메소드가 1~5를 실행하도록 순서를 만들 수 있다.[^338][^339] join은 예외 가능성이 있어 예외 처리가 필요하다고 언급한다.[^340]
3.18.4 다중 스레드: 동시에 실행되어 출력 순서가 섞임[^341]
두 개 스레드를 각각 start 하면 서로 다른 스레드가 동시에 수행되어 출력이 섞일 수 있고, 실행할 때마다 결과가 달라질 수 있다고 설명한다.[^341][^342]
3.18.5 동기화(synchronized): 공유 자원 경쟁 방지[^343]
동기화는 여러 스레드가 공유 자원에 동시에 접근하지 못하게 막는 것으로 설명한다.[^343]
메소드에 synchronized를 붙이면 한 번에 하나의 스레드만 그 메소드를 실행할 수 있다고 한다.[^344] 블록 단위로 synchronized(변수) { ... } 형태도 소개한다.[^345]
예시로 SharedData 클래스에 int data가 있고 increment()가 1 증가시키는 메소드인데, 여기에 synchronized를 붙인다.[^346]
두 스레드가 각각 1000번 increment를 호출하면 총 2000이 되어야 하며, start 후 join으로 대기한 뒤 출력하면 2000이 올바로 나온다고 설명한다.[^347][^348]
반대로 synchronized를 제거하면 1733 같은 “원하지 않은 값”이 나오기도 하며(때로는 2000이 나올 수도 있음), 이는 동시 접근으로 인한 문제임을 보여준다.[^349]
3.19 입출력과 파일: Scanner 입력, printf 출력 포맷, File/Writer/Reader로 파일/폴더/읽기쓰기[^350]
3.19.1 입력(Scanner): next/nextInt/nextDouble/nextLine[^351]
입력은 프로그램으로 데이터를 가져오는 것이며 보통 Scanner scn = new Scanner(System.in);을 사용한다.[^351]
예시로 “정수 입력”을 출력하고 nextInt()로 입력을 받아 변수에 저장한 뒤 출력한다.[^352][^353]
Scanner 주요 메소드:
next()단어 단위 문자열 입력[^354]nextInt()정수 입력[^355]nextDouble()실수 입력[^356]nextLine()한 줄(문장) 입력[^357]
3.19.2 출력(printf): 서식 지정자와 정렬/채움 옵션[^358]
출력은 결과 표시/저장이며, System.out.print/println 외에 포맷 출력 printf를 소개한다.[^358]
예시로 이름: %s, 나이: %d 형태에서 %s는 문자열, %d는 정수로 매핑되어 출력된다고 설명한다.[^359][^360]
주요 포맷:
%d정수[^361]%f실수[^362]%s문자열[^363]%n줄바꿈[^364]%-4d왼쪽 정렬(기본은 오른쪽 정렬), 4칸 확보[^365]%+4d부호 표시 포함[^366]%04d빈칸 0으로 채움[^367]%,d천 단위 콤마[^368]%.2f소수점 자리수 지정(둘째 자리까지)[^369]
3.19.3 파일/폴더 생성 및 정보 조회: File 클래스 기능[^370]
자바에서 파일/폴더 생성, 삭제, 정보 조회 등을 할 수 있다고 설명한다.[^370]
예시로 test.txt 파일명으로 File file = new File(fileName); file.createNewFile();을 try-catch로 감싸 파일을 만든다(파일 생성은 예외 가능).[^[371]]
폴더는 File folder = new File(folderName); folder.mkdir();로 생성 가능하다고 설명한다.[^372]
File 기능 소개:
createNewFile()파일 생성[^373]exists()존재 여부 확인[^374]getName()이름 조회[^375]getAbsolutePath()절대 경로 조회[^376]length()파일 크기[^377]mkdir()폴더 생성[^378]mkdirs()하위 폴더 포함 생성[^379]listFiles()목록 조회 + 반복문 활용[^380]isFile(),isDirectory()파일/폴더 구분[^381]delete()삭제[^382]
3.19.4 파일 쓰기/읽기: BufferedWriter/BufferedReader + try-with-resources[^383]
파일 쓰기는 BufferedWriter를 많이 쓰며, new BufferedWriter(new FileWriter("test.txt"))로 만들고 write(...), newLine()로 줄바꿈 후 다음 문장을 쓰는 예시를 든다.[^384][^385]
읽기는 BufferedReader를 많이 쓰며, new BufferedReader(new FileReader("test.txt"))로 만들고 readLine()으로 한 줄씩 읽어 line != null인 동안 while로 출력하는 흐름을 보여준다.[^386][^387] 실행 결과로 파일에 쓴 “감사합니다”, “안녕히 계세요”가 그대로 출력됨을 확인한다.[^388]
4. 핵심 통찰[^389]
-
자바 입문에서 가장 중요한 분기점은 “문법을 많이 아는 것”이 아니라 기본형/참조형 모델을 머릿속에 세우는 것이며, 이것이 문자열 비교, 객체 참조 복사, 클래스 설계까지 일관되게 영향을 준다.[^3][^86][^223]
- 실행 행동: 문자열은
==대신equals를 기본 습관으로 둔다.[^91]
- 실행 행동: 문자열은
-
손실이 없으면 자동 형변환, 손실 가능성이 있으면 명시 캐스팅이라는 규칙 하나가 타입 변환 실수를 크게 줄인다.[^48][^50]
-
제어문은 “문법 암기”가 아니라 상황 모델링 도구로 제시된다: if는 조건 분기, switch는 값 기반 경우 분기, 반복문은 중복 제거, break/continue는 흐름 제어다.[^100][^110][^115][^126][^128]
-
컬렉션 파트는 “자료구조 선택 감각”을 심어준다:
- ArrayList(접근 빠름), LinkedList(삽입/삭제), HashSet(중복/순서 X), HashMap(키-값, 키 중복 X).[^[256]][^266][^272][^279]
-
예외 처리는 “문제 숨기기”가 아니라 문제 상황을 정상 흐름으로 되돌리는 구조화 방법으로 소개된다: try-catch, finally(정리), try-with-resources(자동 해제), throw(의도적 발생), throws(처리 책임 이동).[^[310]][^318][^321][^315][^327]
-
스레드는 “동시에 실행된다”에서 끝나지 않고, 동시성의 핵심 위험(공유 자원 경쟁)과 해결(synchronized)을 숫자 예시(2000 vs 깨진 값)로 체감하게 한다.[^341][^343][^347][^349]
5. 헷갈리는 용어 정리[^390]
기본 자료형(Primitive Type): 실제 값 자체를 저장하는 타입(int, double, boolean 등).[^14]
참조 자료형(Reference Type): 값이 저장된 메모리 주소(참조)를 저장하는 타입(String, 클래스, 배열 등).[^14][^15]
묵시적 형 변환(Implicit Casting): 손실이 없다고 컴파일러가 판단할 때 자동으로 일어나는 형 변환.[^48]
명시적 형 변환(Explicit Casting): 손실 가능성이 있어 (타입)을 반드시 적어야 하는 변환.[^50]
오버로딩(Overloading): 같은 메소드 이름, 다른 매개변수(개수/타입)로 여러 메소드 정의.[^169]
오버라이딩(Overriding): 부모 클래스 메소드를 자식 클래스에서 재정의.[^214]
다형성(Polymorphism): 부모 타입 참조로 자식 객체를 참조하며, 호출 결과가 실제 객체 타입에 따라 달라질 수 있음.[^217][^219]
동기화(Synchronization): 여러 스레드가 공유 자원에 동시에 접근하지 못하게 막는 것(synchronized).[^343][^344]
함수형 인터페이스(Functional Interface): 추상 메소드 1개만 가진 인터페이스(람다식 대상).[^300]
스트림(Stream): 컬렉션/배열 데이터를 filter/map/forEach 등으로 처리하는 흐름 API.[^303][^304]
참고(콘텐츠 정보)[^391]
- 제목: 자바 무료 강의 2시간 완성 (1분 자바)[^1]
- 채널: 나도코딩[^1]
- 길이: 139분 52초[^1]
- 링크: https://www.youtube.com/watch?v=DNCBaeCoMug[^1]
[^1]: 콘텐츠 메타데이터(사용자 제공): "자바 무료 강의 2시간 완성 (1분 자바) / 채널: 나도코딩 / 길이: 139분 52초 / https://www.youtube.com/watch?v=DNCBaeCoMug"
[^2]: @[00:07] “자료형부터… 연산자 제어문 배열 클래스는 물론 예외 처리 쓰레드 파일까지… 모두 포함”
[^3]: @[01:41] “기본 자료형… 실제 데이터 값을 바로 저장… 참조 자료형… 메모리 주소 값을 저장”
[^4]: @[10:03] 데이터 손실 시 명시 캐스팅 필요 + @[26:51] 문자열 equals + @[41:13] 무한루프 언급 + @[02:06:19] 동기화
[^5]: @[00:14] 복습용 + @[00:20] 빠르게 훑어보기 용도
[^6]: @[00:29] 환경 설정은 별도 안내하지 않음(인프런 미리보기로 진행)
[^7]: @[43:32] 결석 예시로 break + @[44:35] 아들 예시로 continue + @[02:08:26] synchronized 제거 시 결과 이상
[^8]: @[00:42] “지금부터 강의를 시작… 자료형과 변수”로 본격 전개
[^9]: @[00:07]~@[00:42] 강의 목적/범위/환경설정 전제
[^10]: @[00:47] “자료형과 변수” 시작
[^11]: @[00:47] 자료형 정의(데이터 타입)
[^12]: @[01:00]~@[01:15] 문자열 예시(큰따옴표)
[^13]: @[01:15]~@[01:30] 숫자/불리언 소개
[^14]: @[01:30]~@[01:48] 기본/참조 구분 설명
[^15]: @[01:48] 참조 자료형 예시(클래스/인터페이스/배열/열거형)
[^16]: @[01:55] “String도 참조 자료형”
[^17]: @[02:01]~@[02:14] int 크기/범위
[^18]: @[02:23]~@[02:29] long 8바이트 큰 수
[^19]: @[02:29]~@[02:42] float 정밀도(6~7자리)
[^20]: @[02:42]~@[02:48] double 정밀도(15자리)
[^21]: @[02:48]~@[02:56] boolean 1바이트 true/false
[^22]: @[02:59]~@[03:01] char 2바이트
[^23]: @[03:04] 변수 정의(값 저장 공간)
[^24]: @[03:14] 선언+초기화 형태 설명
[^25]: @[03:25]~@[04:00] String/int/double/char/boolean 예시
[^26]: @[04:20] “다르게 변수를 만들 수도”
[^27]: @[04:31]~@[04:42] 선언 후 대입 분리 예시
[^28]: @[04:48] 주석 소개
[^29]: @[04:59] 주석은 실행되지 않음
[^30]: @[05:10]~@[05:45] // 한 줄 주석 예시
[^31]: @[05:57]~@[06:13] /* ... */ 여러 줄 주석
[^32]: @[06:33] 변수 이름 짓기 섹션 시작
[^33]: @[06:35] 의미 있는 이름 권장
[^34]: @[06:41] 밑줄/문자/숫자만
[^35]: @[06:45] 공백 불가
[^36]: @[06:51]~@[06:55] 숫자로 시작 불가
[^37]: @[06:59] 단어 조합 권장
[^38]: @[07:05]~@[07:26] 카멜케이스 관례
[^39]: @[07:26] 예약어 사용 불가
[^40]: @[07:38] 대소문자 구분
[^41]: @[07:44] 상수 정의(변하지 않는 값)
[^42]: @[07:49] final로 상수 생성
[^43]: @[08:01]~@[08:15] final 변수 변경 불가 예시
[^44]: @[08:23]~@[08:31] 한 번 정의 후 안 바뀌는 데이터에 사용
[^45]: @[08:31] 형 변환 정의
[^46]: @[08:49]~@[09:00] int→float 캐스팅 예시
[^47]: @[09:00] 값 리터럴을 double로 캐스팅
[^48]: @[09:23] 묵시적 형 변환 가능 조건
[^49]: @[09:30] 손실 없으면 자동 변환 예시
[^50]: @[09:47]~@[10:21] double→int는 손실, 명시 필요
[^51]: @[10:03] 98.8 → 98 설명
[^52]: @[10:30] 연산자 섹션 시작
[^53]: @[10:37] 연산자 정의
[^54]: @[10:51] 산술 연산자 소개
[^55]: @[11:15]~@[11:36] *, /, % 설명
[^56]: @[11:52] 증가 연산자 전위/후위
[^57]: @[12:33] 감소 연산자 전위/후위
[^58]: @[12:44] 대입 연산자 정의
[^59]: @[12:51]~@[13:32] num=num+2, num=num-2 흐름
[^60]: @[13:32] 복합 대입 연산자 소개
[^61]: @[13:59]~@[14:43] +=, -= 예시 및 기타 연산
[^62]: @[14:56] 비교 연산자 소개
[^63]: @[15:04]~@[16:06] >,>=,<,<= 예시
[^64]: @[16:12]~@[16:30] = vs == 차이
[^65]: @[16:40]~@[17:08] != 설명
[^66]: @[17:13] && 설명
[^67]: @[17:31]~@[18:03] || 설명
[^68]: @[18:03]~@[18:23] ! 설명
[^69]: @[18:28] 삼항 연산자 형태
[^70]: @[18:51]~@[19:03] 조건 참/거짓에 따른 선택
[^71]: @[19:09]~@[19:57] x=3,y=5 max 구하기 예시
[^72]: @[19:57] 문자열 섹션 시작
[^73]: @[20:03] 문자열 정의
[^74]: @[20:17]~@[20:25] 큰따옴표로 감쌈
[^75]: @[20:31] “자주 사용되는 기능” 소개
[^76]: @[20:35]~@[20:49] length 예시(11)
[^77]: @[20:53]~@[21:10] toUpperCase/toLowerCase
[^78]: @[21:14]~@[21:31] contains
[^79]: @[21:31]~@[21:51] indexOf, 인덱스 0부터
[^80]: @[22:00]~@[22:28] lastIndexOf 예시(10)
[^81]: @[22:33]~@[23:12] startsWith/endsWith
[^82]: @[23:12]~@[23:32] replace(like→love)
[^83]: @[23:34]~@[23:53] substring(7)
[^84]: @[23:58]~@[24:07] trim
[^85]: @[24:11]~@[24:33] concat
[^86]: @[25:33] “문자열 비교는 이렇게 하면 안 돼요”
[^87]: @[24:38]~@[25:06] int == 비교는 true
[^88]: @[25:16]~@[25:26] 리터럴 문자열 == 결과 설명
[^89]: @[25:39]~@[25:47] new String 비교 시 false
[^90]: @[26:01]~@[26:41] 리터럴은 같은 곳 참조, new는 다른 곳
[^91]: @[26:46]~@[26:56] equals로 값 비교
[^92]: @[26:56]~@[27:02] 헷갈리니 주의
[^93]: @[27:09] 특수 문자(escape sequence) 소개
[^94]: @[27:15]~@[27:36] \n
[^95]: @[27:36]~@[27:46] \t
[^96]: @[27:53]~@[28:12] \
[^97]: @[28:12]~@[28:24] "
[^98]: @[28:28]~@[28:32] '
[^99]: @[28:36] 제어문 섹션 시작
[^100]: @[28:40] if 소개
[^101]: @[29:02]~@[29:12] 중괄호 사용 규칙
[^102]: @[29:12]~@[29:43] num=3 예시
[^103]: @[29:48]~@[30:10] &&, || 조건 결합
[^104]: @[30:18] else 소개
[^105]: @[30:52]~@[31:29] else 예시(0보다 작지 않아요)
[^106]: @[31:34] else if 소개
[^107]: @[32:05] else if 여러 번 가능
[^108]: @[32:14]~@[33:25] 3과의 비교로 else if 흐름
[^109]: @[33:57]~@[34:05] else는 마지막 한 번(또는 없음)
[^110]: @[34:15] switch-case 소개
[^111]: @[34:31]~@[34:53] switch 구조(케이스/디폴트/브레이크)
[^112]: @[35:02]~@[35:59] menu=2 예시(시작/설정/잘못된 메뉴)
[^113]: @[36:06]~@[36:27] break/default 생략 가능, fall-through 설명
[^114]: @[36:30] 반복문 시작
[^115]: @[36:46] for(선언;조건;증감)
[^116]: @[37:22]~@[38:19] 안녕 5번 예시 + 순서 정리
[^117]: @[38:19] while 소개
[^118]: @[39:19]~@[39:31] 선언을 밖에서
[^119]: @[38:38]~@[39:07] while로 5번 출력 예시
[^120]: @[39:37] do-while 소개
[^121]: @[40:15]~@[40:32] while vs do-while 차이
[^122]: @[41:13] 증감 없으면 무한 루프
[^123]: @[41:21] 이중 반복문 소개
[^124]: @[41:34]~@[42:03] 2×3=6 출력
[^125]: @[42:07]~@[43:00] 바깥/안쪽 반복 설명
[^126]: @[43:00] break 소개
[^127]: @[43:24]~@[44:09] 결석 예시로 3번만 인사(break)
[^128]: @[44:27] continue 소개
[^129]: @[44:35]~@[45:26] 아들 예시로 3번째 인사 생략(continue)
[^130]: @[45:31] 배열 섹션 시작
[^131]: @[45:39] 배열 정의
[^132]: @[45:44]~@[46:08] 배열 선언/생성 예시
[^133]: @[46:26]~@[46:49] 인덱스로 값 대입
[^134]: @[47:02]~@[47:23] 인덱스 0~4 그림 설명
[^135]: @[47:23] 다른 배열 생성 방식 소개
[^136]: @[47:39]~@[47:47] 대괄호 위치 변경 가능
[^137]: @[47:55]~@[48:22] new + 중괄호 초기화
[^138]: @[48:36]~@[49:07] new 생략 초기화
[^139]: @[49:07] 배열 순회 소개
[^140]: @[49:39]~@[49:53] for + length로 순회
[^141]: @[50:12]~@[50:32] for-each(향상된 for)
[^142]: @[50:39]~@[50:55] 변수명 number 권장
[^143]: @[51:03] 다차원 배열 소개
[^144]: @[51:28]~@[51:41] 1D/2D/3D 비유
[^145]: @[51:57]~@[52:19] new int[2][5] 생성
[^146]: @[52:30]~@[53:12] 인덱스 2개(세로/가로)
[^147]: @[53:20]~@[53:56] 2D 초기화 중괄호 구조
[^148]: @[54:03]~@[54:12] 중첩 for로 순회
[^149]: @[55:16]~@[55:32] numbers.length / numbers[i].length
[^150]: @[55:40] 아스키 코드 정의
[^151]: @[55:55]~@[56:05] 48=’0’ 시작
[^152]: @[56:05]~@[56:10] 65=’A’ 시작
[^153]: @[56:10]~@[56:15] 97=’a’ 시작
[^154]: @[56:15]~@[56:28] 시작값 외우면 도움
[^155]: @[56:33] 메소드 섹션 시작
[^156]: @[56:38] 메소드 정의(코드 묶음)와 형태
[^157]: @[56:59]~@[57:28] print 메소드 정의 예시
[^158]: @[57:28]~@[57:55] 호출 시 동작 흐름
[^159]: @[58:03] 전달값(파라미터) 정의
[^160]: @[58:34]~@[59:02] print(int a) 호출 예시
[^161]: @[59:15]~@[59:33] 두 개 파라미터 예시
[^162]: @[59:41]~@[59:49] 1+2=3, 3+5=8 예시
[^163]: @[59:49]~@[01:00:16] 반환값/return 소개
[^164]: @[01:00:16]~@[01:00:21] 반환형 있으면 return 필요
[^165]: @[01:00:25]~@[01:01:12] getMaxLottoNumber=45 예시
[^166]: @[01:01:12]~@[01:01:19] 출력 45 확인
[^167]: @[01:01:19] 전달값+반환값 섹션
[^168]: @[01:01:50]~@[01:02:37] add(1,2)=3 반환 예시
[^169]: @[01:02:37] 오버로딩 정의
[^170]: @[01:03:11]~@[01:03:49] add 2개/3개/실수 버전 생성
[^171]: @[01:04:07]~@[01:04:40] 호출 시 알맞은 버전 선택
[^172]: @[01:04:50] 변수 범위 소개
[^173]: @[01:04:57]~@[01:05:32] main의 a를 다른 메소드에서 못 씀
[^174]: @[01:05:36]~@[01:05:50] scope의 b를 main에서 못 씀
[^175]: @[01:06:04]~@[01:06:36] if 블록 내부 d는 밖에서 못 씀
[^176]: @[01:06:42] 클래스 섹션 시작
[^177]: @[01:06:49] 클래스 정의(데이터+기능, 설계도)
[^178]: @[01:06:56] 객체는 클래스의 결과물, 여러 개 생성 가능
[^179]: @[01:07:10]~@[01:07:15] 종이접기 책/종이학 비유
[^180]: @[01:07:15]~@[01:07:29] class 정의
[^181]: @[01:07:39]~@[01:08:05] new로 객체 생성
[^182]: @[01:08:05]~@[01:08:19] 인스턴스 변수 정의
[^183]: @[01:08:19]~@[01:08:35] 점(.)으로 값 설정
[^184]: @[01:08:46] 객체마다 다른 값
[^185]: @[01:08:46]~@[01:09:12] static 클래스 변수(공유)
[^186]: @[01:09:17]~@[01:09:27] 클래스명.변수로 설정
[^187]: @[01:09:39]~@[01:09:44] 객체 없이 접근 가능
[^188]: @[01:09:49] 인스턴스/클래스 메소드 소개
[^189]: @[01:10:10]~@[01:10:32] 객체 만들고 메소드 호출
[^190]: @[01:10:44] 결과(이름/나이 출력)
[^191]: @[01:10:50]~@[01:11:17] static 메소드 정의
[^192]: @[01:11:17]~@[01:11:33] 클래스명으로 호출
[^193]: @[01:11:33]~@[01:12:10] this 소개
[^194]: @[01:12:10]~@[01:12:26] this.name vs name(파라미터)
[^195]: @[01:12:34]~@[01:12:42] setName("철수") 동작
[^196]: @[01:12:51] 생성자 정의
[^197]: @[01:13:17]~@[01:13:28] 생성자에서 this로 초기화
[^198]: @[01:13:35]~@[01:13:50] new Person("철수",20)
[^199]: @[01:13:57] getter 정의
[^200]: @[01:14:22]~@[01:14:32] getAge 예시
[^201]: @[01:14:32]~@[01:15:07] setter 정의 및 setAge 예시
[^202]: @[01:15:07]~@[01:15:13] this.age = age
[^203]: @[01:15:21]~@[01:15:48] set 후 get 출력
[^204]: @[01:15:48] 접근 제어자 소개
[^205]: @[01:16:06]~@[01:16:34] public/private 예시
[^206]: @[01:16:34]~@[01:17:00] 접근 범위 표
[^207]: @[01:17:00] 패키지 소개
[^208]: @[01:17:32]~@[01:17:56] package sample; 폴더 일치
[^209]: @[01:18:06]~@[01:18:29] import java.util.Random 사용
[^210]: @[01:18:37]~@[01:18:46] import java.util.*
[^211]: @[01:18:46] 상속 정의
[^212]: @[01:19:26] extends 문법
[^213]: @[01:19:42]~@[01:20:04] Person→Student 확장 예
[^214]: @[01:20:04] 오버라이딩 정의
[^215]: @[01:20:12]~@[01:20:53] Person/Student introduce 결과
[^216]: @[01:21:00] 덮어쓰기 개념 정리
[^217]: @[01:21:00] 다형성 정의
[^218]: @[01:21:21]~@[01:21:32] Person 타입으로 Student 참조 가능
[^219]: @[01:21:32]~@[01:21:52] 호출 결과가 달라짐
[^220]: @[01:22:12] super 소개
[^221]: @[01:22:32]~@[01:23:25] super()로 부모 생성자 호출
[^222]: @[01:23:25] 나이는 부모, 학교는 자식에서 설정
[^223]: @[01:23:25] 참조 개념 소개
[^224]: @[01:24:05]~@[01:24:26] 기본형 a=b 값 복사
[^225]: @[01:24:26]~@[01:25:13] 참조형은 주소 복사
[^226]: @[01:25:02]~@[01:25:13] s1=s2 후 동일 참조
[^227]: @[01:25:13] final 소개
[^228]: @[01:25:28]~@[01:25:51] final 변수는 초기값 필요/변경 불가
[^229]: @[01:25:57]~@[01:26:13] final 메소드 오버라이딩 불가
[^230]: @[01:26:20]~@[01:26:31] Student에서 introduce 못 바꿈 예
[^231]: @[01:26:38] enum 소개
[^232]: @[01:26:54]~@[01:27:03] Gender enum(MALE/FEMALE)
[^233]: @[01:27:08]~@[01:27:24] Person에 Gender 변수
[^234]: @[01:27:41]~@[01:27:52] setGender(Gender.MALE)
[^235]: @[01:27:56]~@[01:28:12] enum + switch-case 예시
[^236]: @[01:28:17] 추상/인터페이스 섹션 시작
[^237]: @[01:28:24] abstract class 정의
[^238]: @[01:28:30]~@[01:28:46] Shape 추상 클래스/추상 메소드
[^239]: @[01:29:00]~@[01:29:26] Square가 calculateArea 구현
[^240]: @[01:29:31]~@[01:30:00] Circle πr² 구현
[^241]: @[01:30:00]~@[01:30:19] 인터페이스 정의(뼈대)
[^242]: @[01:30:23]~@[01:30:50] Shape 인터페이스 + 메소드 선언
[^243]: @[01:31:03] implements로 구현, 반드시 메소드 정의
[^244]: @[01:31:14]~@[01:31:59] Square/Circle 구현 예
[^245]: @[01:32:10] 제네릭/컬렉션 섹션 시작
[^246]: @[01:32:10]~@[01:32:24] 제네릭 정의(재사용/타입 안정성)
[^247]: @[01:32:28]~@[01:32:56] 타입별 출력 메소드 오버로딩 중복
[^248]: @[01:33:03]~@[01:33:20] T로 일반화한 메소드
[^249]: @[01:33:25] 제네릭 클래스 섹션
[^250]: @[01:33:39]~@[01:34:09] BoxInteger/BoxString 중복 예
[^251]: @[01:34:44]~@[01:35:08] Box
[^252]: @[01:35:12]~@[01:35:40] Box
[^253]: @[01:35:50] 래퍼 클래스 정의
[^254]: @[01:36:20]~@[01:36:38] Integer/Double/Character 사용
[^255]: @[01:36:43]~@[01:36:59] intValue/charValue 등 기능
[^256]: @[01:37:14] ArrayList 설명(배열 기반)
[^257]: @[01:37:32]~@[01:38:05] add 후 for-each 순회
[^258]: @[01:38:11] ArrayList 기능 소개 시작
[^259]: @[01:38:17] add
[^260]: @[01:38:29]~@[01:38:41] get
[^261]: @[01:38:44]~@[01:38:54] size
[^262]: @[01:38:54]~@[01:39:01] set
[^263]: @[01:39:07]~@[01:39:19] contains
[^264]: @[01:39:19]~@[01:39:31] remove
[^265]: @[01:39:39] clear
[^266]: @[01:39:46] LinkedList 설명
[^267]: @[01:40:09]~@[01:40:17] add/순회
[^268]: @[01:40:25]~@[01:40:51] add/get
[^269]: @[01:40:51]~@[01:41:10] getFirst/getLast
[^270]: @[01:41:16]~@[01:41:50] addFirst/addLast
[^271]: @[01:41:50] clear
[^272]: @[01:41:58] HashSet 정의(순서/중복 X)
[^273]: @[01:42:17]~@[01:42:40] 중복 add 변화 없음
[^274]: @[01:42:47]~@[01:42:55] add
[^275]: @[01:42:55]~@[01:43:02] contains
[^276]: @[01:43:02]~@[01:43:11] size
[^277]: @[01:43:11]~@[01:43:24] remove
[^278]: @[01:43:24]~@[01:43:28] clear
[^279]: @[01:43:28] HashMap 정의(키-값, 키 중복 X, 순서 X)
[^280]: @[01:43:49]~@[01:44:33] 이름-점수 맵 생성/put 예시
[^281]: @[01:44:26]~@[01:44:38] 매핑 구조 설명
[^282]: @[01:44:38]~@[01:44:53] put
[^283]: @[01:44:53]~@[01:44:58] size
[^284]: @[01:44:58]~@[01:45:11] get
[^285]: @[01:45:11]~@[01:45:21] containsKey
[^286]: @[01:45:21]~@[01:45:32] remove
[^287]: @[01:45:32]~@[01:45:40] clear
[^288]: @[01:45:46] Iterator 소개
[^289]: @[01:46:16]~@[01:46:34] iterator/hasNext/next 순회
[^290]: @[01:46:39]~@[01:46:52] hasNext
[^291]: @[01:46:57]~@[01:47:07] next
[^292]: @[01:47:07]~@[01:47:17] remove
[^293]: @[01:47:17] 익명/람다/스트림 섹션 시작
[^294]: @[01:47:23] 익명 클래스 정의
[^295]: @[01:48:00]~@[01:48:27] new Person(){ override introduce }
[^296]: @[01:48:39]~@[01:48:46] 출력이 “사람입니다”→“익명입니다” 식으로 변경
[^297]: @[01:48:46] 람다식 정의
[^298]: @[01:49:12]~@[01:49:50] 람다로 단순화 단계
[^299]: @[01:49:55] (x,y)->x+y 의미 정리
[^300]: @[01:50:00] 함수형 인터페이스 정의(추상 메소드 1개)
[^301]: @[01:50:22] @FunctionalInterface 언급
[^302]: @[01:50:27]~@[01:50:49] Calculator 인터페이스 + 람다 사용 예
[^303]: @[01:51:22] 스트림 소개
[^304]: @[01:51:44] stream 얻기
[^305]: @[01:52:01] filter(짝수)
[^306]: @[01:52:18] map(2배 변환)
[^307]: @[01:52:30] forEach로 출력
[^308]: @[01:52:38] 결과 4, 8 확인
[^309]: @[01:52:44] 예외 처리 섹션 시작
[^310]: @[01:52:50] 예외 처리 정의와 try-catch 구조
[^311]: @[01:53:14]~@[01:53:53] 배열 인덱스 오류 예시
[^312]: @[01:53:53]~@[01:53:59] “문제 발생” 출력
[^313]: @[01:54:06] catch 여러 개 사용 목적
[^314]: @[01:54:58]~@[01:55:05] ArrayIndexOutOfBoundsException 언급
[^315]: @[01:55:11] throw로 예외 발생시키기 소개
[^316]: @[01:55:38]~@[01:56:08] age=-5, age<0이면 throw
[^317]: @[01:56:08] 메시지 출력(e.getMessage)
[^318]: @[01:56:26] finally 정의(항상 실행)
[^319]: @[01:56:40]~@[01:57:04] 3/0 예외 + finally 실행
[^320]: @[01:57:14]~@[01:57:30] 4/2는 catch 없이 finally만
[^321]: @[01:57:42] try-with-resources 정의
[^322]: @[01:58:03]~@[01:58:30] FileWriter로 파일 쓰기 예시
[^323]: @[01:58:30]~@[01:58:36] 자동 자원 해제 설명
[^324]: @[01:58:36] 사용자 정의 예외 정의
[^325]: @[01:58:49] MyException extends Exception
[^326]: @[01:59:00]~@[01:59:34] 음수 age에서 사용자 예외 throw/catch
[^327]: @[01:59:48] throws로 예외 처리 미루기
[^328]: @[02:00:05]~@[02:00:31] divide throws Exception, b=0 호출
[^329]: @[02:00:40]~@[02:00:47] 메인 catch에서 처리
[^330]: @[02:00:56] 스레드 섹션 시작
[^331]: @[02:01:07] Thread 상속 + run 정의
[^332]: @[02:01:49]~@[02:02:06] start로 실행
[^333]: @[02:01:32]~@[02:01:45] 1~5 출력 작업 예시
[^334]: @[02:02:12] Runnable 소개
[^335]: @[02:02:58]~@[02:03:05] Thread 상속 vs Runnable(다른 클래스 상속 가능)
[^336]: @[02:03:23]~@[02:03:40] Runnable을 Thread에 전달해 start
[^337]: @[02:03:47] join 소개
[^338]: @[02:04:36]~@[02:04:43] 섞여 출력되는 결과
[^339]: @[02:04:52]~@[02:05:11] join으로 순서 제어
[^340]: @[02:05:11]~@[02:05:17] join 예외 처리 필요
[^341]: @[02:05:25] 다중 스레드 소개
[^342]: @[02:06:04]~@[02:06:10] 실행마다 결과 달라질 수 있음
[^343]: @[02:06:10] 동기화 정의
[^344]: @[02:06:19] synchronized 메소드 설명
[^345]: @[02:06:36] synchronized(변수) 블록 설명
[^346]: @[02:06:52]~@[02:07:12] SharedData, increment에 synchronized
[^347]: @[02:07:33]~@[02:07:51] 두 스레드 1000번씩=2000 기대
[^348]: @[02:08:10]~@[02:08:16] 실행 결과 2000 확인
[^349]: @[02:08:21]~@[02:08:41] synchronized 제거 시 1733 등 비정상
[^350]: @[02:08:41] 입출력/파일 섹션 시작
[^351]: @[02:08:48] 입력 정의 + Scanner
[^352]: @[02:09:10]~@[02:09:23] nextInt로 입력 대기/저장
[^353]: @[02:09:29]~@[02:09:35] 3 입력 예시
[^354]: @[02:09:54] next(단어)
[^355]: @[02:10:03] nextInt
[^356]: @[02:10:15] nextDouble
[^357]: @[02:10:31]~@[02:10:39] nextLine
[^358]: @[02:10:45] 출력 정의 + printf 소개
[^359]: @[02:11:02]~@[02:11:19] printf 예시(%s, %d)
[^360]: @[02:11:19]~@[02:11:37] 포맷 매핑 설명
[^361]: @[02:11:41] %d
[^362]: @[02:11:53]~@[02:12:04] %f
[^363]: @[02:12:04]~@[02:12:07] %s
[^364]: @[02:12:17]~@[02:12:27] %n
[^365]: @[02:12:39]~@[02:13:02] %-4d 정렬/칸 확보
[^366]: @[02:13:09]~@[02:13:27] %+4d 부호 표시
[^367]: @[02:13:27]~@[02:13:38] %04d 0 채움
[^368]: @[02:13:57]~@[02:14:03] %,d 천 단위 콤마
[^369]: @[02:14:10] %.2f 소수점 자리
[^370]: @[02:14:19] 파일/폴더 작업 소개
[^371]: @[02:14:27]~@[02:14:57] File + createNewFile + try-catch 예시
[^372]: @[02:15:02]~@[02:15:28] mkdir로 폴더 생성
[^373]: @[02:15:32]~@[02:15:44] createNewFile
[^374]: @[02:15:44]~@[02:15:52] exists
[^375]: @[02:15:52]~@[02:16:00] getName
[^376]: @[02:16:00]~@[02:16:18] getAbsolutePath
[^377]: @[02:16:22]~@[02:16:29] length
[^378]: @[02:16:36]~@[02:16:43] mkdir
[^379]: @[02:16:43]~@[02:16:52] mkdirs
[^380]: @[02:16:52]~@[02:17:05] listFiles
[^381]: @[02:17:05]~@[02:17:12] isFile/isDirectory
[^382]: @[02:17:12]~@[02:17:19] delete
[^383]: @[02:17:19] 파일 읽고 쓰기 섹션
[^384]: @[02:17:40]~@[02:18:05] BufferedWriter + FileWriter + write
[^385]: @[02:18:11]~@[02:18:17] newLine 필요 설명
[^386]: @[02:18:30]~@[02:18:57] BufferedReader + FileReader
[^387]: @[02:19:02]~@[02:19:23] readLine, null까지 반복
[^388]: @[02:19:31]~@[02:19:37] “감사합니다/안녕히 계세요” 출력 확인
[^389]: @[00:07]~@[02:19:37] 강의 전 범위에 걸친 반복 패턴 기반 통찰
[^390]: 용어들은 강의 내 정의/예시에서 직접 도출(각 항목의 출처는 해당 섹션 각주 참조)
[^391]: @[00:00]~@[02:19:46] 시작 인사와 마무리(강의 종료 안내 포함)