자바 학습 로드맵

【1단계: 자바 기초 개념】

1. 자바 플랫폼 이해

• JDK, JRE, JVM의 차이
• 컴파일과 실행 과정
• 바이트코드의 개념

핵심 개념 차이:

• 컴파일타임 vs 런타임
• 인터프리터 방식 vs JIT 컴파일
• 소스코드(.java) vs 바이트코드(.class)

2. 메모리 구조

• 스택과 힙
• 메소드 영역
• 가비지 컬렉션 기본 개념

핵심 개념 차이:

• 스택 메모리 vs 힙 메모리
  • 스택: 정적 할당, 함수 호출 시 생성
  • 힙: 동적 할당, 객체 저장
• 정적 영역 vs 동적 영역

3. 변수와 데이터 타입

• 기본형(primitive type)
• 참조형(reference type)
• 변수 스코프
• 형변환(casting)

핵심 개념 차이:

• 기본형 vs 참조형
  • 기본형: 실제 값 저장
  • 참조형: 주소 값 저장
• 값의 전달방식
  • Call by Value
  • Call by Reference
• 지역변수 vs 멤버변수
• 명시적 형변환 vs 암시적 형변환

4. 기본 문법

• 연산자(산술, 비교, 논리)
• 제어문(if, switch)
• 반복문(for, while)
• break, continue

핵심 개념 차이:

• 전위연산 vs 후위연산
• if문 vs switch문
• while vs do-while
• break vs continue

실습 포인트:

1. 기본형 데이터 타입별 메모리 사용량 확인
2. 형변환 시 데이터 손실 케이스 학습
3. 연산자 우선순위 실습
4. 디버거를 통한 변수 상태 확인

주의사항:

• 암묵적 형변환의 위험성 이해
• 변수 스코프 규칙 숙지
• NullPointerException 이해
• 연산자 우선순위 숙지

학습 체크포인트:

• JVM 메모리 구조 이해
• 기본형과 참조형의 차이 설명 가능
• 형변환 규칙 숙지
• 제어문 활용 능력

---

【2단계: 객체지향 기초】

1. 클래스와 객체

• 클래스 구조
• 인스턴스 생성(new)
• 생성자
• this 키워드

핵심 개념 차이:

• 클래스 vs 객체
  • 클래스: 설계도
  • 객체: 실제 구현체
• 인스턴스 변수 vs 클래스 변수
• this vs this()
  • this: 현재 객체 참조
  • this(): 다른 생성자 호출

2. 메소드

• 메소드 선언과 호출
• 파라미터 전달 방식
• 오버로딩
• return 문

핵심 개념 차이:

• 오버로딩 vs 오버라이딩
  • 오버로딩: 같은 이름, 다른 매개변수
  • 오버라이딩: 상속관계에서 메소드 재정의
• 인스턴스 메소드 vs 클래스 메소드
• 매개변수 vs 인자
• void vs return 타입

3. 접근 제어

• public, private, protected
• default 접근 제어자
• getter/setter

핵심 개념 차이:

• 접근 제어자 범위
  • private: 클래스 내부
  • default: 같은 패키지
  • protected: 상속관계까지
  • public: 모든 곳
• 캡슐화 vs 은닉화
• getter vs setter

실습 포인트:

1. 클래스 설계 및 구현
2. 다양한 생성자 구현
3. 메소드 오버로딩 실습
4. 접근 제어자 활용

주의사항:

• 생성자 체이닝 이해
• this 키워드 올바른 사용
• 메모리 관점에서의 객체 생성 이해
• 캡슐화 원칙 준수

학습 체크포인트:

• 클래스와 객체의 관계 이해
• 생성자의 특징과 규칙 숙지
• 메소드 오버로딩 구현 가능
• 접근 제어자의 범위 이해

추가 고려사항:

1. 객체 생성 과정
   • 메모리 할당
   • 인스턴스 초기화
   • 생성자 호출
2. 메소드 설계 원칙
   • 단일 책임 원칙
   • 적절한 접근 제어자 선택
   • 명확한 네이밍
3. 초기화 순서
   • 클래스 변수 초기화
   • 인스턴스 변수 초기화
   • 초기화 블록
   • 생성자

---

【3단계: 객체지향 심화】

1. 상속

• extends 키워드
• super 키워드
• 메소드 오버라이딩
• final 키워드

핵심 개념 차이:

• 상속 vs 구현
  • 상속(extends): 클래스 확장
  • 구현(implements): 인터페이스 구현
• super vs super()
  • super: 부모 클래스 참조
  • super(): 부모 생성자 호출
• final의 다양한 용도
  • final 클래스: 상속 불가
  • final 메소드: 오버라이딩 불가
  • final 변수: 값 변경 불가

2. 다형성

• 업캐스팅/다운캐스팅
• instanceof 연산자
• 추상 클래스
• 인터페이스

핵심 개념 차이:

• 추상클래스 vs 인터페이스
  • 추상클래스: 일부 구현 가능, 단일 상속
  • 인터페이스: 다중 구현 가능, 명세 중심
• 업캐스팅 vs 다운캐스팅
  • 업캐스팅: 자동 형변환
  • 다운캐스팅: 명시적 형변환 필요
• is-a vs has-a 관계
  • is-a: 상속 관계
  • has-a: 포함 관계

3. 캡슐화와 추상화

• 정보 은닉
• 인터페이스 설계
• SOLID 원칙
• 결합도와 응집도

핵심 개념 차이:

• 강한 결합 vs 느슨한 결합
• 높은 응집도 vs 낮은 응집도
• 구현 상속 vs 인터페이스 상속

SOLID 원칙:

1. SRP(단일 책임 원칙)
2. OCP(개방-폐쇄 원칙)
3. LSP(리스코프 치환 원칙)
4. ISP(인터페이스 분리 원칙)
5. DIP(의존성 역전 원칙)

실습 포인트:

1. 상속 구조 설계
2. 인터페이스 활용
3. 다형성 구현
4. SOLID 원칙 적용

주의사항:

• 상속의 남용 주의
• 적절한 추상화 수준 선택
• 인터페이스 분리 원칙 준수
• 순환 참조 주의

학습 체크포인트:

• 상속과 구현의 차이 이해
• 다형성 구현 능력
• SOLID 원칙 적용 능력
• 추상화 수준 결정 능력

추가 고려사항:

1. 설계 패턴과의 연관성
   • 템플릿 메소드 패턴
   • 팩토리 패턴
   • 전략 패턴
2. 실무적 고려사항
   • 유지보수성
   • 확장성
   • 재사용성
3. 성능 관련
   • 가상 메소드 테이블
   • 동적 바인딩
   • 메모리 사용

---

【4단계: Java API 활용】

1. String 관련

• String 메소드
• StringBuilder
• StringBuffer
• String Pool

핵심 개념 차이:

• String vs StringBuilder vs StringBuffer
  • String: 불변(immutable), 문자열 연산 시 새 객체 생성
  • StringBuilder: 가변(mutable), 단일 스레드
  • StringBuffer: 가변(mutable), 멀티 스레드 안전
• String literal vs new String()
  • literal: String Pool 사용
  • new: 힙 메모리에 새 객체 생성

2. 컬렉션 프레임워크

• List (ArrayList, LinkedList)
• Set (HashSet, TreeSet)
• Map (HashMap, TreeMap)
• Iterator

핵심 개념 차이:

• ArrayList vs LinkedList
  • ArrayList: 순차적 접근 빠름, 삽입/삭제 느림
  • LinkedList: 삽입/삭제 빠름, 순차적 접근 느림
• HashSet vs TreeSet
  • HashSet: 순서 없음, O(1) 검색
  • TreeSet: 정렬됨, O(log n) 검색
• HashMap vs Hashtable vs ConcurrentHashMap
  • HashMap: 비동기, null 허용
  • Hashtable: 동기화, null 비허용
  • ConcurrentHashMap: 세그먼트 단위 동기화

시간 복잡도 비교:

1. ArrayList
   • 조회: O(1)
   • 삽입/삭제: O(n)
2. LinkedList
   • 조회: O(n)
   • 삽입/삭제: O(1)
3. HashMap
   • 평균: O(1)
   • 최악: O(n)
4. 제네릭

• 제네릭 클래스
• 제네릭 메소드
• 와일드카드
• 타입 제한

핵심 개념 차이:

• vs <?>
  • : 타입 파라미터
  • <?>: 와일드카드
• extends vs super
  • extends: 상한 경계
  • super: 하한 경계

실습 포인트:

1. 문자열 처리 성능 비교
2. 컬렉션 선택과 활용
3. 제네릭 타입 설계
4. 반복자 패턴 구현

주의사항:

• 적절한 컬렉션 선택
• 제네릭 타입 소거 이해
• 동기화 고려
• 메모리 사용량 고려

학습 체크포인트:

• 문자열 처리 최적화 능력
• 컬렉션 프레임워크 활용 능력
• 제네릭 타입 설계 능력
• 반복자 패턴 이해

추가 고려사항:

1. 성능 최적화
   • 초기 용량 설정
   • 동기화 전략
   • 메모리 관리
2. 실무적 활용
   • 대용량 데이터 처리
   • 멀티스레드 환경
   • 메모리 누수 방지
3. 디자인 패턴 연계
   • Iterator 패턴
   • Factory 패턴
   • Builder 패턴

---

【5단계: 예외처리와 입출력】

1. 예외처리

• try-catch-finally
• throws, throw
• 사용자 정의 예외
• try-with-resources

핵심 개념 차이:

• Checked Exception vs Unchecked Exception
  • Checked: 컴파일 시점 확인, 반드시 처리
  • Unchecked: 런타임 시점, 선택적 처리
• throws vs throw
  • throws: 예외 선언(메서드 선언부)
  • throw: 예외 발생(메서드 내부)
• try-catch vs try-with-resources
  • try-catch: 기본 예외 처리
  • try-with-resources: 자동 리소스 해제

예외 처리 전략:

1. 예외 복구
2. 예외 회피
3. 예외 전환
4. 입출력(I/O)

• File 클래스
• InputStream/OutputStream
• Reader/Writer
• NIO

핵심 개념 차이:

• InputStream vs Reader
  • InputStream: 바이트 단위 처리
  • Reader: 문자 단위 처리
• IO vs NIO
  • IO: 스트림 방식, 블로킹
  • NIO: 채널 방식, 논블로킹
• 버퍼 사용 여부
  • 기본 스트림: 버퍼 없음
  • 버퍼 스트림: 성능 향상

주요 스트림 분류:

1. 바이트 스트림
   • FileInputStream/FileOutputStream
   • BufferedInputStream/BufferedOutputStream
2. 문자 스트림
   • FileReader/FileWriter
   • BufferedReader/BufferedWriter
3. 보조 스트림
   • DataInputStream/DataOutputStream
   • ObjectInputStream/ObjectOutputStream

실습 포인트:

1. 예외 처리 패턴 구현
2. 파일 입출력 구현
3. 버퍼 활용 최적화
4. 리소스 관리

주의사항:

• 리소스 누수 방지
• 적절한 버퍼 크기 설정
• 문자 인코딩 처리
• 예외 처리 계층화

학습 체크포인트:

• 예외 처리 전략 수립 능력
• 리소스 관리 능력
• 입출력 최적화 능력
• 문자셋과 인코딩 이해

추가 고려사항:

1. 성능 최적화
   • 버퍼 크기 최적화
   • NIO 활용
   • 비동기 처리
2. 보안 관련
   • 파일 접근 권한
   • 보안 취약점
   • 임시 파일 처리
3. 실무 응용
   • 로깅 시스템
   • 설정 파일 처리
   • 대용량 파일 처리

---

【6단계: 동시성 프로그래밍】

1. 쓰레드

• Thread 클래스
• Runnable 인터페이스
• 동기화(synchronized)
• ThreadPool

핵심 개념 차이:

• Process vs Thread
  • Process: 독립적 실행 단위, 자원 독립
  • Thread: 프로세스 내 실행 단위, 자원 공유
• Thread vs Runnable
  • Thread: 상속 방식, 단일 상속의 제약
  • Runnable: 구현 방식, 유연성 높음
• synchronized vs volatile
  • synchronized: 객체 잠금, 동기화
  • volatile: 가시성 보장, 원자성 미보장

2. 병렬 처리

• ExecutorService
• Future
• CompletableFuture
• 동시성 컬렉션

핵심 개념 차이:

• Runnable vs Callable
  • Runnable: 반환값 없음
  • Callable: 반환값 있음
• Future vs CompletableFuture
  • Future: 비동기 결과 처리
  • CompletableFuture: 비동기 연산 조합
• 동기 vs 비동기
  • 동기: 작업 완료 대기
  • 비동기: 작업 완료 미대기

쓰레드 상태:

1. NEW: 생성됨
2. RUNNABLE: 실행 가능
3. BLOCKED: 차단됨
4. WAITING: 대기
5. TIMED_WAITING: 시간 대기
6. TERMINATED: 종료됨

동기화 방식:

1. synchronized 키워드
2. Lock 인터페이스
3. volatile 키워드
4. atomic 클래스

실습 포인트:

1. 쓰레드 생성과 관리
2. 동기화 구현
3. ThreadPool 활용
4. 비동기 처리 구현

주의사항:

• 데드락 방지
• 동기화 범위 최소화
• 리소스 관리
• 예외 처리

학습 체크포인트:

• 쓰레드 생명주기 이해
• 동기화 메커니즘 이해
• ThreadPool 운영 능력
• 비동기 프로그래밍 이해

추가 고려사항:

1. 성능 최적화
   • 쓰레드 풀 크기 설정
   • 동기화 오버헤드
   • 컨텍스트 스위칭
2. 디버깅
   • 데드락 탐지
   • 레이스 컨디션 확인
   • 성능 병목 분석
3. 실무 응용
   • 웹 서버 구현
   • 비동기 API 설계
   • 배치 처리 구현

---

【7단계: 모던 자바】

1. 람다와 스트림

• 함수형 인터페이스
• 람다식
• 스트림 API
• Optional

핵심 개념 차이:

• 명령형 vs 선언형
  • 명령형: 어떻게(how) 처리할지 명시
  • 선언형: 무엇을(what) 할지 명시
• 익명 클래스 vs 람다식
  • 익명 클래스: 더 많은 보일러플레이트 코드
  • 람다식: 간결한 함수형 표현

주요 함수형 인터페이스:

1. Consumer: 값 소비
2. Supplier: 값 제공
3. Function<T,R>: 값 변환
4. Predicate: 조건 검사
5. 스트림 연산

• 중간 연산
  • filter
  • map
  • sorted
  • distinct
• 최종 연산
  • collect
  • reduce
  • forEach
  • count

핵심 개념 차이:

• Collection vs Stream
  • Collection: 데이터 저장과 접근
  • Stream: 데이터 처리 연산
• map vs flatMap
  • map: 1:1 변환
  • flatMap: 1:N 변환

3. Optional

• orElse vs orElseGet
• map vs flatMap
• filter 활용
• Optional 체이닝

핵심 개념 차이:

• null vs Optional.empty()
  • null: NPE 위험
  • Optional.empty(): 안전한 null 처리
• orElse vs orElseGet
  • orElse: 항상 실행
  • orElseGet: 필요시만 실행

실습 포인트:

1. 람다식 활용
2. 스트림 파이프라인 구성
3. Optional 활용
4. 함수형 프로그래밍 패턴

주의사항:

• 스트림 재사용 불가
• 무한 스트림 주의
• 부작용(side-effect) 최소화
• 적절한 병렬 처리

학습 체크포인트:

• 함수형 프로그래밍 이해
• 스트림 API 활용 능력
• Optional 활용 능력
• 람다식 디버깅 능력

추가 고려사항:

1. 성능 최적화
   • 병렬 스트림 활용
   • 적절한 컬렉터 선택
   • 중간 연산 최소화
2. 실무 응용
   • 데이터 변환
   • 집계 처리
   • 병렬 처리
3. 디자인 패턴 적용
   • 전략 패턴
   • 옵저버 패턴
   • 데코레이터 패턴

---

【8단계: 실무 응용】

1. 디자인 패턴

• 생성 패턴
• 구조 패턴
• 행위 패턴

핵심 패턴 분류:

• 생성 패턴
  • Singleton: 단일 인스턴스 보장
  • Factory Method: 객체 생성 캡슐화
  • Builder: 복잡한 객체 생성
  • Prototype: 객체 복제
• 구조 패턴
  • Adapter: 인터페이스 호환
  • Decorator: 기능 동적 추가
  • Composite: 부분-전체 계층
  • Proxy: 접근 제어
• 행위 패턴
  • Observer: 상태 변화 통지
  • Strategy: 알고리즘 캡슐화
  • Template Method: 알고리즘 골격
  • Command: 요청 캡슐화

2. 테스팅

• JUnit
• 단위 테스트
• 통합 테스트
• Mock 객체

핵심 개념 차이:

• 단위 테스트 vs 통합 테스트
  • 단위: 개별 컴포넌트 테스트
  • 통합: 컴포넌트 간 상호작용 테스트
• Mock vs Stub
  • Mock: 행위 검증
  • Stub: 상태 검증

테스트 원칙:

1. F.I.R.S.T
   • Fast: 빠른 실행
   • Independent: 독립적
   • Repeatable: 반복 가능
   • Self-validating: 자가 검증
   • Timely: 적시성
2. 성능 최적화

• JVM 튜닝
• 프로파일링
• 메모리 누수 방지
• 코드 최적화

핵심 개념 차이:

• 컴파일 최적화 vs 런타임 최적화
• 시간 복잡도 vs 공간 복잡도
• 동기 처리 vs 비동기 처리

4. 빌드와 배포

• Maven/Gradle
• CI/CD
• 도커 기초
• 배포 자동화

주요 도구 비교:

• Maven vs Gradle
  • Maven: XML 기반, 선언적
  • Gradle: Groovy/Kotlin 기반, 프로그래밍 가능

실습 포인트:

1. 디자인 패턴 적용
2. 테스트 코드 작성
3. 성능 측정과 최적화
4. CI/CD 파이프라인 구성

주의사항:

• 과도한 패턴 사용 지양
• 테스트 가능한 코드 설계
• 성능과 유지보수성 균형
• 배포 자동화 안정성

학습 체크포인트:

• 디자인 패턴 활용 능력
• 테스트 코드 작성 능력
• 성능 최적화 능력
• 배포 자동화 구현 능력

추가 고려사항:

1. 코드 품질
   • 정적 분석 도구 활용
   • 코드 리뷰 프로세스
   • 기술 부채 관리
2. 운영 관점
   • 로깅 전략
   • 모니터링
   • 장애 대응
3. 보안
   • 시큐어 코딩
   • 취약점 분석
   • 접근 제어