3일간 AI Challenge 2를 진행한 후의 회고

AI Challenge! 가 뭐냐면. 싸피에서 진행한 AI 챌린지 중 두 번째로, VQA 모델을 만들고 캐글에서 순위를 겨루는 AI 실전이다. 첫 번째 챌린지는 개인으로 하루 동안 진행되었고, 이번 두번째 챌린지는 넷 혹은 다섯이서 팀을 이뤄 함께 참여했다. 총 3일간 진행되었는데 휴일 기간에도 제출을 할 수 있어 사실상 아직 진행 중이다. 나는 알고리즘 스터디원들과 함께 넷이서 참여했다. 짧은 기간이었지만, 이번 챌린지는 이전에 혼자 모델을 학습시켰을 때와는 꽤 다른 경험으로 남았다.

첫 번째 참여했을 때는 성능을 높이기 위해 에폭이나 학습량을 바꾸고, 모델을 교체한 뒤 점수가 어떻게 달라지는지 확인하는 데 집중했다. 물론 그런 실험도 필요하지만, 당시에는 왜 점수가 달라졌는지 설명하거나 다음 실험의 방향을 정하는 일이 막막했다. 하지만 이번에는 달랐다. 팀원이 "파이프 라인"을 제안한 것이다. 모델 학습에 전략이 있다니.

이렇게 저렇게해서 요렇게 저렇게 하면 어떨까요. 이거랑 저거 써서... 아님 요거나 그거? 이래요래 해서 안되면 이러쿵 저러쿵......

네?

솔직히 9할 정도는 못 알아들었지만 지난 챌린지와 무언가 다르게 흘러가고 있다는 것은 알 수 있었다.

1일차, 0.69에서 시작

우리 팀의 모델은 Qwen2.5-VL-3B-Instruct에 데이터 200개를 학습한 베이스라인에서 출발했다. 첫 정확도는 0.69였다.

우리의 전략은 이랬다. 모델에 이미지를 그대로 넣으면 필요한 정보를 놓칠 수 있으니 질문에 관련된 영역을 바운딩하고, 그 부분을 크롭해 모델에 전달하는 것이다. 처음에는 크롭한 이미지에서 OCR로 글자를 뽑고 선택지와 비교하려 했지만, OCR 모델을 찾는 과정에서 Qwen 자체의 문자 인식 성능이 좋다는 사실을 알게 됐다. 굳이 별도의 OCR 단계를 둘 필요가 없다는 결론이 나와 크롭 이미지를 Qwen이 직접 읽고 답하도록 방향을 바꿨다.

설계가 곧바로 원하는 대로 동작한 것은 아니었다. 모델이 반환한 바운딩 박스 좌표는 정규화된 값이라 실제 이미지에서 엉뚱한 위치를 가리켰다. 좌표를 픽셀 기준으로 보정해야 했다. 원본 이미지는 대부분 720픽셀 이상인데 추론 입력은 384픽셀이라 작은 글자가 뭉개지는 문제도 있었다. 해상도를 높이자 정답률도 함께 올라갔다.

이후에도 크고 작은 문제들이 있었는데 이 과정이 의외로 재미있었다. 계획한 파이프라인이 한 번에 완성되지는 않았지만 문제가 생길 때마다 결과를 확인하고 자료를 찾아보면서 설계를 조금씩 완성해 나갔다. 이론으로만 배울 때는 잘 느끼지 못했던 실전의 감각이 이런 것이 아닐까 싶었다.

크롭은 항상 정답이 아니었다

Qwen3-VL-2B-Instruct로 train 데이터 중 무작위 500개를 추려 모든 문항에 크롭을 적용했을 때 정확도는 0.84였다.

처음에는 크롭을 적용하면 당연히 더 잘 읽을 거라고 생각했다. 결과는 그렇게 단순하지 않았다. 못 맞히던 문제를 맞히게 해주기도 했지만, 원래 맞힐 수 있던 문제를 틀리게 만들기도 했다.

[안내문, 절차, 긴 문장] 유형은 0.775에서 0.875로 올랐고, [고유명사, 상호, 장소명] 유형도 0.904에서 0.923으로 상승했다. 작은 글자나 특정 영역의 정보가 중요한 문제에서는 크롭이 실제로 도움이 된다는 걸 확인한 것이다. 반면 [제외, 부정 비교] 유형은 0.720에서 0.600으로 떨어졌다. 이미지를 잘라내는 과정에서 문제를 푸는 데 필요한 전체 맥락까지 사라졌기 때문이다.

공식 문서를 찾아보면서 Qwen이 여러 이미지를 함께 입력받을 수 있다는 점을 확인했다. 이후 크롭 이미지만 넣던 방식에서 원본 이미지와 크롭 이미지를 함께 넣는 방식으로 바꿨다. 원본으로 전체 맥락을 유지하고, 크롭으로 세부 정보를 보완하려는 선택이었다.

2일차, 점수가 곧 기분이 되다

모델에 전체 데이터의 절반을 학습했을 때 정확도는 0.866, 전체 데이터를 학습했을 때는 0.888이었다. 여기에 원본과 크롭 이미지를 함께 사용하는 전략을 적용하자 0.941까지 올랐다. 우리가 세운 가설이 실제 점수로 이어진 순간이라 정말 기뻤다. 학습량, 이미지 해상도, 입력 방식이 모두 의미가 있을 수 있다는 것을 결과로 확인했다.

그리고 드디어 모델을 변경해보기로 했다. 좋다는 소문이 파다한 Qwen3.5-9B. 기대가 너무 커서 점수가 낮게 나올 거라는 생각도 안했다. 사실 첫 추론에선 최대 생성 토큰 수 설정이 잘못돼 모든 답을 A로 내놓는 사건이 있었다. 0.2점 대의 대단한 점수도 기록으로 남았다. 이후 설정을 바로잡고 전체 데이터 파인튜닝과 크롭을 적용한 실험에서는 0.960이 나왔다. 기대했던 모델이 기대한 만큼의 점수를 냈을 때 느낀 기쁨은 생각보다 컸다.

반대의 순간도 있었다.

위의 실험에 +프롬프팅 을 한 모델이 동시에 추론을 하고 있었다. 0.96을 본 우리는 불을 발견한 원시인 마냥 이 불에 구워질 고기를 기대하고 있었다. 하지만 파인튜닝 없이 프롬프트를 적용한 결과는 0.945였고, 파인튜닝과 프롬프트를 함께 적용한 결과도 0.959였다... 둘 다 파인튜닝과 크롭만 사용한 0.960을 넘지 못했다. 좋아 보이는 기술을 하나 더 얹는다고 성능이 반드시 좋아지지는 않았다. 기대를 많이 한 탓인지 약간 슬프기까지 했다.

3일차, 마지막까지

마지막에는 새로운 분류를 시도했다. 처음의 규칙 기반 분류는 질문에 특정 단어가 있는지를 보는 방식이라 범용성이 부족했다. 오답을 살펴봤을 때에도 기타 분류가 많았다. 그래서 먼저 LLM이 train 데이터의 문제 유형을 분류하게 하고, 텍스트와 숫자를 함께 이해해야 하는 어려운 문제만 Qwen3.8-27B로 보내는 분기 전략을 시도했다.

다만 Colab 자원이 거의 끝나가던 시점이라 충분히 검증하지 못한 채 급하게 추론을 진행해야만 했다. 결과는 0.959였다. 아쉬움은 남았지만, 큰 모델을 쓰는 것만으로 문제가 해결되지는 않는다는 사실을 다시 확인했다. 이 마지막 도전에 새로운 전략을 사용한 만큼 또 다시 좋은 점수를 기대했는데... 아쉬움은 남지만 전략이 유효한지 검증한 건 아니니 아직 다음이 있다.

3일 동안 점수 하나에 이렇게 기뻐하고 실망할 줄은 몰랐다. 점수가 오를 것이라고 확신했던 실험이 잘되면 신이 났고, 좋은 기술을 더했는데 오히려 내려가면 허탈했다. 그래도 그 감정까지 포함해서 재미있었다. 결과를 기다리는 시간이 길어질 수록 더 기대하게 되었고, 회의를 하며 오가는 아이디어를 듣고만 있어도 지식이 쌓이는 것만 같았다. 실제로 이 팀전에 내 기여도는 크지 않지만, 진행 중 가장 많은 것을 얻어간 사람은 나일지도.

마치며,

이번 챌린지를 거치며 AI 모델에 대한 이해도가 확실히 높아졌다고 느낀다. 모델 구조나 파인튜닝을 이론으로 배운 것과는 달랐다. 이미지 해상도와 입력 구성, 프롬프트, 모델 설정이 서로 영향을 주고, 좋아 보이는 조건끼리도 충돌할 수 있다는 사실을 직접 겪었다. 완벽한 정답이 없는 문제에서 근거를 모아 다음 풀이를 정하는 경험이었다. 마지막에 다른 팀의 발표를 보면서도 많이 배웠다. 같은 데이터와 같은 목표를 두고도 접근 방법은 정말 다양했다. 우리가 떠올리지 못한 기발한 전략이 있었고, 실제로 점수를 높인 방법은 직접 다시 실험해 보고 싶었다.

혼자였다면 어쩌면 아예 시도조차 하지 못했을 거다. 팀원들과 함께였기 때문에 끊임없이 새로운 것을 들을 수 있었다. 서당개가 3년만에 풍월을 읊는데는 이유가 있다. 듣는 건 정말 큰 도움이 된다. 한 편으론 아쉬움도 남는다. 시작할 때 실험 계획과 역할을 조금 더 구체적으로 나눴더라면 시간 자원의 낭비 없이 더 많은 가설을 검증해 볼 수 있었을 것이다. 또 추석 연휴에 시간을 더 쓸 수 있었더라면 좋았을 것 같다. 아직 탐색할 수 있는 덜 밝혀진 맵이 눈 앞에 한참은 더 있는 느낌이다.

사실 최종 성적이 아주 높은 편은 아니었다. 그래도 0.69에서 시작해 처음 0.96 라는 점수를 확인했을 때는 정말 기뻤다. 반에서 박수를 치며 좋아했다. 반 꼴찌로 시작한 우리 모델이 (슬슬 자식으로 여겨졌다) 아주 크게 성장한 것만 같았다. 숫자 자체보다 우리가 세운 가설과 검증이 실제 개선으로 이어졌다는 사실이 좋았다. 물론 숫자도 좋았다.

나는 경험의 가치를 높게 두는 편이다. 새로운 경험일수록 점수를 높게 준다. 이번 3일은 완전히 새로운 스킬을 새로 해금한 즐거운 시간이었다. 연휴 기간 아직 캐글 대회가 열려 있기 때문에 우리팀의 열정이 넘치는 팀원들은 조금 더 시도를 해볼 성싶다. 정말 응원함!!

최근 프로젝트 이야기를 하다가 “백엔드 개발자로서 이번 프로젝트에서 어떤 부분을 경험해보고 싶냐”는 질문을 받았다. 바로 대답하기 어려웠다. Spring Boot를 사용해보고 싶다거나 Redis를 적용해보고 싶다거나... 기술 이름을 나열 할 순 있었겠지만 프로젝트에서 내가 정말 경험해 보고 싶은 부분이냐, 하면 그렇지 않은 것 같았다. 어떤 문제를 해결해보고 싶냐고? 새로운 문제요.

새로운 문제가 뭔데?

음

ㅎㅎ?

정말 모르겠습니다.

아직 백엔드 프로젝트 경험이 많지 않아서 그런 것 같다. 데이터베이스도 더 깊게 다뤄보고 싶고, 캐시나 비동기 처리도 궁금하다. 직접 서버를 배포하고 로그를 보면서 문제를 찾는 과정도 경험해보고 싶다. 해본 것이 많지 않다 보니 오히려 뭘 해봐도 재미있을 것 같았고, 그래서 하나를 고르기가 더 어려웠다.

이런 고민을 이야기하다가 두 가지 조언을 들었다. 아직 뭘 좋아하는지 모르겠다면 채용공고를 보면서 기업이 백엔드 개발자에게 어떤 기술과 경험을 원하는지 살펴보는 것도 좋다는 것이었다. 또 하나는 막상 프로젝트가 끝난 뒤 기술적으로 무엇을 경험했는지 떠올려보려면 생각보다 어렵다는 이야기였다. (조언 감사합니다)

그래서 살펴본 채용 공고

메가스터디교육 백엔드 개발 공고

• MySQL 스키마 설계, 쿼리 최적화 및 인덱스 관리
• AWS 클라우드 환경에서 서비스 운영

단순히 API를 구현한 경험만이 아니라 데이터 구조를 직접 설계하고, 느린 쿼리를 개선하고, 완성한 서비스를 실제 환경에서 운영한 경험을 요구하고 있었다.

이너버스 백엔드 개발자 공고

• Core Java & Framework ㆍJava 8+ 실무 경험 필수 (주 개발 언어) 　- 람다, 스트림, CompletableFuture 등 비동기 처리 　- 멀티스레딩, 동시성 제어 및 성능 최적화 　- JVM 튜닝 및 메모리 관리 ㆍMaven/Gradle 빌드 도구 활용
• 대용량 데이터 처리 ㆍElasticsearch 실무 경험 (인덱스 설계, 쿼리 최적화, 집계 쿼리) ㆍ대용량 로그 수집/저장/검색 시스템 개발 경험 ㆍ실시간 데이터 파이프라인 구축 경험 ㆍ배치 처리 및 스트림 처리 아키텍처 설계 ㆍ효율적인 로그 파싱 및 정규화 로직 구현
• 분산 시스템 & 메시징 ㆍApache Kafka 또는 유사 메시징 시스템 실무 경험 ㆍ분산 환경에서의 데이터 일관성 및 트랜잭션 처리 ㆍ마이크로서비스 아키텍처 설계 및 구현 ㆍDocker/Kubernetes 기반 컨테이너 환경 경험 ㆍ서비스 간 통신 패턴 (REST, gRPC, 메시지 큐 등)
• ** 데이터베이스 ** ㆍRDBMS (PostgreSQL, MySQL 등) 설계 및 쿼리 최적화 ㆍNoSQL (Redis, MongoDB 등) 캐싱 및 세션 관리 ㆍ시계열 데이터베이스 경험 우대 (InfluxDB, TimescaleDB 등) ㆍ대용량 데이터 파티셔닝, 샤딩, 인덱싱 전략

다른 공고에 비해 필수 기술 역량이 자세히 적혀있어 전부 가져와 봤다.

다이렉트클라우드 채용공고

・PHP 또는 Golang을 이용한 백엔드 개발 경험 ・웹 서비스의 구조를 이해하고 개발해본 경험 ・대용량 트래픽 경험 ・서버리스 및 마이크로 아키텍쳐에 대한 이해・PHP 또는 Golang을 이용한 백엔드 개발 경험

서버를 개발하는 것과 함께 배포된 서비스를 운영하고, 운영 중 발생하는 문제의 원인을 찾는 경험을 중요하게 보고 있었다.

이렇게 공고를 살펴봤는데, 모든 공고가 Kafka나 Elasticsearch 같은 기술을 공통으로 요구하는 것은 아니었다. 이너버스 공고는 대용량 로그를 다루는 서비스의 특성상 데이터 처리와 분산 시스템에 관한 요구가 특히 자세한 편이었다.

그럼에도 여러 공고에서 비슷하게 확인할 수 있었던 것은 다음과 같았다.

• 필요한 데이터를 고려해 DB 구조를 설계해본 경험
• 느린 쿼리와 인덱스를 분석해 성능을 개선해본 경험
• 많은 요청이나 데이터를 처리하면서 병목을 찾아본 경험
• 서버를 배포하는 것에서 끝내지 않고 실제로 운영해본 경험
• 오류나 장애가 발생했을 때 원인을 확인하고 해결해본 경험
• 캐시, 비동기 처리, 메시지 큐 등을 문제에 맞게 선택해본 경험

Kafka, Elasticsearch, Kubernetes처럼 특정 공고에서 요구하는 기술도 있었지만, 결국 공통적으로 보고 있는 것은 기술 이름보다 그 기술을 이용해 어떤 문제를 해결해봤는지에 가까워 보였다.

그리고 이너버스 공고를 보면서는 또 다른 궁금증이 생겼다.

저 많은 걸 백엔드 개발자 한 명이 다 할 줄 알아야 할까?

찾아보니 회사와 팀의 규모에 따라 달랐다. 작은 팀에서는 한 명의 백엔드 개발자가 API 개발부터 DB 설계, 배포와 운영까지 넓게 담당하기도 한다. 반대로 규모가 큰 회사에서는 데이터 엔지니어, 검색 엔지니어, 인프라 엔지니어, SRE처럼 역할이 나뉘기도 한다.

Kafka 클러스터는 인프라팀에서 운영하고 백엔드 개발자는 메시지를 보내고 처리하는 로직을 만들 수도 있다. Kubernetes 환경은 플랫폼팀에서 관리하지만, 백엔드 개발자가 자신의 서버에 필요한 설정과 상태 확인 방법을 정할 수도 있다.

그러니까 공고에 적힌 기술을 한 사람이 전부 같은 깊이로 다뤄야 한다기보다는, 자신의 영역은 깊게 이해하고 주변 영역의 개발자와 함께 문제를 해결할 수 있어야 한다는 뜻에 가까웠다. 물론 정말로 한 명이 다 하는 회사도 있을 것이다..

그래서 나는 무슨 경험을 해보고 싶은가

공고를 살펴보고 나니 처음 질문에도 조금은 구체적으로 답할 수 있을 것 같았다. 아직 “나는 반드시 대용량 로그 처리 전문가가 될 거야!” 같은 목표가 생긴 것은 아니다. 여전히 안 해본 것이 많고, 그래서 이것저것 해보고 싶다.

그래도 단순히 서버를 한 번 만들어보는 것에서 끝내고 싶지는 않다. 오늘 글의 결론은 크게 두 가지 이다.

1. 정상 동작보다 장애 상황을 한 번 만들어보고 싶다.

정해진 순서대로 요청을 보내고 예상한 응답을 받는 것만으로는 알 수 없는 문제가 많을 것 같다. 외부 API가 늦게 응답하거나, DB 연결이 끊기거나, 같은 데이터를 여러 사용자가 동시에 수정하는 상황을 직접 만들어보고 싶다.

• 외부 API 응답을 일부러 늦추거나 실패시키기
• DB 연결이 끊어진 상황 만들어보기
• 같은 데이터에 동시에 수정 요청 보내기
• 서버가 처리할 수 있는 양보다 많은 요청 보내기
• 작업을 처리하던 서버를 중간에 종료해보기

그다음 timeout이나 retry를 적용하고, 트랜잭션과 락을 사용하면서 결과가 어떻게 달라지는지 확인해보고 싶다. 장애가 한 번도 나지 않는 서버를 만들겠다는 것보다 장애가 났을 때 원인을 찾을 수 있는 서버를 만들어보고 싶다.

2. 성능 개선을 숫자로 확인해보고 싶다.

“Redis를 사용해서 빨라졌다”, “인덱스를 추가해서 성능을 개선했다”라고만 적으면 정말로 얼마나 좋아졌는지 알 수 없다. 개선 전후를 직접 측정하고 비교해보고 싶다.

• 데이터가 1만 건일 때와 100만 건일 때의 조회 시간
• 인덱스를 적용하기 전후의 응답 시간
• 캐시를 적용하기 전후의 DB 조회 횟수
• 동시에 여러 요청이 들어왔을 때의 처리량과 오류율
• N+1 문제를 해결하기 전후의 쿼리 실행 횟수

조회 API의 평균 응답 시간이 어떤 식으로 변했는지, 초당 처리 가능한 요청 수가 얼마나 늘었는지, 요청 한 번 당 실행되는 쿼리의 수를 줄일 수 있을지를 숫자로 체크하고 싶다.

결론

아직 백엔드 경험이 많지 않아서 어떤 분야가 가장 재미있는지는 잘 모르겠다. 오히려 지금은 안 해본 것이 많아서 무엇을 해도 재미있을 것 같다.

그래도 이번 프로젝트에서 해보고 싶은 경험은 이전보다 조금 구체적으로 정리할 수 있게 됐다.

• 정상 동작뿐 아니라 장애 상황도 직접 만들어보기
• 성능 개선 결과를 숫자로 확인하기

또 어떤 기술을 사용할지 먼저 선택하기보단 문제를 먼저 확인하고 필요한 기술을 선택하고 싶다. 먼저 기술을 정해놓고 프로젝트를 진행하면 사용한 기술은 많아질 수 있겠지만 왜 사용했는지를 설명할 수 없다. 프로젝트가 끝난 뒤 Spring Boot와 Redis를 사용했습니다라고만 말하고 싶지는 않다. 어떤 문제가 있었고, 왜 그런 방법을 선택했으며, 적용한 뒤 무엇이 달라졌는지를 설명할 수 있었으면 좋겠다.

프로젝트 기대된당!!

백엔드 개발자는 무슨 일을 할까?

백엔드 개발자를 향한 항해 01 | 백엔드 개발자는 무엇을 책임질까?

요즘 Java로 알고리즘 문제를 풀고 있다. 문제를 읽고, 조건에 맞는 풀이를 생각하고, 코드를 작성해 결과를 확인하는 과정에는 조금씩 익숙해지고 있다.

이제는 그동안 공부한 내용을 하나의 서비스로 연결해 보고 싶어졌다. 이번에 만들어 보려는 것은 재고 CSV 파일을 검사하고 정해진 형식으로 바꿔 주는 서비스, DataCheck다. 아직 구현 전이며, 앞으로 이 프로젝트를 진행하면서 백엔드와 관련된 개념을 함께 공부해 보려고 한다.

파일을 읽고 잘못된 값을 찾는 기능은 Java 프로그램 하나로도 만들 수 있다. 그런데 여러 사용자가 웹에서 파일을 올리고, 이전 결과를 다시 확인하고, 실패한 작업을 재실행하도록 하려면 어떤 일이 더 필요할까?

첫 글에서는 이 질문을 출발점으로 백엔드 개발자의 책임을 정리해 봤다.

어떤 서비스를 만들려고 하는가

DataCheck는 정해진 재고 CSV를 업로드하면 잘못된 데이터와 그 이유를 알려주고, 정상 데이터만 표준 형식으로 내려받게 하는 서비스다. CSV는 쉼표로 필드를 구분하는 텍스트 기반 데이터 형식이다. 따옴표로 감싼 값에는 쉼표나 줄바꿈도 들어갈 수 있어서, 단순히 쉼표마다 문자열을 잘라서는 정확하게 읽을 수 없다.

첫 버전은 품목 코드, 품목명, 수량, 창고 코드, 기록일이라는 다섯 열만 지원하려고 한다. 엑셀 파일이나 임의의 양식을 모두 처리하려고 하면 처음부터 범위가 너무 넓어질 것 같아 UTF-8 CSV 한 종류로 정했다.

예를 들어 수량이 음수라면 해당 행을 오류로 분류하고, 날짜가 2026/09/16이라면 실제로 존재하는 날짜인지 확인한 뒤 2026-09-16으로 바꾼다. 품목명에 쉼표가 들어 있어도 하나의 값으로 보존해야 한다. CSV 전용 파서가 파일의 구조를 읽고, 내가 작성할 검증기는 각 값이 업무 규칙에 맞는지 판단하도록 나눌 생각이다. Apache Commons CSV의 파싱·출력 설명

사용자는 로그인하고 파일을 제출한 뒤 진행 상태를 확인한다. 검사가 끝나면 정상 결과와 오류 보고서를 내려받고, 나중에 자신의 작업 이력을 다시 조회한다.

아직 실제 사용자의 반복 수요를 확인한 것은 아니다. 우선 합성 데이터로 기능과 실패 상황을 검증하는 학습 프로젝트로 시작하려고 한다.

클라이언트와 서버: 파일을 보내는 쪽과 처리하는 쪽

클라이언트(client)는 다른 프로그램의 기능이나 데이터를 요청하는 쪽이고, 서버(server)는 그 요청을 받아 처리하고 결과를 제공하는 쪽이다.

DataCheck에서는 사용자가 접속한 브라우저가 클라이언트 역할을 한다. 브라우저는 선택한 파일을 서버로 보내고, 이후 작업 상태나 결과 파일을 요청한다. 서버는 요청한 사용자를 확인하고, 파일을 보관하고, 검사를 진행하며, 요청에 맞는 응답을 돌려준다.

‘서버’라는 말은 프로그램과 컴퓨터를 모두 가리킬 수 있다. ‘Java로 서버를 만든다’고 할 때는 요청을 처리하는 프로그램을, ‘서버에 파일을 보관한다’고 할 때는 그 프로그램이 사용하는 컴퓨터나 저장 환경을 뜻하는 경우가 많다. 내 노트북에서 서버 프로그램과 브라우저를 함께 실행해도 둘의 역할은 구분된다.

통신에는 요청과 응답의 형식을 정한 약속이 필요하다. 웹에서 사용하는 대표적인 약속이 HTTP다. 파일을 보낸다는 행동도 실제로는 파일 내용을 담은 HTTP 요청으로 전달된다. 다만 모든 요청이 끝날 때까지 파일 검사도 반드시 끝나 있어야 하는 것은 아니다.

이 프로젝트에서 특히 구분해야 할 것이 ‘접수되었다’와 ‘검사가 끝났다’다.

파일을 오래 검사해야 한다면 서버는 원본을 저장하고 작업 정보를 DB에 남긴 뒤, 우선 작업 ID를 돌려줄 수 있다. 이후 별도의 처리 코드가 검사를 수행하고 브라우저는 작업 ID로 상태를 조회한다. 이런 구조에서 접수 응답을 받았다는 것은 작업이 등록됐다는 뜻이다. 정상 결과를 내려받을 수 있다는 뜻은 아니다.

처음에는 요청이 끝나기 전에 검사까지 수행하는 동기 방식으로 만들어 보고, 기능이 맞게 동작하면 요청 접수와 실제 처리를 분리할 예정이다. 기다리는 흐름을 바꾸는 것이므로, 비동기로 바꿨다고 검사 알고리즘 자체가 빨라지는 것은 아니다.

프런트엔드와 백엔드: 화면에 보이는 상태는 어디에서 결정될까?

프런트엔드(frontend)는 사용자가 서비스를 보고 조작하는 부분을 구현한다. DataCheck에서는 파일 선택창, 업로드 버튼, 작업 목록, 오류 미리보기, 다운로드 버튼이 여기에 해당한다.

겉모양을 만드는 것 외에도 할 일이 있다. 제출 중 버튼이 여러 번 눌리지 않게 하고, 파일을 고르지 않았다면 안내하고, 서버가 알려준 작업 상태에 맞게 화면을 바꾸는 일도 프런트엔드가 담당한다.

백엔드(backend)는 요청을 해석하고, 서비스의 규칙에 맞게 처리하며, 필요한 데이터와 상태를 관리한다. 파일 크기를 검사하고, 사용자와 작업을 연결하고, 검사를 실행하며, 어떤 결과를 다운로드하도록 허용할지 결정하는 일이 여기에 해당한다.

프런트엔드에서 파일 크기를 확인하더라도 서버의 검사는 필요하다. 사용자가 화면 코드를 바꾸거나, 브라우저 대신 다른 도구로 직접 요청할 수도 있기 때문이다. 화면의 검사는 사용자에게 빠르게 안내하기 위한 것이고, 서버의 검사는 실제로 받아들여도 되는 요청인지 판단하기 위한 것이다.

다운로드 버튼을 숨기는 것만으로 다른 사람의 파일 접근을 막을 수도 없다. 버튼이 없어도 다운로드 주소로 직접 요청할 수 있으므로, 파일을 제공하는 순간 서버에서 소유권을 확인해야 한다.

두 영역은 API(Application Programming Interface)라는 접점을 통해 협력한다. API는 프로그램이 다른 프로그램의 기능을 어떤 방법으로 요청하고 어떤 결과를 받을지 정한 인터페이스다.

이 서비스에서는 ‘파일을 제출하면 작업 ID를 받는다’, ‘작업 ID로 현재 상태와 집계를 조회한다’, ‘성공한 작업의 결과를 요청하면 파일을 받는다’는 약속이 필요하다. 프런트엔드는 이 약속을 바탕으로 화면을 구성하고, 백엔드는 약속한 의미에 맞는 상태와 결과를 제공한다.

따라서 완료 화면을 보여주는 시점도 단순한 디자인 문제가 아니다. 업로드가 끝난 순간 화면에 ‘검사 완료’를 표시하면 실제 처리 상태와 어긋날 수 있다. 백엔드가 접수·진행·완료를 구분하고, 프런트엔드가 그 의미를 유지해야 한다.

클라이언트·서버가 통신에서의 역할을 설명한다면, 프런트엔드·백엔드는 구현의 관심사와 책임을 설명한다. 서버에서 화면을 만들어 보내는 방식도 있으므로 두 구분을 완전히 같은 뜻으로 외우지는 않으려고 한다.

비즈니스 규칙: 어떤 데이터를 정상으로 볼 것인가

비즈니스 규칙(business rule)은 서비스가 다루는 업무에서 지켜야 하는 조건과 정책이다. 여기서 비즈니스는 돈을 버는 활동만 뜻하지 않는다. DataCheck에서는 재고 데이터를 검사하고 정리하는 일이 서비스의 업무다.

‘수량은 0 이상의 정수여야 한다’, ‘품목 코드는 비어 있으면 안 된다’, ‘날짜는 실제로 존재해야 한다’는 조건이 규칙이다. 잘못된 행이 발견됐을 때 전체 파일을 거절할지, 그 행만 제외할지도 업무 규칙에 해당한다.

이 프로젝트에서는 개별 행의 값이 잘못된 경우 해당 행만 정상 결과에서 제외하고, 오류 보고서에 이유를 남기기로 했다. 하지만 헤더가 다르거나 CSV 구조가 깨져 내용을 신뢰할 수 없다면 파일 전체를 실패로 처리한다. 앞부분에 정상처럼 보이는 행이 있어도 완성된 결과로 공개하지 않는다.

같은 품목·창고·기록일이 반복되면 첫 번째 정상 행만 채택한다. 단순히 파일에서 먼저 나타났다는 이유만으로 잘못된 행을 기준으로 삼지는 않는다. 날짜 형식과 정해진 공백 처리를 먼저 적용한 뒤 중복 키를 비교해야 표현만 다른 같은 데이터를 구분할 수 있다.

예를 들어 아래는 네 레코드를 검사할 때 기대하는 결과다. 아직 실행 결과가 아니라, 구현이 맞는지 확인하기 위해 먼저 정한 기준이다.

전체는 4행, 정상은 2행, 오류는 2행이다. 오류 항목은 2번의 두 문제와 3번의 중복 문제를 합쳐 3개다. 오류 행 수와 오류 항목 수는 서로 다르다.

이런 규칙을 실제 판단과 처리 순서로 옮긴 부분을 비즈니스 로직(business logic)이라고 한다. 입력을 정리하고, 필수값과 범위를 검사하고, 정상 후보의 중복을 판단한 뒤 출력 대상을 나누는 과정이 여기에 해당한다.

CSV 라이브러리가 따옴표나 쉼표를 읽어 주더라도, 음수 수량을 허용할지와 중복 중 무엇을 남길지는 대신 결정해 주지 않는다. 코드를 작성하기 전에 정책과 기대 결과를 정리해야 하는 이유다.

영속성: 검사 결과와 작업 이력은 어디에 남을까?

영속성(persistence)은 프로그램 실행이 끝난 뒤에도 데이터를 보존하고 다시 사용할 수 있는 성질이다.

검사 결과를 Java의 ArrayList에만 담아 두면 실행 중에는 사용할 수 있다. 하지만 프로세스를 종료하고 다시 시작했을 때 이전 목록이 자동으로 돌아오지는 않는다. 사용자가 다음 날 작업 이력을 확인하거나 결과를 다시 내려받으려면 메모리 밖에 정보를 남겨야 한다.

이번 프로젝트에서는 파일과 DB가 서로 다른 정보를 보관한다. 원본 CSV, 정상 결과 CSV, 전체 오류 보고서는 파일로 남긴다. DB에는 누가 제출했는지, 파일이 어디에 있는지, 작업 상태가 무엇인지, 언제 어떤 시도로 처리했는지와 같은 정보를 저장한다.

이처럼 데이터에 관한 설명을 메타데이터(metadata)라고 한다. 파일의 저장 키, 크기, 소유자, 생성 시각은 파일 내용 자체가 아니라 파일을 관리하기 위한 정보다. 결과 행을 하나씩 검색하는 기능이 지금 필요하지 않으므로 모든 CSV 행을 DB에 저장하지 않을 생각이다.

사용자가 요청한 하나의 검사를 ‘작업’으로, 실제로 처리한 한 번을 ‘시도’로 나누는 것도 중요하다. 서버 오류 때문에 재실행하면 같은 작업 아래 두 번째 시도가 생긴다. 첫 번째 실패 기록을 지워 버리면 무슨 문제가 있었는지 설명하기 어려워진다.

여기서 주의할 점은 파일 저장과 DB 저장이 자동으로 함께 성공하거나 취소되지는 않는다는 것이다. 결과 파일을 만드는 데 성공했지만 DB에 완료 상태를 기록하기 전에 서버가 종료될 수도 있다. 반대로 DB에 파일 경로가 있어도 실제 파일이 없어질 수 있다.

DB의 트랜잭션(transaction)은 여러 DB 변경을 하나의 처리 단위로 관리한다. 변경을 확정하는 것을 커밋(commit), 취소하는 것을 롤백(rollback)이라고 한다. 하지만 일반적인 DB 트랜잭션을 취소했다고 별도로 작성한 파일까지 자동으로 삭제되지는 않는다. MySQL의 커밋·롤백 설명

따라서 결과 파일은 임시 위치에 작성하고, 처리가 끝난 뒤 확정 위치로 옮기며, DB에도 결과 참조와 성공 상태를 함께 기록하는 방식으로 설계하려고 한다. 사용자에게는 성공 상태로 확정된 결과만 제공한다. 그 사이에 생긴 불필요한 파일을 어떻게 찾아 정리할지도 별도로 필요하다.

영속성은 모든 파일을 영원히 보관한다는 뜻은 아니다. 이번 서비스에서는 기본 7일 보관 정책을 두고, 실행 중인 작업은 삭제 대상에서 제외할 예정이다. 파일이 만료됐다는 상태와 검사가 실패했다는 상태도 구분해야 한다.

보안: 내 파일을 다른 사람이 볼 수 없어야 한다

보안(security)은 데이터와 기능을 허용되지 않은 접근이나 변경으로부터 보호하는 일이다. 파일 검사 서비스에서는 사용자가 제출한 파일과 결과가 다른 사용자에게 노출되지 않도록 하는 것이 중요한 책임이다.

인증(authentication)은 요청한 주체가 누구인지 확인하는 과정이다. 인가(authorization)는 확인된 주체가 특정 행동을 할 권한이 있는지 판단하는 과정이다. 로그인에 성공했더라도 다른 사용자의 파일을 내려받을 권한까지 얻는 것은 아니다.

사용자 A와 B가 각각 파일을 제출했다고 가정해 보자. B가 A의 작업 ID를 알아냈더라도 상세 정보와 결과 파일을 볼 수 없어야 한다. 재실행 요청 역시 차단해야 한다. 요청에 적힌 사용자 번호를 그대로 믿지 않고, 서버가 검증한 로그인 정보와 저장된 작업의 소유자를 비교해야 한다.

파일 자체도 확인해야 한다. 확장자가 .csv라고 해서 형식이 올바르거나 안전한 것은 아니다. 허용한 크기인지, 지원하는 형식으로 읽을 수 있는지 검사해야 한다. 사용자가 보낸 파일명을 저장 경로로 그대로 사용하지 않고, 서버가 만든 저장 키로 비공개 위치에 보관하는 방식을 사용할 예정이다. OWASP의 파일 업로드 보호 지침

결과를 CSV로 내려주는 과정에도 살펴볼 점이 있다. 자유 텍스트에 수식으로 해석되는 값이 들어 있으면 스프레드시트에서 파일을 열 때 원래 의도와 다르게 동작할 수 있다. 오류 보고서에 원본 값을 그대로 복사하는 경우도 마찬가지다.

다만 모든 값에 임의의 문자를 붙이면 다른 프로그램이 읽을 데이터까지 달라진다. 기계가 처리할 값과 사람이 볼 표시용 값을 구분하고, 어떤 프로그램에서 안전성을 확인했는지 기록해야 한다. 모든 스프레드시트와 재저장 방식에 통하는 만능 처리라고 가정하지 않으려고 한다. OWASP의 CSV Injection 설명

신뢰성: 오류가 있어도 결과의 의미는 정확해야 한다

신뢰성(reliability)은 정해진 조건에서 서비스가 기대한 기능을 일관되게 수행하는 성질이다. 이 프로젝트에서는 올바른 파일을 잘 처리하는 것과 함께, 잘못된 데이터나 서버 중단을 만났을 때 어떤 상태를 남기는지도 중요하다.

먼저 데이터 오류와 서버 장애를 구분해야 한다. 음수 수량을 찾아 오류 보고서에 남기는 것은 검증기가 해야 할 일을 수행한 결과다. 일부 행이 잘못되었더라도 검사가 끝났다면 ‘완료, 오류 있음’으로 표시할 수 있다. 데이터 행은 있는데 정상 행이 하나도 없는 경우도 여기에 포함한다.

반면 결과를 쓰다가 저장 장치 오류가 나거나 처리 도중 서버가 종료됐다면 검사를 정상적으로 끝내지 못한 것이다. 이런 상태를 완료로 표시하거나 미완성 결과를 내려주면 사용자는 잘못된 결과를 믿게 된다.

작업 상태는 다음처럼 구분할 예정이다.

FAILED라는 상태만 보고 모두 재실행해서는 안 된다. 날짜나 파일 구조가 잘못됐다면 같은 입력을 다시 처리해도 해결되지 않는다. 사용자가 파일을 수정해 새 작업으로 제출해야 한다. 서버 오류로 실패한 경우에만 같은 원본으로 다시 실행하도록 하고, 실패 원인 코드를 함께 남길 생각이다.

중복 요청도 신뢰성과 연결된다. 사용자가 업로드를 눌렀지만 응답을 받지 못해 다시 보냈다고 하자. 서버에서는 첫 번째 요청을 이미 접수했을 수 있다. 이때 요청마다 새 작업을 만들면 같은 제출 의도가 여러 작업으로 늘어난다.

이를 구분하기 위해 하나의 제출 의도에는 같은 요청 키를 사용한다. 같은 사용자·같은 키·같은 내용이면 기존 작업을 알려주고, 같은 키인데 내용이 바뀌었다면 충돌로 안내한다. 반대로 사용자가 의도적으로 새 작업을 만들었다면 파일이 같더라도 허용한다. 파일 내용이 같은 것과 요청이 중복된 것은 다른 문제다.

서버가 처리 중 종료된 경우에도 기준이 필요하다. 이번에는 한 애플리케이션과 한 워커로 범위를 제한하고, 완전히 종료된 뒤 재시작했을 때 남은 실행 중 작업을 실패로 정리하려고 한다. 이후 사용자가 새로운 시도로 전체 재실행할 수 있게 한다. 중간 레코드부터 이어서 처리하는 기능은 첫 목표에 넣지 않았다.

개발과 운영: 만든 기능을 계속 사용할 수 있게 하기

개발은 요구사항을 정리하고 코드를 작성하며 의도한 동작인지 검증하는 일이다. DataCheck에서는 정상 CSV 하나를 변환하는 것과 함께, 여러 오류가 있는 행이나 잘못된 헤더도 예상한 방식으로 처리하는지 확인해야 한다.

배포(deployment)는 만든 프로그램을 사용자가 접근하는 환경에 반영하는 일이다. 내 컴퓨터에서는 되던 기능도 파일 경로, DB 연결, 메모리 제한, 폴더 권한이 달라지면 동작하지 않을 수 있다. 실행 환경을 정리하고 배포한 뒤 실제 흐름을 확인하는 일도 필요하다.

운영(operations)은 제공 중인 서비스의 상태를 살피고 변경과 장애에 대응하는 일이다. 파일 검사 서비스에서는 대기 작업이 계속 쌓이지 않는지, 실패가 늘지 않는지, 보관 파일이 저장 공간을 모두 차지하지 않는지 살펴야 한다.

로그(log)는 프로그램에서 일어난 사건의 기록이다. 작업 ID, 시도 번호, 상태 변화, 오류 코드와 소요 시간을 남기면 특정 작업이 어디서 멈췄는지 추적할 수 있다. 원본 행 전체나 비밀번호까지 기록할 필요는 없다.

모니터링(monitoring)은 서비스 상태를 지속적으로 확인하는 활동이다. 작업 대기 수, 실패 수, 처리 시간, 사용 중인 저장 공간을 관찰하면 문제가 생겼는지 판단하는 데 도움이 된다. 모니터링할 값도 ‘있으면 좋아 보이는 수치’보다 실제로 어떤 조치를 결정하는 데 쓸지를 생각하며 고르려고 한다.

성능을 설명할 때도 측정이 필요하다. 파일을 접수하는 데 걸린 시간과 검사를 끝내는 데 걸린 시간을 따로 보고, 같은 데이터로 반복 측정해야 한다. 처음 설정한 20 MiB·10만 행 제한은 검증을 위한 초기 상한이며, 지금 그 규모를 충분히 처리한다고 확인한 수치는 아니다.

파일을 한꺼번에 읽지 않고 레코드 단위로 읽으면 메모리 부담을 줄일 수 있다. 그래도 중복 판정용 Set에는 고유 키가 남기 때문에 모든 메모리 사용이 일정해진다고 말할 수는 없다. 개선 결과도 실제로 측정한 조건과 함께 기록할 예정이다.

운영 책임에는 복구 가능한 범위를 설명하는 일도 포함된다. 영속 볼륨을 사용하면 앱을 다시 실행할 때 파일을 유지할 수 있지만, 그것만으로 저장 장치 장애에 대비한 백업까지 갖춘 것은 아니다. 이번 프로젝트에서 확인한 재시작 복구와 아직 보장하지 못하는 상황을 구분해야 한다.

백엔드 개발자 한 사람이 모든 인프라와 보안을 혼자 담당한다는 뜻은 아니다. 팀마다 역할은 다르다. 다만 내가 만든 코드가 어디에 상태를 남기고, 어떤 조건에서 실패하며, 운영 중 무엇을 확인해야 하는지는 이해할 필요가 있다.

이 서비스에서 나눠야 할 책임

이 표를 정리하면서, 파일을 바꾸는 규칙 외에도 정해야 할 약속이 많다는 것을 알게 됐다. 상태와 응답의 의미를 정하는 일도 구현의 일부다.

알고리즘 공부와 어떻게 이어질까?

알고리즘 문제에서는 정해진 입력 조건 안에서 정확하고 효율적인 결과를 구하는 데 집중한다. DataCheck에서도 자료구조와 시간 복잡도는 필요하다. 중복 키를 찾는 Set, 결과를 순서대로 처리하는 방식, 데이터 크기에 따른 메모리 사용량이 지금까지 공부한 내용과 연결된다.

여기에 서비스에서는 입력 형식이 잘못될 수 있고, 같은 요청이 동시에 들어올 수 있으며, 실행이 끝난 뒤에도 파일과 이력이 남아야 한다는 조건이 붙는다. 결과 계산뿐 아니라 그 결과를 누가 보고, 언제 공개하며, 실패하면 무엇을 남길지도 정해야 한다.

앞으로 기능을 하나 만들 때마다 ‘정답이 나오는가’와 함께 ‘이 요청을 허용해도 되는가’, ‘데이터가 어디에 남는가’, ‘중간에 멈추면 어떤 상태가 되는가’를 확인하려고 한다.

이번 글에서 정리한 것

백엔드 개발에는 요청을 처리하는 코드와 함께, 무엇을 정상으로 볼지, 데이터를 어디에 남길지, 실패했을 때 사용자에게 무엇을 알려줄지 정하는 일도 포함된다. 이번 프로젝트에서는 이 책임을 파일 하나가 들어와 결과로 나가는 흐름 안에서 직접 확인해 보려고 한다.

다음 글에서는 먼저 Spring 없이 Java로 검증기를 만들 예정이다. 한 행의 데이터와 오류를 어떤 객체로 표현할지, 첫 정상 행을 기억하려면 어떤 키를 Set에 넣어야 할지, 오류 항목 수와 오류 행 수를 어떻게 구분할지부터 살펴보려고 한다.

이 입력에서 숫자 5를 불러오려면... 그러니까 입력을 먼저 받아야 하는데...... 입력... 입력을 어떻게 받지??????

알고리즘 공부하지 2개월 넘어가는데 입력에서 막혔다. next랑 nextline 차이가 뭐더라?

ㅎㅎ

~ 그래서 시작하는 입력부터 다시 공부하는 알고리즘 세상 ~

이 포스트는 아직도 scanner를 사용해 입력을 받는 나를 위해 쓰였다.

자바 알고리즘 입출력, 입력 형태별로 익히기

알고리즘 문제에는 숫자, 문자열, 격자, 명령어처럼 다양한 입력이 나온다. 입력 코드를 쓸 때는 데이터를 어떤 단위로 읽을지부터 정하자.

• 공백으로 구분된 값 하나는 토큰 단위로 읽는다.
• 공백을 포함한 문장은 줄 단위로 읽는다.
• 붙어 있는 숫자나 문자는 문자열로 읽은 뒤 문자별로 나눈다.

이 기준을 바탕으로 Scanner의 기본 동작부터 자주 나오는 입력 유형, BufferedReader와 출력 방법까지 살펴보자.

1. 입력 단위와 Scanner 기본 설정

입력 예시를 보면 먼저 공백과 줄바꿈이 어떤 역할을 하는지 살펴보자. 아래는 기본 구분자 설정을 쓰는 Scanner 기준이다.

숫자처럼 보여도 00123의 앞자리 0이나 각 자릿수가 필요하다면 문자열로 읽는다. 입력량이 많을 때는 시간 제한도 함께 보고 BufferedReader 사용을 고려한다.

Scanner 기본 코드

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();

        System.out.println(n);
    }
}

이후의 Scanner 예제는 다음 객체가 생성되어 있다고 가정한다.

Scanner sc = new Scanner(System.in);

각 예제는 별개의 입력을 기준으로 작성했다.

2. next(), nextInt(), nextLine()의 차이

중요!!

next()와 nextInt()는 토큰 하나, nextLine()은 현재 위치부터 줄 끝까지 읽는다. 토큰은 기본적으로 공백이나 줄바꿈으로 구분되는 값이다.

hello java world를 next()로 읽으면 "hello"만 가져온다. 다음 두 번의 호출에서 "java", "world"를 읽는다. 같은 입력을 처음부터 nextLine()으로 읽으면 한 줄 전체를 가져온다.

String line = sc.nextLine(); // "hello java world"

nextLine()은 마지막 줄바꿈도 소비하지만, 반환하는 문자열에는 줄바꿈을 넣지 않는다.

nextInt()끼리는 줄바꿈을 신경 쓰지 않아도 된다

int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();

이 코드는 5 6 7이 한 줄에 있든, 숫자마다 줄이 바뀌든 똑같이 읽는다. 숫자 뒤의 줄바꿈은 남지만 다음 nextInt()가 건너뛰기 때문이다.

nextLine()으로 바꿀 때는 현재 위치를 확인하자

3
123
456
789

int n = sc.nextInt();       // 3
String row = sc.nextLine(); // ""

3을 읽은 직후에는 줄바꿈이 남아 있다. nextLine()은 그 자리에서 바로 줄바꿈을 만나므로 빈 문자열을 반환한다. 다음 줄을 읽으려면 현재 줄의 나머지를 먼저 소비한다.

int n = sc.nextInt();
sc.nextLine(); // 첫 줄의 나머지와 줄바꿈 소비
String row = sc.nextLine(); // "123"

숫자 다음에 무조건 nextLine()을 넣는 것은 아니다. 다음에 읽을 데이터가 어느 줄에 있는지 보고 결정한다.

국룰 조합은

1. nextInt()+nextLine()+nextLine()
2. nextInt()+next()

3. 정수 N개, 큰 정수와 실수 읽기

배열이나 정렬 문제에서는 먼저 개수 N을 읽고, 그만큼 반복해서 값을 받으면 된다.

5
10 20 30 40 50

int n = sc.nextInt();
int[] arr = new int[n];

for (int i = 0; i < n; i++) {
    arr[i] = sc.nextInt();
}

숫자가 여러 줄에 나뉘어 있어도 같은 코드로 읽는다. 각 값의 줄 위치보다 정수 N개를 순서대로 읽는 것이 중요한 경우에 쓴다.

큰 정수와 실수

long value = sc.nextLong();
double ratio = sc.nextDouble();

int의 범위를 넘는 정수는 처음부터 long으로 읽어야 한다.

long value = sc.nextInt(); // 입력이 int 범위를 넘으면 읽는 단계에서 오류

저장 변수가 long이어도 nextInt()가 읽을 수 있는 범위는 달라지지 않는다.

4. 문자 하나와 문자열 읽기

문자 하나

Scanner에는 nextChar()가 없다. 문자 하나는 문자열로 읽고 첫 문자를 꺼낸다.

char ch = sc.next().charAt(0); // 입력이 A라면 'A'

주의할 점은 next()가 토큰 전체를 읽는다는 것이다. 입력이 ABC라면 "ABC"를 모두 읽은 뒤 'A'만 꺼낸다. 다음 next()로 B를 읽을 수는 없다.

붙어 있는 문자

ABCDE처럼 문자가 붙어 있으면 문자열을 한 번 읽고 각 위치에 접근한다. 문자열 탐색이나 괄호 검사에서 자주 쓰는 방식이다.

String word = sc.next();
for (int i = 0; i < word.length(); i++) {
    char ch = word.charAt(i);
    System.out.println(ch);
}

입력이 ABCDE라면 A부터 E까지 한 줄에 하나씩 출력된다. 문자 배열이 필요하면 toCharArray()로 바꾼다.

char[] letters = sc.next().toCharArray();

문자열을 그대로 두고 위치별로 확인할 때는 charAt(i), 배열의 문자를 직접 바꿔야 할 때는 toCharArray()가 편하다.

자바의 char는 UTF-16 코드 단위다. 영문과 숫자 중심의 입력에서는 위처럼 처리하지만, 일부 이모지는 화면의 한 글자가 char 두 개로 표현될 수 있다.

공백으로 구분된 문자

5
A B C D E

int n = sc.nextInt();
char[] arr = new char[n];

for (int i = 0; i < n; i++) {
    arr[i] = sc.next().charAt(0);
}

각 문자가 별도의 토큰이므로 next()를 반복한다. ABCDE는 한 번 읽고 나누지만, A B C D E는 다섯 번 읽는다.

5. 공백을 포함한 문장 읽기

공백을 포함한 문장은 nextLine()으로 읽는다. hello java world를 next()로 읽으면 "hello"까지만 가져온다.

정수 다음에 문장 여러 줄이 오는 경우

2
hello java
nice to meet you

int n = sc.nextInt();
sc.nextLine(); // n이 있는 줄의 나머지 소비

String[] sentences = new String[n];
for (int i = 0; i < n; i++) {
    sentences[i] = sc.nextLine();
}

현재 줄을 비우는 nextLine()은 반복문 전에 한 번만 호출한다. 문장 안의 공백은 그대로 남으므로 charAt(i)로 접근하면 공백도 하나의 문자로 읽힌다.

숫자와 문장이 같은 줄에 있는 경우

20 Kim Jinsol

int age = sc.nextInt();
String name = sc.nextLine().trim(); // "Kim Jinsol"

이때는 현재 줄의 나머지가 이름이다. nextLine()을 호출하고 반환값을 버리면 이름도 버리게 된다. trim()은 양끝 공백이 필요 없을 때만 쓴다.

6. 붙어 있는 숫자를 한 자리씩 처리하기

숫자의 합이나 각 자릿수 검사 문제에서 사용하는 방식이다.

54321

String number = sc.next();
int sum = 0;

for (int i = 0; i < number.length(); i++) {
    sum += number.charAt(i) - '0';
}

System.out.println(sum); // 15

charAt(i)의 반환값은 숫자가 아니라 문자이다.

char ch = '5';

int a = ch;       // 53: 문자 '5'의 코드값
int b = ch - '0'; // 5

'0'부터 '9'까지의 코드값이 연속되어 있으므로 '0'을 빼면 해당 정수가 된다.

00123을 정수로 읽으면 123이 되어 앞의 0이 사라진다. 앞자리 0이나 원래 자릿수가 필요하면 next()로 문자열을 읽는다. 계산할 숫자 전체가 필요한지, 각 자릿수가 필요한지 구분하자.

7. 격자 입력 세 가지

공백 없는 숫자 격자

미로, 농작물 수확 등 각 칸이 한 자리 숫자로 주어지는 문제의 입력 형태이다.

3
123
456
789

next() 사용

int n = sc.nextInt();
int[][] map = new int[n][n];

for (int r = 0; r < n; r++) {
    String row = sc.next();

    for (int c = 0; c < n; c++) {
        map[r][c] = row.charAt(c) - '0';
    }
}

한 행을 문자열로 읽고 각 문자를 숫자로 바꾼다. 첫 행 123은 배열에 1, 2, 3으로 저장된다.

nextLine()으로 행을 읽어도 되지만, 그때는 nextInt() 다음에 첫 줄의 나머지를 소비해야 한다. 이를 빠뜨려 첫 row가 빈 문자열이 되면 row.charAt(0)에서 예외가 발생한다.

공백 있는 숫자 격자

2 3
10 20 30
40 50 60

int n = sc.nextInt(); // 행
int m = sc.nextInt(); // 열

int[][] map = new int[n][m];

for (int r = 0; r < n; r++) {
    for (int c = 0; c < m; c++) {
        map[r][c] = sc.nextInt();
    }
}

각 값이 공백으로 구분되어 있으므로 정수 단위로 읽으면 된다.

두 자리 숫자나 음수가 있어도 같은 방식이다.

-10 200 3

charAt(c) - '0'은 한 자리 숫자 문자를 변환하는 방법이므로, 이런 입력에는 사용할 수 없다.

문자 격자

탐색 문제에서 이동 가능한 칸과 벽을 문자로 구분하는 경우이다.

3 4
S..#
.#..
...E

int n = sc.nextInt();
int m = sc.nextInt();

char[][] map = new char[n][m];

for (int r = 0; r < n; r++) {
    map[r] = sc.next().toCharArray();
}

읽은 뒤에는 문자로 비교한다.

if (map[r][c] == '#') {
    // 벽
}

if (map[r][c] == 'E') {
    // 도착점
}

문자 char는 작은따옴표를 사용한다.

'#'   // char
"#"   // String

이 코드는 각 행에 공백 없이 정확히 m개의 문자가 주어진다는 조건을 전제로 한다.

공백 자체가 격자의 한 칸이라면 nextLine()으로 읽고 공백을 보존해야 한다.

8. 그래프와 명령어 입력

그래프의 간선

4 3
1 2
2 3
2 4

정점 4개, 간선 3개인 무방향 그래프라고 가정한다.

int n = sc.nextInt();
int m = sc.nextInt();

List<List<Integer>> graph = new ArrayList<>();

for (int i = 0; i <= n; i++) {
    graph.add(new ArrayList<>());
}

for (int i = 0; i < m; i++) {
    int a = sc.nextInt();
    int b = sc.nextInt();

    graph.get(a).add(b);
    graph.get(b).add(a);
}

필요한 import:

import java.util.ArrayList;
import java.util.List;

무방향 그래프이므로 양쪽에 저장한다. 방향 그래프라면 문제에서 지정한 방향으로만 저장한다.

입력에서 확인할 부분은 다음과 같다.

• 정점 번호가 0부터인지 1부터인지
• 간선이 단방향인지 양방향인지
• 가중치가 추가로 주어지는지

가중치가 있다면 간선 하나당 정수 세 개를 읽는다.

int from = sc.nextInt();
int to = sc.nextInt();
int weight = sc.nextInt();

명령어마다 입력 개수가 다른 경우

스택이나 큐 구현 문제에서 자주 나오는 형태이다.

4
push 3
push 5
pop
size

명령어에 따라 필요한 값만 추가로 읽을 수 있다.

int n = sc.nextInt();

for (int i = 0; i < n; i++) {
    String command = sc.next();

    if (command.equals("push")) {
        int value = sc.nextInt();

        // value 추가
    } else if (command.equals("pop")) {
        // 값 꺼내기
    } else if (command.equals("size")) {
        // 크기 확인
    }
}

문자열 내용은 equals()로 비교한다. push처럼 값이 뒤따르는 명령만 추가로 정수를 읽으면 된다.

한 줄에 명령 하나가 주어진다면 nextLine()으로 읽고 StringTokenizer로 나눠도 된다. 다만 인수가 공백을 포함한 문장이라면 필요한 공백까지 사라지지 않도록 처리해야 한다.

9. 테스트 케이스와 입력 종료 조건

테스트 케이스가 여러 개인 경우

2
3
1 2 3
2
10 20

첫 번째 값이 테스트 케이스 개수 T인 경우이다.

int t = sc.nextInt();

for (int tc = 1; tc <= t; tc++) {
    int n = sc.nextInt();
    int sum = 0;

    for (int i = 0; i < n; i++) {
        sum += sc.nextInt();
    }

    System.out.println("#" + tc + " " + sum);
}

위 코드의 출력:

#1 6
#2 30

#테스트번호 정답 형식은 문제에서 요구할 때만 사용한다.

케이스마다 초기화하고 입력은 끝까지 읽기

합계, 정답, 방문 배열처럼 케이스마다 새로 계산할 값은 바깥 반복문 안에서 초기화한다.

판정이 끝났다고 입력 반복문을 break로 빠져나오면 아직 읽지 않은 값이 다음 케이스로 넘어갈 수 있다. 추가 검사는 생략하더라도 정해진 입력은 모두 읽어야 한다.

boolean valid = true;

for (int i = 0; i < n; i++) {
    int value = sc.nextInt();

    if (!valid) {
        continue;
    }

    if (value < 0) {
        valid = false;
    }
}

EOF 또는 특정 값까지 읽기

EOF까지 정수 읽기

EOF는 입력이 끝났다는 의미이다.

while (sc.hasNextInt()) {
    int value = sc.nextInt();

    System.out.println(value);
}

정수로만 구성된 입력을 끝까지 읽는 방식이다. 정수가 아닌 토큰을 만나도 반복이 끝나므로 입력 조건을 확인해야 한다.

EOF까지 줄 읽기

while (sc.hasNextLine()) {
    String line = sc.nextLine();

    System.out.println(line);
}

빈 줄도 하나의 줄로 읽는다.

특정 값이 나오면 종료

3
5
7
0

0이 종료 조건인 경우:

while (sc.hasNextInt()) {
    int value = sc.nextInt();

    if (value == 0) {
        break;
    }

    // value 처리
}

종료 값은 문제에서 정해 준 경우에만 사용한다.

10. BufferedReader와 StringTokenizer

입력량이 많은 문제에서는 BufferedReader와 StringTokenizer를 함께 사용하는 경우가 많다.

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

기본 설정:

BufferedReader br =
        new BufferedReader(new InputStreamReader(System.in));

정수 하나가 한 줄에 있는 경우

5

int n = Integer.parseInt(br.readLine().trim());

readLine()은 문자열을 반환하므로 숫자로 사용하려면 변환이 필요하다.

long value = Long.parseLong(br.readLine().trim());
double ratio = Double.parseDouble(br.readLine().trim());

한 줄에 정수 여러 개가 있는 경우

10 20 30

StringTokenizer st = new StringTokenizer(br.readLine());

int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
int c = Integer.parseInt(st.nextToken());

readLine()은 한 줄을 읽고, StringTokenizer는 그 문자열을 나눈다. nextToken()의 반환값도 문자열이므로 Integer.parseInt()로 정수로 바꾼다.

StringTokenizer는 다음 줄을 읽지 않는다

10 20
30

StringTokenizer st = new StringTokenizer(br.readLine());

int a = Integer.parseInt(st.nextToken()); // 10
int b = Integer.parseInt(st.nextToken()); // 20
int c = Integer.parseInt(st.nextToken()); // 예외 발생

st에 들어 있는 내용은 첫 줄 "10 20"뿐이다.

다음 줄까지 읽으려면 br.readLine()을 다시 호출해야 한다.

Scanner.nextInt()처럼 자동으로 다음 줄의 값을 읽어 주는 것은 아니다.

격자에 적용하기

공백 있는 정수 격자는 행마다 new StringTokenizer(br.readLine())를 만들고, 열 개수만큼 Integer.parseInt(st.nextToken())을 반복한다. 각 행의 값이 한 줄에 주어진다는 조건에서 쓴다.

공백 없는 숫자 격자는 각 행을 br.readLine()으로 읽고 row.charAt(c) - '0'으로 변환한다. 첫 줄의 크기도 readLine()으로 읽었다면 줄바꿈을 소비하려고 한 번 더 호출할 필요는 없다.

EOF까지 읽기

String line;

while ((line = br.readLine()) != null) {
    // line 처리
}

빈 줄과 EOF는 다르다.

공백 분리와 split()

String line = "10  20   30";

split(" ") 사용 시 주의

String[] tokens = line.split(" ");

공백 하나를 기준으로 분리하기 때문에, 연속된 공백 사이에 빈 문자열이 생길 수 있다.

공백 개수가 일정하지 않다면 다음과 같이 작성할 수 있다.

String[] tokens = line.trim().split("\\s+");

\\s+는 하나 이상의 공백 문자에 대응한다.

단, 빈 줄은 별도로 처리해야 한다.

StringTokenizer 사용

StringTokenizer st = new StringTokenizer(line);

while (st.hasMoreTokens()) {
    int value = Integer.parseInt(st.nextToken());
}

기본 설정에서는 연속된 공백을 건너뛰고 토큰을 읽는다.

숫자 토큰만 필요하면 StringTokenizer, 문장과 공백 자체가 필요하면 원래 문자열을 유지하는 방식이 적합하다.

입력을 직접 한 문자씩 읽는 경우

BufferedReader.read()로 입력 스트림에서 문자 단위로 읽을 수도 있다. 반환형은 입력 종료 값 -1을 표현하기 위해 int다. 공백과 줄바꿈도 읽히므로 줄바꿈 형식에 따라 '\r', '\n'을 처리해야 할 수 있다.

단순히 문자열의 각 문자를 확인하려면 charAt()이 간단하다. System.in.read()는 바이트를 읽으므로 한글을 그대로 char로 변환하는 용도로 쓰면 안 된다.

11. 출력 형식과 버퍼 사용

print()는 줄바꿈 없이 출력하고, println()은 출력 후 줄을 바꾼다. 공백은 직접 넣어야 한다.

System.out.print(10);
System.out.print(20); // 두 호출의 결과: 1020

10 20으로 출력하려면 다음처럼 쓴다.

System.out.println(10 + " " + 20);

출력 형식을 지정할 때는 printf()를 쓴다.

System.out.printf("%d %s%n", 10, "java"); // 10 java 출력 후 줄바꿈

System.out.printf(java.util.Locale.US, "%.2f%n", 3.14159); // 3.14

Locale.US를 지정하면 소수점 구분자로 .을 사용한다. 소수 자릿수와 줄바꿈은 문제의 출력 조건에 맞춘다.

배열 출력

배열을 System.out.println(arr)로 출력하면 원소가 나열되지 않는다. 디버깅할 때는 Arrays.toString()이 편하다.

import java.util.Arrays;

int[] arr = {1, 2, 3};
System.out.println(Arrays.toString(arr)); // [1, 2, 3]

다만 문제에서 1 2 3을 요구한다면 대괄호와 쉼표를 빼고 공백으로 구분해야 한다. 아래 StringBuilder 예제처럼 구분자를 직접 넣자. 디버깅용 출력과 제출용 출력은 다를 수 있다.

출력이 많다면 StringBuilder

출력할 내용이 많으면 StringBuilder에 모아서 한 번에 출력할 수 있다. 문자열을 반복해서 +=로 연결하는 것보다 많은 결과를 모으는 데 적합하다.

StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
    sb.append(i).append('\n');
}
System.out.print(sb);

위 코드는 1부터 5까지 한 줄에 하나씩 출력한다. 배열을 공백으로 구분해 출력할 때도 같은 방식이다.

StringBuilder sb = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
    if (i > 0) {
        sb.append(' ');
    }
    sb.append(arr[i]);
}
sb.append('\n');
System.out.print(sb);

첫 원소 앞에는 공백을 넣지 않고, 두 번째 원소부터 앞에 공백을 붙인다. 결과 전체를 메모리에 저장하므로 출력이 매우 크다면 나누어 출력하거나 BufferedWriter를 쓴다.

BufferedWriter

import java.io.BufferedWriter;
import java.io.OutputStreamWriter;

BufferedWriter bw =
        new BufferedWriter(new OutputStreamWriter(System.out));

bw.write("hello");
bw.newLine();

bw.write(String.valueOf(123));
bw.newLine();

bw.flush();

정수 출력 시 주의

bw.write(65);

위 코드는 문자열 "65"를 출력하지 않는다. 문자 코드에 해당하는 'A'를 출력한다.

숫자 자체를 출력하려면 문자열로 변환한다.

bw.write(String.valueOf(65)); // "65"

마지막에는 flush()로 버퍼에 남은 내용을 출력한다.

12. 입력량이 많은 문제의 기본 코드

아래 코드는 공백이나 줄바꿈으로 구분된 정수를 읽어 합을 출력한다.

입력:

5
10 20 30 40 50

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class Main {
    static BufferedReader br =
            new BufferedReader(new InputStreamReader(System.in));

    static StringTokenizer st;

    static String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = br.readLine();

            if (line == null) {
                return null;
            }

            st = new StringTokenizer(line);
        }

        return st.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public static void main(String[] args) throws IOException {
        int n = nextInt();
        long sum = 0;

        for (int i = 0; i < n; i++) {
            sum += nextInt();
        }

        System.out.println(sum);
    }
}

next()는 현재 줄에 토큰이 남아 있으면 하나를 반환하고, 없으면 다음 줄을 읽는다. 그래서 숫자가 여러 줄에 나뉘어 있어도 처리할 수 있다.

이 코드의 nextInt()는 필요한 정수가 입력에 존재한다고 가정한다. 줄 경계와 빈 줄도 건너뛰므로 문장이나 공백 자체가 중요한 입력에는 맞지 않는다.

13. 자주 하는 실수와 제출 전 확인

문제를 읽으며 확인할 것

입력 코드를 쓰기 전에 다음을 확인해 두자.

1. 입력 개수나 종료 조건이 N, T, 특정 값, EOF 중 무엇인가?
2. 공백과 줄바꿈은 구분자인가, 데이터의 일부인가?
3. 숫자 전체가 필요한가, 각 자릿수와 원래 형태가 필요한가?
4. 격자 한 칸은 한 문자인가, 여러 자리 정수인가?
5. 입력값이나 계산 결과가 int 범위를 넘을 수 있는가?
6. 입력·출력량과 시간 제한에 맞는 방식을 골랐는가?
7. 공백, 줄바꿈, 테스트 번호, 소수 자릿수 등 출력 조건을 확인했는가?

입력이 꼬이면 지금 어디까지 읽었는지부터 확인하자. 토큰을 읽다가 줄 단위로 바꾼 지점이나, 아직 읽지 않은 값이 남은 반복문을 살펴보면 원인을 찾기 쉽다.

요약

이번에 확실히 이해한 건 숫자를 읽은 뒤 문자열을 읽을 때, next()와 nextLine()의 동작이 다르다는 점이다.

nextInt()로 첫 숫자를 읽고 나면 줄바꿈이 남는다. 이후 next()는 입력 전 앞의 공백을 먹으므로 바로 다음 문자열을 읽지만, nextLine()은 남은 줄바꿈부터 처리한다!

다시 처음으로 돌아가서

입력으로 다음 숫자가 주어진다. 3 123 456 789

이 입력에서 숫자 5를 읽으려면...

nextInt() + next()로 읽거나, nextInt() + nextLine()으로 현재 줄을 비운 뒤 + nextLine()으로 다음 줄을 읽어야 한다.

입력이 헷갈릴 때는 어떤 메서드를 쓰는지와 함께 현재 어디까지 읽었는지를 확인하기.

기업에서 요구하는 백엔드 개발자의 여건을 모아보자

짐싸 ＜백엔드팀 ​소개＞ • 백엔드팀은 100만 명 이상의 사용자와 수천 명의 파트너가 이용하는 플랫폼 서비스를 안정적으로 운영하며, 기술을 통해 더 나은 사용자 경험을 제공합니다. • 단순한 기능 구현을 넘어 서비스의 확장성과 안정성을 위한 기반 기술을 설계하고, 서버 아키텍처를 직접 운영하며 성능을 최적화하고 있습니다. • 고객–파트너 간 복잡한 매칭 로직과 비동기 처리 등 다양한 기술 과제를 해결하며, 디지털 전환이 더딘 3조 원 규모의 이사 시장을 혁신하고 있습니다. • 백엔드팀은 서비스의 성장을 이끌고 그 속도를 앞서가는 팀입니다.

＜포지션 소개＞ • 짐싸의 비전을 이해하고 서비스의 신뢰성, 안정성, 확장성을 책임질 수 있는 백엔드 시스템을 개발합니다. • 인프라, DB 관리, API 개발 등 핵심적인 역할을 수행하며, 팀원들과 기술적 이슈에 대한 고민을 함께 해결해나갑니다. 주요업무 • 높은 가용성과 확장성을 가지도록 짐싸 백엔드 시스템 개발 및 개선 • 요구사항 분석 및 테스트를 통한 RESTful API 구축 • 서비스의 성능을 위한 애플리케이션 최적화 • 클라우드 환경에서의 서버 운영 자격요건 • AI 도구·AI 에이전트를 활용해 보신 분 • Spring Boot(Java), JPA를 활용한 프로젝트 경험이 있거나 이에 준하는 개발 역량을 갖추신 분 • DB(RDB, NoSQL) 테이블 설계가 가능하신 분 • 새로운 기술을 두려워하지 않고 도전하며 이를 동료에게 공유하는 것을 즐기시는 분 • 컴퓨터 공학 전공 혹은 이에 준하는 지식 및 활용 역량이 있으신 분 • 해외여행에 결격사유가 없는 분 (남성의 경우, 병역필 또는 면제자)

여기어때

자격요건

• 대용량 트래픽 처리를 위한 시스템 설계 경험이 있는 분 • 논리적이고 체계적인 문제 해결 능력과 커뮤니케이션 능력을 보유한 분 • Java(Kotlin) Spring 기반 대규모 애플리케이션 개발 및 운영 경험이 있는 분 • JPA, Hibernate 등 ORM 사용과 도메인 모델링 경험이 있는 분 • AWS 클라우드 환경(EKS, RDS, ElastiCache) 기반의 인프라 설계 및 운영 경험이 있는 분

위버스 컴퍼니 주요업무 • 커뮤니티, 멤버십, 커머스 전반을 아우르는 다양한 요구사항을 백엔드 구조로 구현하고 서비스에 반영합니다. • 유료 멤버십, 구독형 디지털 상품, 쿠폰/투표/설문 등 주요 기능을 개발하고 운영 효율을 개선합니다. • 전시, 상품, 주문, 클레임, 물류 등 커머스 도메인의 기능을 고도화하고 서비스 간 연계를 설계합니다. • 서비스 이용 과정에서 발생하는 이슈를 분석하고, 안정적인 운영을 위한 개선 작업을 수행합니다. • 사용자 데이터 및 VOC를 기반으로 서비스 품질을 점검하고 개선 방향을 도출합니다.

[주요 업무 환경] • 아티스트의 활동 및 프로젝트 일정에 따른 업무 집중 시기가 있을 수 있습니다. 자격요건 • Java 또는 Kotlin 기반으로 백엔드 개발 경험이 있거나, 이에 대한 기본적인 이해를 갖춘 분 • Spring Framework 기반 웹서비스 구조에 대한 이해 또는 개발 경험이 있는 분 • RESTful API 설계 및 개발에 대한 이해 또는 경험이 있는 분 • 데이터베이스(RDBMS 등)를 활용한 데이터 처리 및 모델링에 대한 이해가 있는 분 • Git 등 형상관리 도구 사용 경험 또는 협업 방식에 대한 이해가 있는 분 • 새로운 기술이나 환경에 대해 스스로 학습하고 적용해 보려는 의지가 있는 분 • 문제를 정의하고 해결해 보고자 하는 태도를 갖춘 분 • 다양한 직군과 협업하며 원활하게 커뮤니케이션할 수 있는 분

[위버스 백엔드 엔지니어가 사용/활용하는 기술] • 커뮤니티 : Java, Spring, Redis, Kafka (실시간 데이터 및 사용자 인터랙션 처리) • 프로모션 : Java, Spring, Kafka 기반 이벤트 처리, AWS 등 Cloud 환경 • 멤버십/구독 : Java 또는 Kotlin, Spring, 인증/권한 및 사용자 상태 관리, 외부 시스템 연동(API) • 커머스 : Java 또는 Kotlin, Spring, JPA, MySQL 등 RDBMS, Redis, Kafka

드림어스 주요업무 • 미디어 자동 입수 파이프라인 시스템 구축: 미디어 데이터가 유입되는 첫 단계인 대용량 자동 수집(입수) 파이프라인 시스템을 설계하고 개발합니다. • 미디어 트랜스코딩 고도화: 수집된 다양한 원본 미디어 데이터를 표준 규격으로 통합(Unification)하고, 다양한 디바이스와 네트워크 환경에 맞춰 최적화하는 트랜스코딩 시스템을 고도화 합니다. • 스트리밍 서비스 연동: 최적화된 미디어 파일이 실제 유저에게 효율적으로 제공될 수 있도록 스트리밍 서비스를 제공 합니다. • 백오피스 개발 및 운영: 음원/음반 유통망 시스템, 콘텐츠 관리 시스템, 대규모 작업을 위한 운영 포털 시스템을 개발하고 운영합니다. 자격요건 • Java, Kotlin, Golang 중 하나의 언어로 프로젝트를 완성해 본 경험 (학교 과제, 개인/팀 프로젝트, 인턴 등 형태 무관) • HTTP와 REST의 기본 동작 원리를 이해하고, 간단한 API 서버를 만들어 본 경험 • 관계형 데이터베이스(RDBMS)와 SQL에 대한 기본 이해 • 자료구조, 운영체제, 네트워크 등 CS 기초 지식

버즈빌 자격요건 "광고 도메인 경험이 없어도 괜찮습니다! 문제를 탐구하고 해결하는 태도가 더 중요합니다."

• Kotlin, Go, Python 등 하나 이상의 서버 프로그래밍 언어로 백엔드 시스템을 개발해 본 분 (실무 경력이 짧더라도 프로젝트 등으로 역량을 보여줄 수 있다면 충분합니다.) • MySQL 등 관계형 데이터베이스와 Redis, DynamoDB 등 NoSQL 저장소를 활용해 본 분 • 외부 시스템과의 API 연동을 설계하고 개발해 본 경험이 있는 분 • 백엔드에 한정하지 않고, 제품에 필요하다면 프론트엔드 등 다른 기술 영역으로 확장하는 데 열려 있는 분 • 다양한 직군과 원활하게 소통하고 협업할 수 있는 분 • AI 도구를 적극적으로 도입하고, 이를 통해 생산성을 극대화할 수 있는 역량을 갖추신 분

독특했던 채용 설명...

쏘카

자격요건

[백엔드·프론트엔드 어느 한 축은 프로덕션 수준으로 단단한 분] • 좋은 설계와 나쁜 설계를 자기 기준으로 판단할 수 있는 분 [기능 정의 단계부터 함께 고민해본 경험이 있는 분] • 요구사항을 받아서 구현하는 사람이 아니라, ‘무엇을 왜 만들어야 하는가’를 PM.디자이너와 함께 결정해본 분 [AI 에이전트를 업무에 깊이 통합해본 분] • 단순히 'AI를 써봤다' 수준이 아니라, Agentic Coding Agent(Claude Code, Cursor 등)의 작동 방식·강점·한계를 체득하고 자기 워크플로우의 일부로 만든 분 • AI 없이 일하던 방식으로 돌아가는 것이 부자연스럽게 느껴지는 분 [자기 일을 결과로 설명할 수 있는 분] • "구현했습니다"가 아니라 "이 문제를 해결했고 어떤 결과를 만들었습니다"로 자기 일을 말할 수 있는 분

우대사항

• 제품 개발 경험 3년 이상 • 모빌리티·주차·오프라인·결제·실시간 트랜잭션 등 복잡한 도메인에서 서비스를 개발해본 경험 • 기존 방식을 의심하고 새로 시도해본 경험.

• 팀이 일하는 방식, 시스템이 작동하는 방식, 시장이 굴러가는 방식을 다르게 제안하고 실제로 바꿔본 분 • AI Native 조직 만들기에 동참하고 싶은 분.
• SOCAR를 "AI 없이는 작동하지 않는 회사"로 함께 바꿔가는 여정에 흥미를 느끼는 분 • 스타트업 또는 사내 스타트업 환경에서 0 ＞ 1 제품 출시 경험

전체적으로는...

공통적으로 요구하는 역량

Java/Kotlin + Spring 기반 서버 개발 REST API 설계 및 개발 RDBMS·SQL·데이터 모델링, JPA/ORM 활용 자료구조·운영체제·네트워크 등 CS 기초 Redis, Kafka, NoSQL 등 대용량·비동기 처리 기술 AWS 등 클라우드 환경에서의 운영 경험 단순 구현보다 성능·안정성·확장성까지 고려하는 설계 협업, 문제 정의, 자기주도적 학습 및 기술 공유 능력 +) AI 활용 능력에 대한 이야기도 자주 보임

현재 기업들이 원하는 개발자는?

_문제 정의 → 설계 → 개발 → 테스트 → 배포 → 운영 → 성능 개선 _까지 책임지는 Software Engineer에 가까운 백엔드 개발자같다는 생각을 했다. 단순히 무엇을 구현했는지보다는 왜 만들었는지, 어떤 문제를 해결했는지, 어떤 결과를 만들었는지를 더 중요하게 보는 듯. 이건 예전에는 없던 새로운 경향이라고 하기엔 무리가 있지만, 기업에서 원하는 것이 단순한 백엔드 업무만 가능한 개발자가 아니라는 것이 더 명확해 보인다.

GPT의 제안...

앞으로 백엔드 개발자를 준비한다면 우선순위는 Java → Spring Boot → REST API → DB/SQL/JPA → CS → Redis/Kafka → AWS/Docker 순으로 기본기를 쌓는 것이 좋습니다. 그리고 프로젝트에서도 단순 CRUD에서 끝내지 않고 트래픽, 비동기 처리, 캐시, 장애 대응, 성능 개선, AI 활용까지 한두 가지라도 직접 경험해 보는 것이 중요합니다.

그렇단다

어떤 기술 하나를 진득하게 깊게 아는 것도 중요하지만 여러 경험을 해보는 것도 그만큼 중요하다는 결론 채용공고를 자주 들여다보고 공통적으로 원하는 역량을 잘 캐치해서 기업에서 원하는 인재상이 무엇인지 알고있기, 그리고 그 기술을 사용하는 개발자를 원하는 이유가 무엇인지 체크할 것.

들어가며

실제 개발에서는 데이터를 직접 코드에 작성하는 경우보다 외부 시스템에서 전달받는 경우가 훨씬 많다.

대표적인 예가 공공데이터포털(Open API), 기상청 API, 지도 API, 금융 API 등이다.

이러한 데이터는 대부분 CSV, XML, JSON 형태로 제공된다.

과거에는 XML이 많이 사용되었지만, 현재는 대부분 JSON을 사용한다. 그렇다고 XML이 사라진 것은 아니다. 공공기관이나 오래된 시스템에서는 XML을 사용하는 경우가 여전히 많으며, Java에서는 XML을 처리하는 SAX, DOM Parser도 자주 등장한다.

이번 글에서는 공공데이터의 형태와 XML의 구조, SAX와 DOM Parser의 차이, 그리고 JSON의 특징까지 정리해보려고 한다.

공공데이터와 데이터 형식

공공데이터란?

공공데이터란 국가기관이나 공공기관이 생산하거나 관리하는 공적인 정보를 의미한다.

대표적인 예는 다음과 같다.

• 날씨 정보
• 버스 도착 정보
• 지하철 운행 정보
• 관광지 정보
• 미세먼지 정보
• 병원 및 약국 정보
• 문화 행사 정보

이러한 데이터는 대부분 Open API 형태로 제공되며 프로그램에서 쉽게 사용할 수 있도록 일정한 형식을 가진다.

대표적인 데이터 형식은 다음 세 가지이다.

• CSV
• XML
• JSON

CSV

CSV(Comma Separated Values)는 가장 단순한 형태의 데이터이다.

이름 그대로 쉼표(,) 로 데이터를 구분한다.

id,name,age
1,Kim,20
2,Lee,25
3,Park,30

장점

• 파일 크기가 작다.
• 사람이 읽기 쉽다.
• 처리 속도가 빠르다.

단점

• 데이터 구조를 표현하기 어렵다.
• 계층 구조를 표현할 수 없다.
• 데이터 타입 정보가 없다.

간단한 테이블 데이터를 저장할 때 많이 사용된다.

XML

XML(Extensible Markup Language)은 태그를 이용하여 데이터를 표현하는 문서 형식이다.

HTML과 비슷하게 생겼지만 목적은 완전히 다르다.

HTML은 화면을 표현하기 위한 언어이고,

XML은 데이터를 저장하고 전달하기 위한 언어이다.

<person>
    <name>Kim</name>
    <age>20</age>
</person>

XML은 구조가 명확하고 확장성이 뛰어나기 때문에 공공데이터에서 많이 사용되었다.

JSON

JSON(JavaScript Object Notation)은 현재 가장 많이 사용되는 데이터 교환 형식이다.

객체를 Key-Value 형태로 표현한다.

{
  "name": "Kim",
  "age": 20
}

현재 대부분의 REST API는 JSON을 기본 형식으로 사용한다.

데이터 형식 비교

현재는 JSON이 가장 많이 사용되지만 XML 역시 공공데이터나 레거시 시스템에서는 여전히 중요한 역할을 한다.

XML

XML이란?

XML은 Extensible Markup Language의 약자이다.

"확장 가능한 마크업 언어"라는 의미이며, 필요한 태그를 개발자가 직접 정의하여 사용할 수 있다.

예를 들어 사람 정보를 저장한다면 다음과 같이 작성할 수 있다.

<person>
    <name>Kim</name>
    <age>20</age>
</person>

학생이라면

<student>
    <name>Hong</name>
    <grade>3</grade>
</student>

처럼 자유롭게 태그를 만들 수 있다.

이것이 HTML과 가장 큰 차이점이다.

Well-Formed XML

XML은 반드시 문법을 지켜야 한다.

이를 Well-Formed XML이라고 한다.

대표적인 규칙은 다음과 같다.

XML 선언

문서는 일반적으로 다음과 같이 시작한다.

<?xml version="1.0" encoding="UTF-8"?>

• XML 버전
• 문자 인코딩

을 지정한다.

Root Element는 하나만 존재

XML에는 최상위 태그가 반드시 하나 존재해야 한다.

올바른 예

<students>
    ...
</students>

잘못된 예

<student></student>

<teacher></teacher>

루트 태그가 두 개이므로 잘못된 XML이다.

시작 태그와 종료 태그가 일치해야 한다.

올바른 예

<name>Kim</name>

잘못된 예

<name>Kim</age>

태그는 대소문자를 구분한다.

<Name>

과

<name>

은 서로 다른 태그이다.

속성(Attribute)

태그에는 속성을 가질 수 있다.

<student id="1">

여기서

id → 속성 이름
1 → 속성 값

이다.

XML 문서 검증

XML은 개발자가 자유롭게 태그를 만들 수 있다.

그러다 보니 사람마다 태그 이름을 다르게 작성하면 문제가 발생한다.

이를 방지하기 위해 XML 문서의 규칙을 정의하는 방법이 존재한다.

대표적인 방법은

• DTD(Document Type Definition)
• XML Schema(XSD)

이다.

이를 이용하면 XML 문서가 정해진 규칙대로 작성되었는지 검사할 수 있다.

이러한 XML을 Valid XML이라고 한다.

XML Parsing

XML은 단순한 문자열이 아니다.

프로그램에서 원하는 데이터를 사용하려면 XML을 분석해야 한다.

이 과정을 Parsing이라고 한다.

XML 문서

↓

Parser

↓

Java 객체

Java에서는 대표적으로 두 가지 Parser를 제공한다.

• SAX Parser
• DOM Parser

SAX Parser

SAX란?

SAX(Simple API for XML)는 XML을 처음부터 끝까지 한 줄씩 읽으면서 이벤트 방식으로 처리하는 Parser이다.

문서 읽기

↓

시작 태그 발견

↓

이벤트 발생

↓

데이터 처리

↓

다음 태그 읽기

메모리에 XML 전체를 저장하지 않는다.

필요한 순간에만 처리한다.

특징

장점

• 매우 빠르다.
• 메모리 사용량이 적다.
• 대용량 XML 처리에 적합하다.

단점

• 이미 지나간 데이터를 다시 읽을 수 없다.
• 앞뒤를 자유롭게 탐색하기 어렵다.
• 구조를 자유롭게 수정하기 어렵다.

즉,

속도는 빠르지만 탐색은 불편하다.

이벤트 기반 처리

SAX는 태그를 만날 때마다 이벤트가 발생한다.

예를 들어

<name>Kim</name>

을 읽으면

startElement()

↓

characters()

↓

endElement()

순서대로 호출된다.

개발자는 이벤트가 발생했을 때 필요한 작업을 수행하면 된다.

Handler

SAX Parser는 이벤트가 발생했을 때 실행할 코드를 Handler에 작성한다.

대표적인 메서드는 다음과 같다.

startElement()

characters()

endElement()

각 메서드가 호출될 때 원하는 데이터를 저장하면 된다.

Record 클래스

Java에서는 XML 데이터를 저장하기 위해 Record를 사용할 수도 있다.

Record는 데이터를 저장하기 위한 불변 객체이다.

public record Person(
    String name,
    int age
) {}

Record의 특징은 다음과 같다.

• 모든 필드는 final
• Setter가 없다.
• 생성자, equals(), hashCode(), toString() 등을 자동 생성한다.

DTO(Data Transfer Object)를 만들 때 매우 유용하다.

DOM Parser

DOM이란?

DOM(Document Object Model)은 XML 문서를 전부 메모리에 읽은 후 트리 구조를 생성한다.

XML

↓

메모리에 전체 저장

↓

트리 생성

↓

원하는 노드 탐색

특징

장점

• 원하는 위치를 자유롭게 탐색 가능
• 수정 가능
• 부모, 자식 노드 접근 가능

단점

• 메모리 사용량이 크다.
• 속도가 느리다.
• 큰 XML에서는 부담이 크다.

즉,

탐색은 편하지만 무겁다.

Node 구조

DOM에서는 XML을 모두 Node로 관리한다.

예를 들어

<person>
    <name>Kim</name>
</person>

은 다음과 같은 트리 구조가 된다.

person
 └── name
      └── Kim

태그, 속성, 값 모두 Node로 관리된다.

SAX와 DOM 비교

간단히 기억하면

SAX는 빠르고 가볍고, DOM은 무겁지만 자유롭다.

JSON

JSON이란?

JSON(JavaScript Object Notation)은 현재 가장 많이 사용되는 데이터 교환 형식이다.

사람이 읽기 쉽고 용량도 작으며 대부분의 프로그래밍 언어에서 사용할 수 있다.

대표적인 형태는 다음과 같다.

{
  "name": "Kim",
  "age": 20,
  "major": "Computer"
}

객체는 Key-Value 형태로 구성된다.

배열 표현

JSON은 배열도 표현할 수 있다.

{
  "students": [
    {
      "name": "Kim"
    },
    {
      "name": "Lee"
    }
  ]
}

JSON의 장점

JSON이 널리 사용되는 이유는 다음과 같다.

• 문법이 단순하다.
• 사람이 읽기 쉽다.
• 용량이 작다.
• 대부분의 언어에서 지원한다.
• 웹과 모바일 환경에서 매우 많이 사용된다.

현재 REST API에서는 거의 JSON을 사용한다고 생각해도 될 정도이다.

XML과 JSON 비교

최근에는 대부분 JSON을 사용하지만,

공공데이터나 오래된 시스템에서는 XML도 자주 사용되므로 두 형식을 모두 이해하고 있어야 한다.

오늘 배운 내용 정리

이번 글에서는 Java에서 사용하는 XML과 JSON의 구조와 XML Parser를 정리했다.

• 공공데이터는 CSV, XML, JSON 형태로 제공된다.
• CSV는 단순하지만 구조 표현이 어렵다.
• XML은 태그 기반의 구조적인 데이터 형식이다.
• XML은 Well-Formed 문법을 반드시 따라야 한다.
• DTD와 XML Schema를 이용하면 XML 문서를 검증할 수 있다.
• XML Parsing은 XML 데이터를 프로그램에서 사용할 수 있도록 분석하는 과정이다.
• SAX Parser는 이벤트 기반으로 동작하며 빠르고 메모리 사용량이 적다.
• DOM Parser는 문서를 모두 메모리에 저장한 후 트리 구조로 탐색한다.
• Record는 불변 DTO를 간결하게 작성하기 위한 문법이다.
• JSON은 Key-Value 구조를 사용하는 데이터 형식이다.
• 현재 대부분의 REST API는 JSON을 사용한다.
• XML은 공공기관과 레거시 시스템에서 여전히 많이 사용된다.

들어가며

프로그램을 실행하다 보면 개발자가 예상하지 못한 상황이 발생할 수 있다.

사용자가 숫자를 입력해야 하는 곳에 문자열을 입력하거나, 존재하지 않는 파일을 읽으려고 할 수도 있다. 배열의 범위를 벗어난 인덱스에 접근하거나 null인 객체의 메서드를 호출할 수도 있다.

int result = 10 / 0;

위 코드는 실행 중 ArithmeticException을 발생시킨다.

예외를 처리하지 않으면 프로그램은 해당 지점에서 비정상적으로 종료될 수 있다. 그러나 모든 오류 상황에서 프로그램을 즉시 종료하는 것이 적절한 것은 아니다.

잘못된 입력을 다시 요청하거나, 파일이 없다는 메시지를 출력하거나, 작업을 취소한 뒤 안전하게 다음 흐름으로 이동할 수 있어야 한다.

Java는 이러한 상황을 처리하기 위해 예외 처리(Exception Handling) 기능을 제공한다.

이번 글에서는 예외 클래스의 계층 구조부터 Checked Exception과 Unchecked Exception의 차이, try-catch-finally, try-with-resources, throw와 throws, 예외 변환, 사용자 정의 예외까지 정리해보려고 한다.

예외란 무엇인가

프로그램의 오류 상황

프로그램 실행 중 정상적인 흐름을 방해하는 문제는 크게 Error와 Exception으로 구분할 수 있다.

Throwable
├─ Error
└─ Exception

Throwable은 Java에서 오류와 예외를 표현하는 최상위 클래스다.

Error

Error는 일반적으로 애플리케이션 코드에서 복구하기 어려운 심각한 문제를 나타낸다.

대표적인 예는 다음과 같다.

• OutOfMemoryError
• StackOverflowError
• VirtualMachineError

public static void recursive() {
    recursive();
}

위 메서드를 계속 호출하면 호출 스택이 가득 차면서 StackOverflowError가 발생할 수 있다.

Error는 대부분 개발자가 try-catch로 복구하기보다 원인을 찾아 프로그램이나 실행 환경을 수정해야 하는 문제다.

Exception

Exception은 프로그램에서 처리하거나 복구할 가능성이 있는 예외 상황을 나타낸다.

대표적인 예는 다음과 같다.

• 잘못된 숫자 변환
• 존재하지 않는 파일 접근
• 배열 범위 초과
• 잘못된 객체 형변환
• null 객체 사용
• 데이터베이스 연결 실패

예외는 모두 객체이며, 예외가 발생하면 JVM은 해당 상황을 표현하는 예외 객체를 생성한다.

예외 상황 발생
→ 예외 객체 생성
→ 예외 객체를 던짐
→ 처리 가능한 catch 탐색

예외 클래스의 계층

Java 예외는 다음과 같은 계층 구조를 가진다.

Throwable
├─ Error
└─ Exception
   ├─ RuntimeException
   │  ├─ NullPointerException
   │  ├─ ArithmeticException
   │  ├─ ClassCastException
   │  ├─ NumberFormatException
   │  └─ IndexOutOfBoundsException
   │
   ├─ IOException
   ├─ SQLException
   ├─ ClassNotFoundException
   └─ ...

RuntimeException을 기준으로 Checked Exception과 Unchecked Exception을 구분한다.

Checked Exception과 Unchecked Exception

Checked Exception

Checked Exception은 컴파일러가 예외 처리 여부를 확인하는 예외다.

예외가 발생할 수 있는 코드를 작성했다면 다음 중 하나를 반드시 선택해야 한다.

• try-catch로 직접 처리
• throws로 호출한 곳에 처리 책임 전달

처리하지 않으면 컴파일이 되지 않는다.

대표적인 Checked Exception은 다음과 같다.

• IOException
• SQLException
• ClassNotFoundException
• InterruptedException

Class.forName("com.example.Sample");

Class.forName()은 ClassNotFoundException이 발생할 수 있으므로 반드시 처리해야 한다.

public class CheckedExceptionExample {

    public static void main(String[] args) {
        try {
            Class.forName(
                    "com.example.Sample"
            );
        } catch (ClassNotFoundException e) {
            System.out.println(
                    "클래스를 찾을 수 없습니다."
            );
        }

        System.out.println("프로그램 정상 종료");
    }
}

Unchecked Exception

Unchecked Exception은 컴파일러가 예외 처리 여부를 강제하지 않는 예외다.

RuntimeException과 그 하위 클래스가 해당한다.

대표적인 예는 다음과 같다.

• NullPointerException
• ArithmeticException
• NumberFormatException
• ClassCastException
• IndexOutOfBoundsException
• IllegalArgumentException

int number =
        Integer.parseInt("Java");

위 코드는 NumberFormatException을 발생시킬 수 있지만 처리 코드가 없어도 컴파일된다.

public class UncheckedExceptionExample {

    public static void main(String[] args) {
        int number =
                Integer.parseInt("Java");

        System.out.println(number);
    }
}

실행 시 예외가 발생하면 프로그램이 중단된다.

Checked와 Unchecked 비교

Checked Exception이라고 항상 복구 가능한 것은 아니고, Unchecked Exception이라고 절대 처리하면 안 되는 것도 아니다.

중요한 것은 예외의 종류보다 현재 계층에서 의미 있게 처리할 수 있는가다.

try-catch로 예외 처리하기

try-catch 구조

예외가 발생할 수 있는 코드를 try 블록에 작성하고, 예외가 발생했을 때 실행할 코드를 catch 블록에 작성한다.

try {
    // 예외가 발생할 수 있는 코드
} catch (ExceptionType e) {
    // 예외가 발생했을 때 처리할 코드
}

문자열을 숫자로 변환하는 예제를 살펴보자.

public class TryCatchExample {

    public static void main(String[] args) {
        String input = "Java";

        try {
            int number =
                    Integer.parseInt(input);

            System.out.println(number);
        } catch (NumberFormatException e) {
            System.out.println(
                    "숫자로 변환할 수 없습니다."
            );
        }

        System.out.println(
                "프로그램을 계속 실행합니다."
        );
    }
}

실행 결과는 다음과 같다.

숫자로 변환할 수 없습니다.
프로그램을 계속 실행합니다.

try-catch의 실행 흐름

try 블록에서 예외가 발생하지 않으면 catch 블록은 실행되지 않는다.

try 시작
→ 정상 실행
→ catch 건너뜀
→ 다음 코드 실행

예외가 발생하면 해당 지점 이후의 try 코드는 실행되지 않는다.

try 시작
→ 예외 발생
→ 예외 객체 생성
→ 일치하는 catch로 이동
→ catch 실행
→ 다음 코드 실행

public class ExceptionFlowExample {

    public static void main(String[] args) {
        try {
            System.out.println("A");

            int result = 10 / 0;

            System.out.println("B");
        } catch (ArithmeticException e) {
            System.out.println("C");
        }

        System.out.println("D");
    }
}

실행 결과는 다음과 같다.

A
C
D

10 / 0에서 예외가 발생했으므로 "B"는 출력되지 않는다.

catch의 예외 변수

catch (NumberFormatException e)

e에는 JVM이 던진 예외 객체가 전달된다.

예외 객체를 통해 어떤 문제가 발생했는지 확인할 수 있다.

catch (NumberFormatException e) {
    System.out.println(e.getMessage());
}

예외 객체의 정보 확인하기

모든 예외 클래스는 Throwable을 상속하므로 Throwable이 제공하는 메서드를 사용할 수 있다.

getMessage()

예외에 포함된 상세 메시지를 반환한다.

try {
    Integer.parseInt("Java");
} catch (NumberFormatException e) {
    System.out.println(e.getMessage());
}

출력되는 메시지는 예외가 발생한 원인과 입력값에 대한 정보를 포함할 수 있다.

getCause()

현재 예외의 원인이 된 다른 예외 객체를 반환한다.

원인이 설정되어 있지 않다면 null을 반환한다.

Throwable cause = e.getCause();

예외를 다른 예외로 변환해 던질 때 원래 예외를 연결해두면 getCause()로 확인할 수 있다.

printStackTrace()

예외가 발생한 위치와 메서드 호출 흐름을 출력한다.

catch (Exception e) {
    e.printStackTrace();
}

Stack Trace에는 다음 정보가 포함된다.

• 발생한 예외의 종류
• 예외 메시지
• 예외가 발생한 클래스와 메서드
• 파일명과 코드 줄 번호
• 해당 메서드가 호출된 과정

java.lang.NumberFormatException
    at java.lang.Integer.parseInt(...)
    at Example.convert(Example.java:15)
    at Example.main(Example.java:7)

Stack Trace는 디버깅할 때 매우 중요한 정보다.

다만 실제 서버 애플리케이션에서는 printStackTrace()보다 로깅 프레임워크를 통해 예외를 기록하는 경우가 많다.

여러 예외 처리하기

여러 catch 블록

하나의 try 블록에서 여러 종류의 예외가 발생할 수 있다면 여러 catch 블록을 작성할 수 있다.

public class MultipleCatchExample {

    public static void main(String[] args) {
        String[] values = {
                "10",
                "Java"
        };

        try {
            int index = 2;

            int number = Integer.parseInt(
                    values[index]
            );

            System.out.println(number);
        } catch (
                ArrayIndexOutOfBoundsException e
        ) {
            System.out.println(
                    "배열 인덱스를 확인하세요."
            );
        } catch (
                NumberFormatException e
        ) {
            System.out.println(
                    "숫자 형식을 확인하세요."
            );
        }
    }
}

발생한 예외와 일치하는 catch 블록 하나만 실행된다.

catch 순서

예외 클래스도 상속 관계를 가진다.

Exception
↑
RuntimeException
↑
NumberFormatException

catch 블록을 찾을 때 다형성이 적용되므로 자식 예외부터 부모 예외 순서로 작성해야 한다.

try {
    Integer.parseInt("Java");
} catch (NumberFormatException e) {
    System.out.println(
            "숫자 변환 오류"
    );
} catch (Exception e) {
    System.out.println(
            "그 밖의 예외"
    );
}

상위 예외를 먼저 작성하면 하위 예외의 catch 블록은 실행될 기회가 없다.

try {
    Integer.parseInt("Java");
} catch (Exception e) {
    System.out.println("전체 예외 처리");
}

// 컴파일 오류
// catch (NumberFormatException e) {
// }

Exception이 NumberFormatException까지 먼저 처리하기 때문에 뒤의 블록은 도달할 수 없는 코드가 된다.

멀티 catch

처리 방법이 같은 여러 예외를 하나의 catch 블록에서 처리할 수 있다.

try {
    // 예외 발생 가능 코드
} catch (
        NumberFormatException
        | NullPointerException e
) {
    System.out.println(
            "입력값을 확인하세요."
    );
}

|로 연결한 예외는 서로 부모와 자식 관계이면 안 된다.

// 사용할 수 없음
// catch (RuntimeException
//        | NumberFormatException e) {
// }

NumberFormatException이 이미 RuntimeException에 포함되기 때문이다.

구체적인 예외 처리와 통합 처리

가능하면 예외 상황에 맞는 구체적인 처리를 제공하는 것이 좋다.

catch (NumberFormatException e) {
    System.out.println(
            "숫자만 입력할 수 있습니다."
    );
}

모든 예외를 무조건 Exception 하나로 처리하면 사용자에게 정확한 원인을 설명하기 어렵다.

catch (Exception e) {
    System.out.println(
            "오류가 발생했습니다."
    );
}

그러나 모든 예외를 지나치게 세분화하면 코드가 복잡해질 수 있다.

같은 방식으로 처리할 예외들은 멀티 catch나 공통 상위 타입으로 묶는 것이 적절하다.

finally와 자원 정리

finally

finally 블록은 예외 발생 여부와 관계없이 try-catch가 끝날 때 실행된다.

try {
    System.out.println("작업 실행");
} catch (Exception e) {
    System.out.println("예외 처리");
} finally {
    System.out.println("항상 실행");
}

예외가 발생하지 않아도 실행되고, 예외가 발생해 catch가 실행된 뒤에도 실행된다.

return이 있어도 finally가 먼저 실행된다

public class FinallyReturnExample {

    public static int test() {
        try {
            System.out.println("try");
            return 1;
        } finally {
            System.out.println("finally");
        }
    }

    public static void main(String[] args) {
        int result = test();

        System.out.println(result);
    }
}

실행 결과는 다음과 같다.

try
finally
1

return으로 메서드가 종료되기 전에 finally가 먼저 실행된다.

finally가 실행되지 않을 수 있는 경우

finally를 일반적으로 항상 실행된다고 설명하지만 절대적인 보장은 아니다.

다음과 같은 경우 실행되지 않을 수 있다.

• System.exit()로 JVM이 종료된 경우
• JVM 자체가 비정상 종료된 경우
• 운영체제나 프로세스가 강제로 종료된 경우
• 전원이 차단된 경우

try {
    System.exit(0);
} finally {
    System.out.println(
            "실행되지 않을 수 있음"
    );
}

finally의 주요 목적

finally는 주로 사용한 자원을 정리하기 위해 사용한다.

예를 들어 다음 자원은 사용 후 반납이 필요하다.

• 파일 스트림
• 네트워크 연결
• 데이터베이스 연결
• 입력 스트림
• 출력 스트림

자원을 반납하지 않으면 시스템 자원이 계속 점유되는 Resource Leak이 발생할 수 있다.

FileInputStream input = null;

try {
    input = new FileInputStream(
            "data.txt"
    );

    int value = input.read();

    System.out.println(value);
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (input != null) {
        try {
            input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

하지만 자원을 닫는 close()에서도 예외가 발생할 수 있기 때문에 코드가 복잡해진다.

이를 개선하기 위해 try-with-resources가 도입되었다.

try-with-resources

자동 자원 반납

try-with-resources는 try 선언부에서 생성한 자원을 자동으로 닫아주는 문법이다.

try (
    Resource resource = new Resource()
) {
    // 자원 사용
} catch (Exception e) {
    // 예외 처리
}

try 블록을 벗어날 때 자동으로 close()가 호출된다.

import java.io.FileInputStream;
import java.io.IOException;

public class ResourceExample {

    public static void main(String[] args) {
        try (
            FileInputStream input =
                    new FileInputStream(
                            "data.txt"
                    )
        ) {
            int value = input.read();

            System.out.println(value);
        } catch (IOException e) {
            System.out.println(
                    "파일 처리 중 오류가 발생했습니다."
            );

            e.printStackTrace();
        }
    }
}

finally에서 직접 close()를 호출하지 않아도 된다.

AutoCloseable

try-with-resources에서 사용할 객체는 AutoCloseable 인터페이스를 구현해야 한다.

public interface AutoCloseable {

    void close() throws Exception;
}

FileInputStream, BufferedReader, JDBC의 Connection과 같은 많은 자원 클래스가 AutoCloseable을 구현한다.

여러 자원 사용하기

여러 자원을 함께 선언할 수 있다.

try (
    FileInputStream input =
            new FileInputStream(
                    "input.txt"
            );

    FileOutputStream output =
            new FileOutputStream(
                    "output.txt"
            )
) {
    output.write(input.read());
}

자원은 선언한 순서의 반대로 닫힌다.

input 생성
output 생성

작업 종료

output close
input close

try-with-resources의 변수

try 선언부의 자원 변수는 다시 대입할 수 없다.

try (
    FileInputStream input =
            new FileInputStream(
                    "data.txt"
            )
) {
    // input = new FileInputStream("other.txt");
    // 재할당 불가
}

사실상 final처럼 취급된다.

Java 9 이후의 개선

Java 9부터는 외부에서 선언된 final 또는 사실상 final인 변수를 try 선언부에서 사용할 수 있다.

FileInputStream input =
        new FileInputStream("data.txt");

try (input) {
    System.out.println(input.read());
}

단, 해당 변수는 이후 다른 값으로 재할당되지 않은 상태여야 한다.

throw와 throws

throw

throw는 예외 객체를 직접 발생시키는 키워드다.

throw new IllegalArgumentException(
        "나이는 음수일 수 없습니다."
);

예외 상황을 개발자가 직접 정의하여 발생시킬 수 있다.

public class Member {

    private int age;

    public void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException(
                    "나이는 음수일 수 없습니다."
            );
        }

        this.age = age;
    }
}

throws

throws는 메서드에서 발생한 예외를 직접 처리하지 않고 호출한 곳으로 전달한다고 선언하는 키워드다.

public void readFile()
        throws IOException {
}

예외가 사라지는 것이 아니라 처리 책임이 호출자에게 이동한다.

public static void readFile()
        throws IOException {

    FileInputStream input =
            new FileInputStream(
                    "data.txt"
            );

    input.close();
}

호출한 메서드는 다시 처리하거나 위임해야 한다.

public static void main(String[] args) {
    try {
        readFile();
    } catch (IOException e) {
        System.out.println(
                "파일을 처리할 수 없습니다."
        );
    }
}

throw와 throws 차이

throw new IOException();

void read()
        throws IOException,
               SQLException {
}

Checked Exception과 throws

Checked Exception은 반드시 다음 중 하나로 처리해야 한다.

try-catch로 직접 처리
또는
throws로 호출자에게 위임

public void loadClass()
        throws ClassNotFoundException {

    Class.forName(
            "com.example.Sample"
    );
}

Unchecked Exception과 throws

Unchecked Exception은 throws를 작성하지 않아도 자동으로 호출 스택을 따라 전달된다.

public void validate(int age) {
    if (age < 0) {
        throw new IllegalArgumentException(
                "잘못된 나이"
        );
    }
}

다음처럼 선언할 수도 있지만 컴파일러가 강제하지는 않는다.

public void validate(int age)
        throws IllegalArgumentException {
}

Unchecked Exception을 throws에 작성하는 목적은 주로 메서드 사용자가 발생 가능성을 쉽게 알도록 문서화하는 것이다.

예외를 처리할지 위임할지 결정하기

현재 메서드에서 예외를 의미 있게 처리할 수 있다면 직접 처리한다.

try {
    int number =
            Integer.parseInt(input);
} catch (NumberFormatException e) {
    System.out.println(
            "숫자를 다시 입력하세요."
    );
}

현재 계층에서 처리 방법을 결정할 수 없다면 상위 계층으로 전달한다.

public Member findMember(long id) {
    return repository.findById(id)
            .orElseThrow(
                    () ->
                            new MemberNotFoundException(
                                    id
                            )
            );
}

예외를 잡았지만 할 수 있는 일이 없다면 무조건 잡기보다 적절한 계층으로 전달하는 것이 더 좋을 수 있다.

메서드 오버라이딩과 throws

자식 클래스에서 메서드를 오버라이딩할 때 부모 메서드보다 더 넓은 Checked Exception을 선언할 수 없다.

public class Parent {

    public void work()
            throws IOException {
    }
}

자식 클래스는 같은 예외나 더 구체적인 하위 예외를 선언할 수 있다.

public class Child extends Parent {

    @Override
    public void work()
            throws FileNotFoundException {
    }
}

다음은 사용할 수 없다.

public class Child extends Parent {

    // 더 넓은 Exception 선언 불가
    // @Override
    // public void work()
    //         throws Exception {
    // }
}

예외를 선언하지 않는 것도 가능하다.

@Override
public void work() {
}

Unchecked Exception은 이 제한을 직접적으로 적용받지 않는다.

예외 변환과 Exception Chaining

예외 변환

하위 계층에서 발생한 기술적인 예외를 상위 계층에서 이해하기 쉬운 업무 예외로 변환할 수 있다.

예를 들어 Repository에서 데이터베이스 관련 예외가 발생했다고 가정해보자.

public Member findById(long id) {
    try {
        return loadMemberFromDatabase(id);
    } catch (SQLException e) {
        throw new MemberDataAccessException(
                "회원 데이터 조회 실패",
                e
        );
    }
}

상위 계층은 SQLException 같은 데이터베이스 구현 세부사항 대신 MemberDataAccessException이라는 의미 있는 예외를 다룰 수 있다.

Exception Chaining

예외를 변환할 때 원래 예외를 함께 전달하는 것을 Exception Chaining이라고 한다.

throw new MemberDataAccessException(
        "회원 데이터 조회 실패",
        e
);

사용자 정의 예외 생성자에서 원인을 부모 생성자에 전달한다.

public class MemberDataAccessException
        extends RuntimeException {

    public MemberDataAccessException(
            String message,
            Throwable cause
    ) {
        super(message, cause);
    }
}

원래 예외 정보를 보존했기 때문에 Stack Trace에서 전체 원인 흐름을 확인할 수 있다.

MemberDataAccessException
Caused by: SQLException

예외를 변환하면서 원래 예외를 제거하면 실제 원인을 추적하기 어려워진다.

사용자 정의 예외

사용자 정의 예외가 필요한 이유

Java 표준 예외만으로도 많은 상황을 표현할 수 있지만, 업무 의미를 명확하게 전달하기 위해 별도의 예외를 만들 수 있다.

예를 들어 다음 상황을 표현해보자.

• 회원을 찾을 수 없음
• 주문을 취소할 수 없음
• 잔액이 부족함
• 이미 사용 중인 이메일
• 재고가 부족함

throw new RuntimeException(
        "회원을 찾을 수 없습니다."
);

단순 RuntimeException보다 다음 예외가 의미를 더 명확하게 표현한다.

throw new MemberNotFoundException(id);

Unchecked 사용자 정의 예외

RuntimeException을 상속하면 Unchecked Exception이 된다.

public class MemberNotFoundException
        extends RuntimeException {

    public MemberNotFoundException(long id) {
        super(
            "회원을 찾을 수 없습니다. id=" + id
        );
    }
}

사용할 때는 다음과 같다.

public Member findMember(long id) {
    if (id != 1L) {
        throw new MemberNotFoundException(id);
    }

    return new Member(id, "김자바");
}

호출한 쪽에서 반드시 try-catch를 작성할 필요는 없다.

Checked 사용자 정의 예외

Exception을 직접 상속하면 Checked Exception이 된다.

public class InsufficientBalanceException
        extends Exception {

    public InsufficientBalanceException(
            long balance,
            long amount
    ) {
        super(
            "잔액이 부족합니다. "
                    + "잔액="
                    + balance
                    + ", 출금액="
                    + amount
        );
    }
}

이 예외를 발생시키는 메서드는 처리하거나 throws로 선언해야 한다.

public void withdraw(long amount)
        throws InsufficientBalanceException {

    if (amount > balance) {
        throw new InsufficientBalanceException(
                balance,
                amount
        );
    }

    balance -= amount;
}

Checked와 Unchecked 중 무엇을 선택할까?

Checked Exception은 호출자가 반드시 처리하도록 강제할 수 있다.

하지만 호출 단계마다 try-catch나 throws가 추가되어 코드가 복잡해질 수 있다.

Unchecked Exception은 코드가 간결하고 여러 계층을 자연스럽게 전파할 수 있다.

하지만 예외 처리가 누락될 가능성이 있다.

최근 애플리케이션 개발에서는 다음과 같은 업무 예외를 Unchecked Exception으로 설계하는 경우가 많다.

• 유효하지 않은 인수
• 존재하지 않는 데이터
• 업무 규칙 위반
• 처리할 수 없는 상태

Checked Exception은 호출자가 실제로 복구하거나 다른 대안을 선택할 수 있을 때 고려하는 것이 좋다.

올바른 예외 처리 방법

예외를 비워두지 않기

다음과 같이 예외를 잡고 아무 작업도 하지 않으면 문제가 사라진 것처럼 보인다.

try {
    execute();
} catch (Exception e) {
}

실제로는 예외 정보가 완전히 사라져 원인을 찾기 어렵다.

최소한 로그를 남기거나, 의미 있는 처리를 하거나, 다시 던져야 한다.

catch (Exception e) {
    logger.error(
            "작업 실행 실패",
            e
    );

    throw e;
}

Exception을 무조건 잡지 않기

catch (Exception e)

는 대부분의 예외를 한 번에 잡을 수 있지만 너무 광범위하다.

복구할 수 없는 프로그래밍 오류까지 잘못 처리하여 문제를 숨길 수 있다.

가능하면 필요한 예외를 구체적으로 처리한다.

catch (NumberFormatException e) {
}

최상위 계층에서 예외를 공통 처리해야 할 때는 Exception을 사용할 수 있지만, 내부 로직 곳곳에서 무분별하게 사용하지 않는 것이 좋다.

예외를 흐름 제어로 사용하지 않기

다음 코드는 예외를 반복문 종료 조건으로 사용한다.

try {
    int index = 0;

    while (true) {
        System.out.println(
                values[index++]
        );
    }
} catch (
        ArrayIndexOutOfBoundsException e
) {
}

예외는 정상적인 분기나 반복 종료를 위한 기능이 아니다.

다음처럼 정상적인 조건식을 사용해야 한다.

for (
    int index = 0;
    index < values.length;
    index++
) {
    System.out.println(values[index]);
}

예외 객체 생성과 Stack Trace 구성에는 비용도 발생한다.

상태 확인 메서드 활용하기

예외가 발생하기 전에 상태를 확인할 수 있다면 상태 확인 메서드를 사용할 수 있다.

Scanner scanner =
        new Scanner(System.in);

if (scanner.hasNextInt()) {
    int number = scanner.nextInt();

    System.out.println(number);
} else {
    System.out.println(
            "숫자를 입력해야 합니다."
    );
}

hasNextInt()로 상태를 확인한 뒤 nextInt()를 호출하면 잘못된 입력에 대한 예외 발생을 줄일 수 있다.

다만 모든 상황에서 사전 검사만으로 예외를 완전히 막을 수 있는 것은 아니다. 파일이나 네트워크처럼 검사 이후 상태가 변할 수 있는 외부 자원은 실제 작업에서 발생하는 예외도 함께 처리해야 한다.

RuntimeException은 원인 수정이 우선일 수 있다

NullPointerException, IndexOutOfBoundsException, ClassCastException 같은 예외는 무조건 try-catch로 감싸기보다 발생 원인을 수정해야 하는 경우가 많다.

try {
    String name = null;

    System.out.println(name.length());
} catch (NullPointerException e) {
}

다음처럼 잘못된 상태가 만들어지지 않도록 설계하는 것이 더 좋다.

if (name == null) {
    throw new IllegalArgumentException(
            "이름은 null일 수 없습니다."
    );
}

로그를 통해 예외 추적하기

예외가 발생했을 때 다음 정보를 확인해야 한다.

어떤 예외가 발생했는가?
예외 메시지는 무엇인가?
어느 코드에서 발생했는가?
어떤 메서드 호출을 통해 도달했는가?
원인 예외가 있는가?

Stack Trace는 보통 가장 위의 예외만 보는 것이 아니라 아래쪽의 Caused by까지 확인해야 한다.

ServiceException
    at MemberService.find(...)

Caused by: SQLException
    at MemberRepository.find(...)

실제 원인은 가장 아래쪽에 가까운 Caused by에 나타나는 경우가 많다.

printStackTrace보다 로깅 사용하기

학습 단계에서는 다음 코드를 자주 사용한다.

e.printStackTrace();

실제 프로젝트에서는 로깅 프레임워크를 사용하는 경우가 많다.

logger.error(
        "회원 조회 중 예외 발생. id={}",
        id,
        e
);

로그에는 다음 정보가 함께 포함될 수 있다.

• 발생 시간
• 로그 레벨
• 스레드
• 클래스 이름
• 업무 식별자
• 예외 메시지와 Stack Trace

예외 객체 e를 문자열로만 연결하면 Stack Trace가 누락될 수 있으므로 로거에 예외 객체 자체를 전달해야 한다.

종합 예제: 회원 등록 예외 처리

회원 등록 과정에서 발생할 수 있는 예외를 사용자 정의 예외로 처리해보자.

DuplicateEmailException

public class DuplicateEmailException
        extends RuntimeException {

    public DuplicateEmailException(
            String email
    ) {
        super(
            "이미 사용 중인 이메일입니다. "
                    + "email="
                    + email
        );
    }
}

InvalidMemberException

public class InvalidMemberException
        extends RuntimeException {

    public InvalidMemberException(
            String message
    ) {
        super(message);
    }
}

Member

public class Member {

    private final String name;
    private final String email;

    public Member(
            String name,
            String email
    ) {
        if (
            name == null
            || name.isBlank()
        ) {
            throw new InvalidMemberException(
                    "이름은 비어 있을 수 없습니다."
            );
        }

        if (
            email == null
            || email.isBlank()
        ) {
            throw new InvalidMemberException(
                    "이메일은 비어 있을 수 없습니다."
            );
        }

        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }
}

MemberRepository

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

public class MemberRepository {

    private final Map<String, Member> members =
            new HashMap<>();

    public boolean existsByEmail(
            String email
    ) {
        return members.containsKey(email);
    }

    public void save(Member member) {
        members.put(
                member.getEmail(),
                member
        );
    }

    public Optional<Member> findByEmail(
            String email
    ) {
        return Optional.ofNullable(
                members.get(email)
        );
    }
}

MemberService

public class MemberService {

    private final MemberRepository repository;

    public MemberService(
            MemberRepository repository
    ) {
        this.repository = repository;
    }

    public Member register(
            String name,
            String email
    ) {
        if (
            repository.existsByEmail(email)
        ) {
            throw new DuplicateEmailException(
                    email
            );
        }

        Member member =
                new Member(name, email);

        repository.save(member);

        return member;
    }
}

실행 클래스

public class ExceptionExample {

    public static void main(String[] args) {
        MemberRepository repository =
                new MemberRepository();

        MemberService service =
                new MemberService(repository);

        try {
            Member first =
                    service.register(
                            "김자바",
                            "java@example.com"
                    );

            System.out.println(
                    first.getName()
                            + " 등록 완료"
            );

            service.register(
                    "이자바",
                    "java@example.com"
            );
        } catch (
                DuplicateEmailException e
        ) {
            System.out.println(
                    "회원 등록 실패: "
                            + e.getMessage()
            );
        } catch (
                InvalidMemberException e
        ) {
            System.out.println(
                    "입력값 오류: "
                            + e.getMessage()
            );
        } finally {
            System.out.println(
                    "회원 등록 작업 종료"
            );
        }

        System.out.println(
                "프로그램 정상 종료"
        );
    }
}

실행 결과는 다음과 같다.

김자바 등록 완료
회원 등록 실패: 이미 사용 중인 이메일입니다. email=java@example.com
회원 등록 작업 종료
프로그램 정상 종료

이 예제에는 다음 개념이 포함되어 있다.

• 사용자 정의 예외
• Unchecked Exception
• throw를 이용한 예외 발생
• 여러 catch 블록
• finally
• 예외를 이용한 업무 규칙 표현
• 컬렉션과 Optional

헷갈리기 쉬운 개념

Error와 Exception

Error
→ 일반적으로 애플리케이션에서 복구하기 어려운 심각한 문제

Exception
→ 프로그램 코드에서 처리할 수 있는 예외 상황

Error까지 무조건 catch하려고 하는 것은 적절하지 않다.

Checked와 Unchecked

Checked Exception
→ 컴파일러가 처리 여부 검사

Unchecked Exception
→ 컴파일러가 처리 여부 강제하지 않음

둘의 차이는 “심각한 예외와 가벼운 예외”가 아니다.

컴파일러가 처리 코드를 강제하는지에 대한 차이다.

throw와 throws

throw new Exception();

실제로 예외 객체를 발생시킨다.

void method() throws Exception {
}

예외 처리 책임을 호출자에게 전달한다.

catch와 throws

catch
→ 현재 메서드에서 예외 처리

throws
→ 호출한 메서드로 예외 전달

throws를 사용한다고 예외가 처리되거나 사라지는 것은 아니다.

finally와 try-with-resources

finally는 예외 발생 여부와 관계없이 공통 작업을 수행한다.

try-with-resources는 AutoCloseable 자원을 자동으로 닫기 위한 전용 문법이다.

파일이나 DB 연결처럼 닫아야 하는 자원에는 가능하면 try-with-resources를 사용하는 것이 좋다.

예외 처리와 예외 무시

다음은 예외 처리가 아니다.

catch (Exception e) {
}

예외를 잡았지만 아무것도 하지 않았기 때문에 문제를 숨긴 것이다.

예외 메시지와 Stack Trace

e.getMessage()

예외 메시지만 반환한다.

e.printStackTrace()

예외 종류, 메시지, 발생 위치, 호출 경로를 함께 출력한다.

디버깅에는 Stack Trace가 훨씬 중요하다.

실무에서는 어떻게 사용할까?

실무에서는 예외를 잡는 것보다 어느 계층에서 어떤 의미로 처리할지가 중요하다.

Repository 계층에서는 데이터베이스나 파일 관련 예외가 발생할 수 있다.

Service 계층에서는 이를 업무 의미가 있는 예외로 변환할 수 있다.

SQLException
→ MemberDataAccessException

Controller 계층에서는 예외를 HTTP 응답으로 변환할 수 있다.

MemberNotFoundException
→ HTTP 404 Not Found

Spring에서는 @ExceptionHandler나 @RestControllerAdvice를 사용해 예외를 공통 처리할 수 있다.

@ExceptionHandler(
        MemberNotFoundException.class
)
public ResponseEntity<?> handle(
        MemberNotFoundException e
) {
    return ResponseEntity
            .notFound()
            .build();
}

예외 메시지에는 문제 해결에 필요한 정보를 포함하되 비밀번호, 인증 토큰, 주민등록번호 같은 민감한 정보는 포함하지 않아야 한다.

예외를 로그로 남길 때도 같은 예외를 여러 계층에서 반복 기록하면 로그가 중복될 수 있다.

예외를 처리하는 계층
또는
최종적으로 사용자 응답으로 변환하는 계층

처럼 로깅 위치를 명확히 정하는 것이 좋다.

오늘 배운 내용 정리

이번 글에서는 Java의 예외 처리 구조와 활용 방법을 정리했다.

• 예외는 프로그램의 정상적인 실행 흐름을 방해하는 상황을 표현한다.
• Java의 오류와 예외는 모두 Throwable을 상속한다.
• Error는 일반적으로 애플리케이션에서 복구하기 어려운 심각한 문제다.
• Exception은 코드에서 처리할 수 있는 예외 상황을 표현한다.
• 예외는 모두 객체이며 JVM이 예외 객체를 생성해 던진다.
• Checked Exception은 처리하지 않으면 컴파일되지 않는다.
• Checked Exception은 try-catch 또는 throws로 처리해야 한다.
• Unchecked Exception은 컴파일러가 처리 여부를 강제하지 않는다.
• RuntimeException과 그 하위 예외가 Unchecked Exception에 해당한다.
• try 블록에는 예외가 발생할 가능성이 있는 코드를 작성한다.
• catch 블록은 발생한 예외 객체를 받아 처리한다.
• 예외가 발생하면 해당 지점 이후의 try 코드는 실행되지 않는다.
• getMessage()는 예외의 상세 메시지를 반환한다.
• getCause()는 현재 예외의 원인 예외를 반환한다.
• printStackTrace()는 예외 발생 위치와 호출 흐름을 출력한다.
• 여러 예외를 처리할 때는 여러 catch 블록을 사용할 수 있다.
• 자식 예외를 부모 예외보다 먼저 처리해야 한다.
• 멀티 catch를 이용하면 처리 방식이 같은 여러 예외를 하나로 묶을 수 있다.
• finally는 예외 발생 여부와 관계없이 일반적으로 실행된다.
• return이 있더라도 메서드 종료 전에 finally가 실행된다.
• System.exit()나 JVM 강제 종료 상황에서는 finally 실행이 보장되지 않는다.
• finally는 주로 자원을 정리하는 데 사용한다.
• try-with-resources는 AutoCloseable 자원을 자동으로 닫는다.
• try-with-resources의 자원 변수는 다시 할당할 수 없다.
• throw는 예외 객체를 직접 발생시킨다.
• throws는 예외 처리 책임을 호출자에게 전달한다.
• throws를 사용해도 예외가 사라지는 것은 아니다.
• 오버라이딩 메서드는 부모보다 더 넓은 Checked Exception을 선언할 수 없다.
• 예외 변환은 하위 계층의 기술 예외를 상위 계층의 의미 있는 예외로 바꾸는 작업이다.
• Exception Chaining은 변환된 예외에 원래 예외를 연결하는 방법이다.
• 사용자 정의 예외는 업무 상황을 명확하게 표현할 수 있다.
• 사용자 정의 Checked Exception은 Exception을 상속한다.
• 사용자 정의 Unchecked Exception은 RuntimeException을 상속한다.
• 예외를 잡고 아무 작업도 하지 않으면 문제의 원인을 숨기게 된다.
• 예외는 정상적인 흐름 제어 목적으로 사용하지 않아야 한다.
• RuntimeException은 무조건 잡기보다 잘못된 코드와 상태를 수정해야 하는 경우가 많다.
• 실제 프로젝트에서는 printStackTrace()보다 로깅 프레임워크를 사용하는 것이 일반적이다.
• Stack Trace를 분석할 때는 예외 종류, 메시지, 발생 위치, Caused by를 확인해야 한다.

다음 글 예고

다음 글에서는 Java가 파일과 데이터를 읽고 쓰는 방법인 입출력 스트림을 다룬다.

Java 심화 ⑩ 입출력 스트림

- InputStream과 OutputStream
- Reader와 Writer
- FileInputStream
- FileOutputStream
- BufferedInputStream
- BufferedReader
- File과 Path
- Files 클래스
- 직렬화
- try-with-resources

입출력 API는 Checked Exception을 많이 발생시키므로 이번 글에서 학습한 try-catch, throws, try-with-resources가 실제로 어떻게 사용되는지 자연스럽게 연결해서 이해할 수 있다.

면접과 평가에서 자주 나오는 질문

Checked Exception과 Unchecked Exception의 차이는?

Checked Exception은 컴파일러가 처리 여부를 검사한다.

Unchecked Exception은 처리 여부를 강제하지 않는다.

Checked
→ Exception 하위이지만 RuntimeException 계열이 아님

Unchecked
→ RuntimeException 하위

try에서 return하면 finally는 실행되는가?

일반적으로 실행된다.

finally가 실행된 후 return이 완료된다.

단, System.exit()나 JVM 강제 종료 상황은 예외다.

finally에서 return을 사용하면 어떻게 되는가?

finally의 return이 기존 return이나 예외를 덮어버릴 수 있다.

public int test() {
    try {
        return 1;
    } finally {
        return 2;
    }
}

결과는 2다.

이런 코드는 예외와 원래 반환값을 숨기므로 사용하지 않는 것이 좋다.

throw와 throws의 차이는?

throw
→ 실제 예외 발생

throws
→ 예외 처리 책임 위임

try-with-resources의 조건은?

자원 객체가 AutoCloseable 또는 그 하위 인터페이스를 구현해야 한다.

try-with-resources에서 자원은 어떤 순서로 닫히는가?

선언한 순서의 반대로 닫힌다.

예외를 잡아서 다시 던질 때 주의할 점은?

원래 예외를 cause로 연결해야 한다.

throw new ServiceException(
        "처리 실패",
        e
);

사용자 정의 예외는 Checked와 Unchecked 중 무엇이 좋은가?

호출자가 실제로 복구할 수 있고 처리를 강제할 필요가 있다면 Checked Exception을 고려할 수 있다.

업무 규칙 위반이나 계층 간 전달이 필요한 예외는 RuntimeException으로 설계하는 경우가 많다.

catch (Exception e)는 왜 주의해야 하는가?

처리할 의도가 없는 예외까지 모두 잡아 문제를 숨길 수 있기 때문이다.

최상위 경계에서 공통 처리하는 경우를 제외하면 구체적인 예외를 처리하는 것이 좋다.

들어가며

프로그램은 대부분 여러 데이터를 저장하고 조회하고 수정하며 삭제하는 작업을 반복한다.

회원 관리 프로그램에서는 여러 회원을 저장해야 하고, 쇼핑몰에서는 상품과 주문 목록을 관리해야 한다. 게시판에서는 여러 게시글을 저장하고 검색해야 한다.

여러 데이터를 저장하는 가장 기본적인 방법은 배열이다.

String[] names = new String[3];

names[0] = "김자바";
names[1] = "이자바";
names[2] = "박자바";

하지만 배열은 생성할 때 길이가 결정되고 이후 크기를 변경할 수 없다. 새로운 데이터를 추가하려면 더 큰 배열을 만들고 기존 데이터를 복사해야 한다.

String[] oldNames = {
        "김자바",
        "이자바",
        "박자바"
};

String[] newNames = new String[5];

System.arraycopy(
        oldNames,
        0,
        newNames,
        0,
        oldNames.length
);

데이터의 개수가 계속 변하는 프로그램에서 배열을 직접 관리하는 것은 번거롭다.

Java는 이러한 문제를 해결하기 위해 여러 데이터를 효율적으로 저장하고 처리할 수 있는 컬렉션 프레임워크를 제공한다.

이번 글에서는 컬렉션 프레임워크의 기본 구조와 List, Set, Map의 차이를 살펴본다. 이어서 정렬, 불변 컬렉션, 람다 표현식, 표준 함수형 인터페이스, Optional, Stream API까지 함께 정리해보려고 한다.

자료구조와 컬렉션 프레임워크

자료구조란?

자료구조는 데이터를 효율적으로 저장하고 접근하고 수정하기 위한 데이터의 조직 방식이다.

단순히 여러 값을 보관하는 것뿐 아니라 다음 내용까지 포함한다.

• 데이터가 어떤 형태로 저장되는가
• 데이터 사이에 어떤 관계가 있는가
• 데이터를 어떻게 추가하고 조회하는가
• 데이터를 어떻게 수정하고 삭제하는가
• 특정 데이터를 얼마나 빠르게 찾을 수 있는가

동일한 데이터를 저장하더라도 자료구조에 따라 작업 성능이 달라질 수 있다.

예를 들어 인덱스로 특정 요소를 빠르게 조회하려면 배열 기반 구조가 유리하다. 중간에 데이터를 자주 추가하거나 삭제한다면 연결 구조가 더 적합할 수 있다.

따라서 무조건 좋은 자료구조가 있는 것이 아니라, 어떤 작업을 자주 수행하는지에 따라 적합한 자료구조를 선택해야 한다.

배열과 컬렉션의 차이

배열은 같은 타입의 여러 값을 저장하는 가장 기본적인 자료구조다.

int[] numbers = {10, 20, 30};

배열에는 다음과 같은 특징이 있다.

• 생성할 때 길이가 결정된다.
• 인덱스로 요소에 빠르게 접근할 수 있다.
• 같은 타입의 값만 저장할 수 있다.
• 기본 타입과 참조 타입 모두 저장할 수 있다.

배열의 길이를 동적으로 변경할 수 없다는 점은 가장 큰 불편함이다.

컬렉션은 내부적으로 배열이나 연결 구조 등을 사용하지만 개발자가 크기 변경과 데이터 관리를 직접 처리하지 않아도 된다.

List<String> names = new ArrayList<>();

names.add("김자바");
names.add("이자바");
names.add("박자바");

컬렉션은 데이터가 추가되면 필요한 저장 공간을 내부적으로 관리한다.

Object만 사용했을 때의 문제

모든 객체는 Object를 상속하므로 Object[]를 사용하면 여러 종류의 객체를 함께 저장할 수 있다.

Object[] values = new Object[3];

values[0] = "Java";
values[1] = 100;
values[2] = new Member("김자바");

값을 저장할 때는 편리하지만 꺼낼 때는 Object로 반환되기 때문에 강제 타입 변환이 필요하다.

String language = (String) values[0];
Integer number = (Integer) values[1];

잘못된 타입으로 변환하면 실행 중 ClassCastException이 발생한다.

제네릭을 사용하면 컬렉션이 저장할 타입을 컴파일 단계에서 제한할 수 있다.

List<String> languages = new ArrayList<>();

languages.add("Java");

// languages.add(100);
// 컴파일 오류

값을 꺼낼 때도 형변환이 필요 없다.

String language = languages.get(0);

컬렉션 프레임워크의 구조

컬렉션 프레임워크는 다수의 데이터를 저장하고 처리하기 위한 인터페이스와 구현 클래스의 집합이다.

주요 클래스와 인터페이스는 java.util 패키지에 포함되어 있다.

Collection
├─ List
│  ├─ ArrayList
│  └─ LinkedList
│
└─ Set
   ├─ HashSet
   └─ TreeSet

Map
├─ HashMap
└─ TreeMap

List와 Set은 Collection 인터페이스를 상속한다.

Map은 Key와 Value의 쌍을 관리하는 구조이기 때문에 Collection과는 별도의 계층으로 존재한다.

List, Set, Map 비교

List<String> list = new ArrayList<>();
Set<String> set = new HashSet<>();
Map<String, Integer> map = new HashMap<>();

Collection의 공통 메서드

List와 Set은 Collection 인터페이스를 상속하므로 공통 메서드를 사용할 수 있다.

import java.util.ArrayList;
import java.util.List;

public class CollectionMethodExample {

    public static void main(String[] args) {
        List<String> languages = new ArrayList<>();

        languages.add("Java");
        languages.add("Python");
        languages.add("JavaScript");

        System.out.println(languages.size());
        System.out.println(languages.contains("Java"));
        System.out.println(languages.isEmpty());

        languages.remove("Python");

        System.out.println(languages);

        languages.clear();

        System.out.println(languages.isEmpty());
    }
}

List: 순서가 있는 데이터 관리하기

List의 특징

List는 입력한 순서를 유지하고 중복된 요소를 허용한다.

List<String> names = new ArrayList<>();

names.add("김자바");
names.add("이자바");
names.add("김자바");

결과는 다음과 같다.

[김자바, 이자바, 김자바]

동일한 값이 두 번 저장되어도 모두 유지된다.

순서가 있기 때문에 인덱스로 요소에 접근할 수 있다.

String first = names.get(0);

List의 주요 메서드

import java.util.ArrayList;
import java.util.List;

public class ListMethodExample {

    public static void main(String[] args) {
        List<String> names = new ArrayList<>();

        names.add("김자바");
        names.add("박자바");
        names.add(1, "이자바");

        System.out.println(names);

        String firstName = names.get(0);

        System.out.println(firstName);

        names.set(0, "김Java");
        names.remove(2);

        System.out.println(names);
    }
}

ArrayList

ArrayList는 배열을 기반으로 구현된 List다.

List<String> names = new ArrayList<>();

내부적으로 객체 배열을 사용하고, 저장 공간이 부족해지면 더 큰 배열을 생성한 뒤 기존 요소를 복사한다.

개념적으로 다음과 같은 구조다.

ArrayList

index    0        1        2
       ┌────────┬────────┬────────┐
value  │ "Java" │ "SQL"  │ "HTML" │
       └────────┴────────┴────────┘

배열 기반이므로 인덱스를 이용한 조회가 빠르다.

names.get(1);

반면 배열의 중간에 요소를 추가하거나 삭제하면 뒤에 있는 요소들을 이동해야 한다.

삭제 전

[A][B][C][D]

B 삭제

[A][C][D][ ]

C와 D를 앞으로 이동

초기 용량 지정하기

저장할 데이터 개수를 어느 정도 알고 있다면 초기 용량을 지정할 수 있다.

List<String> names = new ArrayList<>(100);

이 코드는 리스트의 크기를 100으로 만드는 것이 아니다.

요소를 저장할 내부 공간의 초기 용량을 설정한다.

System.out.println(names.size());

결과는 여전히 0이다.

초기 용량을 적절히 지정하면 배열을 반복해서 확장하고 복사하는 비용을 줄일 수 있다. 다만 필요 이상으로 크게 지정하면 메모리를 낭비할 수 있다.

LinkedList

LinkedList는 각 요소가 앞뒤 요소의 정보를 가지고 연결된 구조다.

Java의 LinkedList는 이중 연결 리스트로 구현되어 있다.

null ← [A] ⇄ [B] ⇄ [C] → null

각 노드는 개념적으로 다음 정보를 가진다.

이전 노드 참조
현재 데이터
다음 노드 참조

List<String> names = new LinkedList<>();

배열처럼 모든 요소가 연속된 메모리 공간에 저장될 필요가 없다.

요소의 위치를 이미 알고 있다면 주변 링크를 변경하여 추가하거나 삭제할 수 있다.

A ⇄ B ⇄ C

B 삭제

A ⇄ C

다만 특정 인덱스의 요소를 찾으려면 처음이나 끝에서부터 연결을 따라 이동해야 하므로 인덱스 조회는 ArrayList보다 느릴 수 있다.

ArrayList와 LinkedList 비교

이론적으로는 중간 삽입과 삭제가 LinkedList에 유리해 보이지만, 실제 작업에서는 먼저 해당 위치를 찾는 탐색 비용이 발생한다.

따라서 일반적인 Java 애플리케이션에서는 ArrayList를 기본 선택으로 사용하는 경우가 많다.

앞뒤에서 요소를 자주 추가하거나 제거하는 큐나 덱 구조가 필요하다면 LinkedList보다 ArrayDeque가 더 적합한 경우도 많다.

주요 시간 복잡도

ArrayList의 마지막 추가는 저장 공간 확장이 필요한 순간에는 배열 복사로 O(n)이 걸리지만, 여러 연산을 평균 내면 상각 O(1)로 본다.

반복문에서 요소 삭제 시 주의하기

인덱스를 증가시키면서 요소를 삭제하면 다음 요소의 인덱스가 앞으로 당겨져 검사하지 못하는 요소가 생길 수 있다.

import java.util.ArrayList;
import java.util.List;

public class RemoveExample {

    public static void main(String[] args) {
        List<Integer> numbers =
                new ArrayList<>(
                        List.of(1, 3, 5, 2, 4)
                );

        for (int i = 0; i < numbers.size(); i++) {
            if (numbers.get(i) % 2 == 1) {
                numbers.remove(i);
            }
        }

        System.out.println(numbers);
    }
}

1을 삭제하면 뒤의 3이 인덱스 0으로 이동하지만 i는 1로 증가하므로 3을 확인하지 못할 수 있다.

뒤에서부터 순회하면 인덱스가 밀리는 문제를 피할 수 있다.

for (int i = numbers.size() - 1; i >= 0; i--) {
    if (numbers.get(i) % 2 == 1) {
        numbers.remove(i);
    }
}

메모에 적힌 조건은 다음처럼 수정해야 한다.

i >= 0

i <= 0을 사용하면 마지막 인덱스가 양수인 경우 반복문이 시작되지 않는다.

Iterator로 안전하게 삭제하기

컬렉션을 순회하면서 요소를 삭제해야 한다면 Iterator를 사용할 수 있다.

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorRemoveExample {

    public static void main(String[] args) {
        List<Integer> numbers =
                new ArrayList<>(
                        List.of(1, 2, 3, 4, 5)
                );

        Iterator<Integer> iterator =
                numbers.iterator();

        while (iterator.hasNext()) {
            int number = iterator.next();

            if (number % 2 == 1) {
                iterator.remove();
            }
        }

        System.out.println(numbers);
    }
}

Iterator로 순회 중일 때는 컬렉션의 remove()가 아니라 iterator.remove()를 사용해야 한다.

removeIf()

조건에 맞는 요소를 삭제할 때는 removeIf()가 더 간결하다.

List<Integer> numbers =
        new ArrayList<>(
                List.of(1, 2, 3, 4, 5)
        );

numbers.removeIf(
        number -> number % 2 == 1
);

System.out.println(numbers);

실행 결과는 다음과 같다.

[2, 4]

향상된 for문에서 수정하면 안 되는 이유

다음 코드는 실행 중 ConcurrentModificationException을 발생시킬 수 있다.

for (Integer number : numbers) {
    if (number % 2 == 1) {
        numbers.remove(number);
    }
}

향상된 for문은 내부적으로 Iterator를 사용한다. 순회 중 컬렉션의 구조가 예상하지 못하게 변경되면 반복자가 안전하게 동작할 수 없기 때문에 예외가 발생한다.

요소를 삭제하려면 다음 방법을 사용한다.

• Iterator.remove()
• removeIf()
• 뒤에서부터 인덱스 순회
• 삭제할 요소를 별도로 수집한 뒤 removeAll()

remove(int)와 remove(Object)

List<Integer>에서 remove()를 사용할 때 특히 주의해야 한다.

List<Integer> numbers =
        new ArrayList<>(
                List.of(10, 20, 30)
        );

numbers.remove(1);

1은 삭제할 값이 아니라 인덱스로 해석된다.

결과는 다음과 같다.

[10, 30]

값 10을 삭제하고 싶다면 Integer 객체로 전달해야 한다.

numbers.remove(Integer.valueOf(10));

제네릭은 불공변이다

SpiderMan이 Person의 자식이라고 가정해보자.

public class Person {
}

public class SpiderMan extends Person {
}

배열은 다음 대입이 가능하다.

SpiderMan[] spiderMen =
        new SpiderMan[3];

Person[] people = spiderMen;

배열은 공변이기 때문이다.

하지만 제네릭은 불공변이므로 다음 대입은 불가능하다.

List<SpiderMan> spiderMen =
        new ArrayList<>();

// List<Person> people = spiderMen;
// 컴파일 오류

List<SpiderMan>은 List<Person>의 하위 타입이 아니다.

여러 자식 타입을 읽기 위한 목적이라면 와일드카드를 사용할 수 있다.

List<? extends Person> people = spiderMen;

Arrays.asList()

Arrays.asList()는 배열을 기반으로 고정 크기의 리스트를 만든다.

import java.util.Arrays;
import java.util.List;

public class ArraysAsListExample {

    public static void main(String[] args) {
        List<String> names =
                Arrays.asList(
                        "김자바",
                        "이자바",
                        "박자바"
                );

        names.set(0, "김Java");

        System.out.println(names);
    }
}

요소 변경은 가능하다.

names.set(0, "김Java");

그러나 크기를 변경하는 작업은 불가능하다.

// names.add("최자바");
// UnsupportedOperationException

// names.remove("이자바");
// UnsupportedOperationException

원본 배열과 리스트가 연결되어 있다는 점도 주의해야 한다.

String[] values = {"A", "B"};

List<String> list =
        Arrays.asList(values);

values[0] = "Changed";

System.out.println(list);

결과는 다음과 같다.

[Changed, B]

독립적으로 수정 가능한 ArrayList가 필요하다면 새 리스트로 복사한다.

List<String> names =
        new ArrayList<>(
                Arrays.asList(
                        "김자바",
                        "이자바"
                )
        );

Set: 중복되지 않는 데이터 관리하기

Set의 특징

Set은 중복된 요소를 허용하지 않는 컬렉션이다.

Set<String> languages =
        new HashSet<>();

languages.add("Java");
languages.add("Python");
languages.add("Java");

"Java"를 두 번 추가했지만 한 번만 저장된다.

[Java, Python]

HashSet은 입력 순서를 보장하지 않는다.

System.out.println(languages);

출력 순서는 저장 순서와 다를 수 있다.

순서가 필요하면 목적에 따라 다음 구현체를 고려할 수 있다.

• LinkedHashSet: 입력 순서 유지
• TreeSet: 정렬된 순서 유지

HashSet

HashSet은 해시값을 이용해 데이터를 저장하고 검색한다.

Set<Member> members =
        new HashSet<>();

내부적으로는 HashMap을 사용하며, 저장할 객체를 Key처럼 관리한다.

해시란?

해시는 임의 길이의 데이터를 일정한 규칙에 따라 고정된 범위의 값으로 변환하는 방식이다.

Java 객체는 hashCode() 메서드로 정수 형태의 해시 코드를 반환한다.

String value = "Java";

System.out.println(value.hashCode());

해시 기반 자료구조는 해시 코드를 이용해 데이터가 저장될 위치를 빠르게 찾는다.

개념적인 과정은 다음과 같다.

객체
→ hashCode()
→ 저장 위치 계산
→ 해당 위치에서 equals()로 최종 비교

해시 충돌

서로 다른 객체가 같은 해시값이나 같은 저장 위치를 가질 수 있다. 이를 해시 충돌이라고 한다.

해시 코드는 int 범위의 값이지만 실제로 수십억 개의 배열을 생성할 수는 없다. 내부 배열의 크기에 맞게 저장 위치를 계산하기 때문에 서로 다른 해시 코드도 같은 위치에 배정될 수 있다.

Java의 HashMap은 같은 위치에 여러 요소가 배정되면 연결 구조로 관리한다. 충돌이 많이 발생하고 일정 조건을 만족하면 Java 8부터 일부 구간을 트리 구조로 전환해 검색 성능이 지나치게 떨어지는 것을 줄인다.

따라서 HashSet과 HashMap이 항상 단순한 연결 리스트만 사용하는 것은 아니다.

중복 객체를 판단하는 기준

HashSet은 일반적으로 다음 두 조건을 이용해 논리적으로 같은 객체인지 판단한다.

hashCode()가 같음
그리고
equals()가 true

회원 전화번호가 같으면 같은 회원으로 판단하는 예제를 만들어보자.

import java.util.Objects;

public class SmartPhone {

    private final String number;
    private final String model;

    public SmartPhone(
            String number,
            String model
    ) {
        this.number = number;
        this.model = model;
    }

    @Override
    public boolean equals(Object object) {
        if (this == object) {
            return true;
        }

        if (!(object instanceof SmartPhone phone)) {
            return false;
        }

        return Objects.equals(
                number,
                phone.number
        );
    }

    @Override
    public int hashCode() {
        return Objects.hash(number);
    }

    @Override
    public String toString() {
        return "SmartPhone{"
                + "number='" + number + '\''
                + ", model='" + model + '\''
                + '}';
    }
}

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {

    public static void main(String[] args) {
        Set<SmartPhone> phones =
                new HashSet<>();

        phones.add(
                new SmartPhone(
                        "010-1111-2222",
                        "Model A"
                )
        );

        phones.add(
                new SmartPhone(
                        "010-1111-2222",
                        "Model B"
                )
        );

        System.out.println(phones.size());
        System.out.println(phones);
    }
}

전화번호를 기준으로 equals()와 hashCode()를 재정의했으므로 두 객체를 같은 데이터로 판단한다.

1

equals()를 재정의할 때는 반드시 동일한 필드 기준으로 hashCode()도 함께 재정의해야 한다.

Map: Key와 Value를 함께 관리하기

Map의 특징

Map은 Key와 Value의 쌍으로 데이터를 관리한다.

Key          Value

"apple"   → "사과"
"banana"  → "바나나"
"grape"   → "포도"

하나의 Key와 Value 쌍을 Entry라고 부른다.

Key는 중복될 수 없지만 Value는 중복될 수 있다.

Map<String, Integer> scores =
        new HashMap<>();

scores.put("김자바", 90);
scores.put("이자바", 90);

점수 90은 중복될 수 있다.

같은 Key로 값을 다시 저장하면 기존 값이 교체된다.

scores.put("김자바", 100);

Map의 주요 메서드

HashMap 사용하기

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {

    public static void main(String[] args) {
        Map<String, Integer> scores =
                new HashMap<>();

        scores.put("김자바", 90);
        scores.put("이자바", 85);
        scores.put("박자바", 95);

        int kimScore = scores.get("김자바");

        System.out.println(kimScore);

        scores.put("김자바", 100);

        System.out.println(scores);

        scores.remove("이자바");

        System.out.println(scores);
    }
}

존재하지 않는 Key 조회하기

get()으로 존재하지 않는 Key를 조회하면 null이 반환된다.

Integer score = scores.get("없는 회원");

기본값이 필요하다면 getOrDefault()를 사용할 수 있다.

int score =
        scores.getOrDefault(
                "없는 회원",
                0
        );

Map 순회하기

Key와 Value를 함께 사용할 때는 entrySet()이 편리하다.

for (
        Map.Entry<String, Integer> entry
                : scores.entrySet()
) {
    System.out.println(
            entry.getKey()
                    + ": "
                    + entry.getValue()
    );
}

람다를 사용하면 더 간결하게 작성할 수 있다.

scores.forEach(
        (name, score) ->
                System.out.println(
                        name + ": " + score
                )
);

HashMap의 내부 구조

HashMap은 내부적으로 Key의 hashCode()를 이용해 저장 위치를 계산한다.

개념적으로 다음과 같은 구조를 가진다.

내부 배열

index 0 → Entry
index 1 → Entry → Entry
index 2 → 비어 있음
index 3 → Entry

Entry에는 Key, Value, 해시 정보, 다음 Entry를 가리키는 정보 등이 포함된다.

Key의 중복을 판단할 때도 hashCode()와 equals()가 사용된다.

따라서 사용자 정의 객체를 HashMap의 Key로 사용할 때는 논리적인 동등성 기준에 맞게 두 메서드를 재정의해야 한다.

또한 Key로 사용하는 객체의 비교 기준 필드는 저장 후 변경하지 않는 것이 안전하다. Key의 해시값이 변경되면 저장된 데이터를 다시 찾지 못할 수 있다.

Set과 Map의 관계

HashSet은 내부적으로 HashMap을 이용한다.

Set에 저장할 요소를 HashMap의 Key로 사용하고, Value에는 의미 없는 공통 객체를 저장하는 방식이다.

HashSet 요소
→ HashMap의 Key

내부 Value
→ 공통 더미 객체

이 때문에 HashSet도 HashMap과 마찬가지로 hashCode()와 equals()를 이용해 중복을 판단한다.

컬렉션 생성과 정렬

불변 컬렉션

Java 9부터 List.of(), Set.of(), Map.of()를 이용해 변경할 수 없는 컬렉션을 만들 수 있다.

List<String> languages =
        List.of(
                "Java",
                "Python",
                "JavaScript"
        );

다음 작업은 모두 불가능하다.

// languages.add("C++");
// languages.remove("Java");
// languages.set(0, "Kotlin");

실행하면 UnsupportedOperationException이 발생한다.

List.of(), Set.of(), Map.of()

List<String> list =
        List.of("A", "B", "C");

Set<String> set =
        Set.of("A", "B", "C");

Map<String, Integer> map =
        Map.of(
                "A", 10,
                "B", 20
        );

이 컬렉션들은 null을 허용하지 않는다.

// List.of("A", null);
// NullPointerException

Set.of()에는 중복값을 전달할 수 없다.

// Set.of("A", "A");
// IllegalArgumentException

Map.of()도 중복된 Key를 허용하지 않는다.

수정 가능한 컬렉션으로 복사하기

List.of()로 만든 데이터를 수정해야 한다면 새 컬렉션으로 복사한다.

List<String> languages =
        new ArrayList<>(
                List.of(
                        "Java",
                        "Python"
                )
        );

languages.add("JavaScript");

Arrays.asList()와 List.of() 비교

List 정렬하기

Collections.sort()를 이용해 리스트를 오름차순으로 정렬할 수 있다.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SortExample {

    public static void main(String[] args) {
        List<Integer> numbers =
                new ArrayList<>(
                        List.of(5, 2, 4, 1, 3)
                );

        Collections.sort(numbers);

        System.out.println(numbers);
    }
}

실행 결과는 다음과 같다.

[1, 2, 3, 4, 5]

List의 sort() 메서드를 사용할 수도 있다.

numbers.sort(null);

내림차순 정렬

numbers.sort(
        Collections.reverseOrder()
);

Comparator를 사용하면 다음과 같이 작성할 수도 있다.

numbers.sort(
        (left, right) ->
                Integer.compare(
                        right,
                        left
                )
);

사용자 정의 객체 정렬

회원 객체를 나이순으로 정렬해보자.

public class Member {

    private final String name;
    private final int age;

    public Member(
            String name,
            int age
    ) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return name + "(" + age + ")";
    }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class MemberSortExample {

    public static void main(String[] args) {
        List<Member> members =
                new ArrayList<>(
                        List.of(
                                new Member("김자바", 25),
                                new Member("이자바", 20),
                                new Member("박자바", 30)
                        )
                );

        members.sort(
                Comparator.comparingInt(
                        Member::getAge
                )
        );

        System.out.println(members);
    }
}

나이가 같은 경우 이름으로 추가 정렬할 수 있다.

members.sort(
        Comparator
                .comparingInt(Member::getAge)
                .thenComparing(Member::getName)
);

Comparable과 Comparator

클래스 자체에 자연스러운 기본 정렬 기준이 있다면 Comparable을 구현할 수 있다.

다양한 정렬 기준이 필요하다면 Comparator가 더 유연하다.

람다 표현식으로 동작 전달하기

람다 표현식이란?

람다 표현식은 하나의 동작을 간결한 코드 블록으로 표현하는 문법이다.

기존에는 간단한 동작 하나를 전달하기 위해 익명 구현 객체를 만들어야 했다.

Comparator<Integer> comparator =
        new Comparator<Integer>() {

            @Override
            public int compare(
                    Integer left,
                    Integer right
            ) {
                return Integer.compare(
                        left,
                        right
                );
            }
        };

람다 표현식을 사용하면 다음처럼 줄일 수 있다.

Comparator<Integer> comparator =
        (left, right) ->
                Integer.compare(
                        left,
                        right
                );

람다는 메서드 자체가 아니라 함수형 인터페이스의 구현 객체로 해석된다.

함수형 인터페이스

추상 메서드가 하나만 존재하는 인터페이스를 함수형 인터페이스라고 한다.

@FunctionalInterface
public interface Calculator {

    int calculate(int left, int right);
}

람다 표현식을 구현 객체로 대입할 수 있다.

Calculator add =
        (left, right) ->
                left + right;

int result = add.calculate(10, 20);

@FunctionalInterface는 해당 인터페이스가 함수형 인터페이스의 조건을 만족하는지 컴파일러가 검사하도록 한다.

default 메서드와 static 메서드는 여러 개 존재해도 상관없다. 추상 메서드만 하나여야 한다.

람다 문법

매개변수가 하나라면 괄호를 생략할 수 있다.

value -> System.out.println(value)

실행문이 하나라면 중괄호를 생략할 수 있다.

(left, right) -> left + right

실행문이 여러 개라면 중괄호를 사용한다.

(left, right) -> {
    int result = left + right;

    return result;
}

중괄호를 사용하면서 값을 반환하려면 return이 필요하다.

컬렉션과 람다

컬렉션 API에는 람다 표현식을 사용할 수 있는 메서드가 많다.

List<String> names =
        new ArrayList<>(
                List.of(
                        "김자바",
                        "이자바",
                        "박자바"
                )
        );

names.forEach(
        name ->
                System.out.println(name)
);

조건에 맞는 요소를 삭제할 수도 있다.

names.removeIf(
        name -> name.startsWith("김")
);

모든 요소를 변경할 수도 있다.

names.replaceAll(
        String::toUpperCase
);

메서드 참조

람다 표현식이 기존 메서드 하나만 호출한다면 :: 연산자를 이용한 메서드 참조로 표현할 수 있다.

names.forEach(
        name ->
                System.out.println(name)
);

다음처럼 변경할 수 있다.

names.forEach(
        System.out::println
);

정적 메서드 참조

Function<String, Integer> parser =
        Integer::parseInt;

다음 람다와 같다.

Function<String, Integer> parser =
        value -> Integer.parseInt(value);

특정 객체의 인스턴스 메서드 참조

String prefix = "Java";

Predicate<String> checker =
        prefix::equals;

다음 람다와 같다.

Predicate<String> checker =
        value -> prefix.equals(value);

임의 객체의 인스턴스 메서드 참조

Function<String, String> converter =
        String::toUpperCase;

다음 람다와 같다.

Function<String, String> converter =
        value -> value.toUpperCase();

생성자 참조

Supplier<StringBuilder> supplier =
        StringBuilder::new;

다음 람다와 같다.

Supplier<StringBuilder> supplier =
        () -> new StringBuilder();

매개변수가 있는 생성자도 참조할 수 있다.

Function<String, StringBuilder> creator =
        StringBuilder::new;

순회 중 같은 컬렉션을 수정하지 않기

다음 코드는 잘못된 예제다.

// names.forEach(names::add);

names를 순회하면서 같은 names에 다시 데이터를 추가하기 때문에 구조적 변경이 발생한다. ConcurrentModificationException이 발생하거나 의도하지 않은 동작으로 이어질 수 있다.

출력하려면 다음처럼 사용해야 한다.

names.forEach(System.out::println);

다른 컬렉션에 복사하려면 목적지 컬렉션을 별도로 둔다.

List<String> copied =
        new ArrayList<>();

names.forEach(copied::add);

표준 함수형 인터페이스

Java는 자주 사용하는 함수 형태를 java.util.function 패키지의 표준 인터페이스로 제공한다.

Consumer
Supplier
Function
Operator
Predicate

직접 함수형 인터페이스를 만들 필요 없이 목적에 맞는 표준 인터페이스를 사용할 수 있다.

Consumer

매개값을 받고 반환값이 없는 형태다.

T → 반환값 없음

Consumer<String> printer =
        value ->
                System.out.println(value);

printer.accept("Java");

메서드 참조로 표현할 수 있다.

Consumer<String> printer =
        System.out::println;

대표 메서드는 accept()다.

Supplier

매개값은 없고 값을 반환하는 형태다.

매개값 없음 → T

Supplier<StringBuilder> supplier =
        StringBuilder::new;

StringBuilder builder = supplier.get();

대표 메서드는 get()이다.

Function

매개값을 받아 다른 값을 반환한다.

T → R

Function<String, Integer> lengthFunction =
        String::length;

int length =
        lengthFunction.apply("Java");

대표 메서드는 apply()다.

Operator

매개값과 반환값의 타입이 같은 함수다.

T → T

하나의 값을 받아 같은 타입으로 반환하는 경우 UnaryOperator를 사용한다.

UnaryOperator<Integer> doubleValue =
        number -> number * 2;

System.out.println(
        doubleValue.apply(10)
);

두 값을 받아 같은 타입으로 반환하는 경우 BinaryOperator를 사용한다.

BinaryOperator<Integer> add =
        Integer::sum;

System.out.println(
        add.apply(10, 20)
);

Predicate

매개값을 받아 boolean을 반환한다.

T → boolean

Predicate<Integer> isEven =
        number -> number % 2 == 0;

System.out.println(
        isEven.test(10)
);

대표 메서드는 test()다.

필터링과 조건 검사에 많이 사용된다.

표준 함수형 인터페이스 비교

Optional과 Stream API

Optional이란?

Optional<T>은 값이 존재할 수도 있고 존재하지 않을 수도 있는 상황을 표현하는 래퍼 클래스다.

Optional<Member>

메서드가 null을 직접 반환하는 대신 값의 존재 여부를 명시적으로 표현할 수 있다.

import java.util.Optional;

public class MemberRepository {

    public Optional<String> findNameById(
            long id
    ) {
        if (id == 1L) {
            return Optional.of("김자바");
        }

        return Optional.empty();
    }
}

Optional 사용하기

Optional<String> name =
        repository.findNameById(1L);

if (name.isPresent()) {
    System.out.println(name.get());
}

다만 isPresent()와 get()을 반복해서 사용하는 것보다는 Optional 전용 메서드를 활용하는 것이 좋다.

name.ifPresent(
        System.out::println
);

값이 없을 때 기본값을 반환할 수 있다.

String result =
        name.orElse("이름 없음");

기본값 생성 비용이 크다면 orElseGet()을 사용할 수 있다.

String result =
        name.orElseGet(
                () -> createDefaultName()
        );

값이 없을 때 예외를 발생시킬 수도 있다.

String result =
        name.orElseThrow(
                () -> new IllegalArgumentException(
                        "회원을 찾을 수 없습니다."
                )
        );

orElse와 orElseGet의 차이

optional.orElse(
        createDefaultValue()
);

orElse()에 전달한 코드는 Optional에 값이 있어도 먼저 실행될 수 있다.

optional.orElseGet(
        () -> createDefaultValue()
);

orElseGet()은 값이 없을 때만 Supplier를 실행한다.

기본값 생성에 비용이 들거나 부수 효과가 있다면 orElseGet()이 적합하다.

Optional 사용 시 주의할 점

Optional은 주로 메서드 반환값에서 값이 없을 가능성을 표현하기 위해 사용한다.

다음과 같은 사용은 일반적으로 신중해야 한다.

• 엔티티나 DTO의 필드 타입으로 사용
• 메서드 매개변수로 사용
• 컬렉션 자체를 Optional로 감싸기
• Optional<List<T>>처럼 불필요하게 중첩하기
• 무조건 get() 호출하기

컬렉션은 결과가 없으면 빈 컬렉션을 반환하는 것이 자연스럽다.

return List.of();

Stream API란?

Stream API는 배열과 컬렉션의 요소를 선언적인 방식으로 처리하기 위한 API다.

기존 반복문에서는 처리 절차를 직접 작성한다.

List<Integer> numbers =
        List.of(1, 2, 3, 4, 5);

List<Integer> evenNumbers =
        new ArrayList<>();

for (Integer number : numbers) {
    if (number % 2 == 0) {
        evenNumbers.add(number);
    }
}

Stream을 사용하면 어떤 작업을 할 것인지 중심으로 작성할 수 있다.

List<Integer> evenNumbers =
        numbers.stream()
                .filter(
                        number ->
                                number % 2 == 0
                )
                .toList();

Stream의 처리 흐름

Stream 연산은 크게 세 단계로 볼 수 있다.

데이터 소스
→ 중간 연산
→ 최종 연산

numbers.stream()
        .filter(number -> number % 2 == 0)
        .map(number -> number * 10)
        .forEach(System.out::println);

• stream(): 스트림 생성
• filter(): 조건에 맞는 요소 선택
• map(): 요소 변환
• forEach(): 결과 소비

중간 연산과 최종 연산

중간 연산은 새로운 Stream을 반환하며 여러 개 연결할 수 있다.

대표적인 중간 연산은 다음과 같다.

• filter()
• map()
• sorted()
• distinct()
• limit()
• skip()
• peek()

최종 연산이 호출되어야 실제 처리가 시작된다.

대표적인 최종 연산은 다음과 같다.

• forEach()
• toList()
• collect()
• count()
• reduce()
• findFirst()
• anyMatch()
• allMatch()

Stream은 원본 컬렉션을 변경하지 않는다

List<Integer> numbers =
        new ArrayList<>(
                List.of(5, 2, 4, 1, 3)
        );

List<Integer> sortedNumbers =
        numbers.stream()
                .sorted()
                .toList();

System.out.println(numbers);
System.out.println(sortedNumbers);

실행 결과는 다음과 같다.

[5, 2, 4, 1, 3]
[1, 2, 3, 4, 5]

Stream 연산은 원본 컬렉션 자체를 정렬하지 않고 새로운 결과를 만든다.

map 연산

map()은 각 요소를 다른 값으로 변환한다.

List<String> names =
        List.of(
                "java",
                "spring",
                "vue"
        );

List<String> upperNames =
        names.stream()
                .map(String::toUpperCase)
                .toList();

reduce 연산

reduce()는 여러 요소를 하나의 결과로 합친다.

List<Integer> numbers =
        List.of(1, 2, 3, 4, 5);

int sum =
        numbers.stream()
                .reduce(
                        0,
                        Integer::sum
                );

System.out.println(sum);

0은 초기값이며 Integer::sum은 두 값을 합치는 함수다.

맵과 리듀스 모델

Map-Reduce 모델은 데이터를 변환한 뒤 결과를 하나로 합치는 처리 방식이다.

원본 데이터

[1, 2, 3, 4]

map
각 값을 제곱

[1, 4, 9, 16]

reduce
모든 값을 합산

30

int result =
        List.of(1, 2, 3, 4)
                .stream()
                .map(
                        number ->
                                number * number
                )
                .reduce(
                        0,
                        Integer::sum
                );

종합 예제: 회원 목록 처리하기

회원 데이터를 컬렉션에 저장하고 Stream으로 처리해보자.

Member 클래스

import java.util.Objects;

public class Member {

    private final long id;
    private final String name;
    private final int age;
    private final Grade grade;

    public Member(
            long id,
            String name,
            int age,
            Grade grade
    ) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.grade = grade;
    }

    public long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Grade getGrade() {
        return grade;
    }

    @Override
    public boolean equals(Object object) {
        if (this == object) {
            return true;
        }

        if (!(object instanceof Member member)) {
            return false;
        }

        return id == member.id;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }

    @Override
    public String toString() {
        return name
                + "("
                + age
                + ", "
                + grade
                + ")";
    }
}

Grade Enum

public enum Grade {
    BASIC,
    SILVER,
    GOLD
}

실행 클래스

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class CollectionExample {

    public static void main(String[] args) {
        List<Member> members =
                new ArrayList<>();

        members.add(
                new Member(
                        1L,
                        "김자바",
                        25,
                        Grade.GOLD
                )
        );

        members.add(
                new Member(
                        2L,
                        "이자바",
                        20,
                        Grade.BASIC
                )
        );

        members.add(
                new Member(
                        3L,
                        "박자바",
                        30,
                        Grade.SILVER
                )
        );

        members.add(
                new Member(
                        4L,
                        "최자바",
                        22,
                        Grade.GOLD
                )
        );

        List<String> adultGoldMembers =
                members.stream()
                        .filter(
                                member ->
                                        member.getAge() >= 20
                        )
                        .filter(
                                member ->
                                        member.getGrade()
                                                == Grade.GOLD
                        )
                        .sorted(
                                Comparator.comparingInt(
                                        Member::getAge
                                )
                        )
                        .map(Member::getName)
                        .toList();

        System.out.println(adultGoldMembers);

        Set<Member> memberSet =
                new HashSet<>(members);

        System.out.println(
                "중복 제거 후 회원 수: "
                        + memberSet.size()
        );

        Map<Long, Member> memberMap =
                new HashMap<>();

        for (Member member : members) {
            memberMap.put(
                    member.getId(),
                    member
            );
        }

        Member found =
                memberMap.get(1L);

        System.out.println(
                "조회 결과: " + found
        );
    }
}

이 예제에서는 다음 개념이 사용되었다.

• ArrayList에 회원 목록 저장
• HashSet으로 중복 관리
• HashMap으로 ID 기반 조회
• Enum으로 회원 등급 제한
• 람다와 메서드 참조
• Stream의 filter(), sorted(), map()
• equals()와 hashCode()를 이용한 동등성 판단

헷갈리기 쉬운 개념

Collection과 Collections

Collection

List와 Set의 최상위 인터페이스다.

Collections

컬렉션을 정렬하거나 변환하는 정적 유틸리티 메서드를 제공하는 클래스다.

Collections.sort(list);
Collections.reverse(list);
Collections.shuffle(list);

List와 ArrayList

List<String> names =
        new ArrayList<>();

List는 인터페이스이고 ArrayList는 구현 클래스다.

변수는 인터페이스 타입으로 선언하는 것이 구현체 교체에 유리하다.

List<String> names =
        new LinkedList<>();

다만 ArrayList에만 존재하는 기능이 반드시 필요하다면 구체 타입을 사용할 수도 있다.

크기와 용량

List<String> names =
        new ArrayList<>(100);

초기 용량은 100이지만 실제 요소 개수는 0이다.

names.size();

결과는 0이다.

• 크기: 현재 저장된 요소 개수
• 용량: 내부 배열이 요소를 저장할 수 있는 공간

HashSet의 순서

HashSet은 입력 순서를 보장하지 않는다.

입력 순서가 필요하면 LinkedHashSet, 정렬된 순서가 필요하면 TreeSet을 고려한다.

Map은 Collection이 아니다

Map은 여러 데이터를 관리하지만 Collection 인터페이스를 상속하지 않는다.

Key와 Value의 쌍을 관리하는 구조가 List와 Set의 단일 요소 구조와 다르기 때문이다.

HashMap의 Key와 변경 가능한 객체

객체를 HashMap의 Key로 사용한 뒤 hashCode() 계산에 사용된 필드 값을 변경하면 해당 Key를 다시 찾지 못할 수 있다.

따라서 Map의 Key는 String, Integer, Enum, 불변 값 객체처럼 변경되지 않는 타입을 사용하는 것이 안전하다.

Stream과 컬렉션

컬렉션은 데이터를 저장한다.

Stream은 데이터를 저장하지 않고 데이터 처리 과정을 표현한다.

Collection
→ 데이터 저장

Stream
→ 데이터 처리

Stream은 한 번 최종 연산을 수행하면 다시 사용할 수 없다.

Stream<String> stream =
        names.stream();

stream.forEach(System.out::println);

// 같은 stream 재사용 불가

실무에서는 어떻게 사용할까?

일반적인 목록 관리에는 ArrayList가 가장 자주 사용된다.

List<Member> members =
        new ArrayList<>();

중복을 허용하지 않는 태그, 권한, 식별자 집합에는 HashSet이 적합하다.

Set<String> tags =
        new HashSet<>();

ID나 코드로 특정 객체를 빠르게 조회해야 한다면 HashMap을 사용할 수 있다.

Map<Long, Member> memberById =
        new HashMap<>();

하지만 데이터가 데이터베이스에 저장되어 있다면 애플리케이션에서 모든 데이터를 Map으로 복사하기보다 데이터베이스의 인덱스와 조회 기능을 활용해야 한다.

컬렉션 타입은 가능하면 인터페이스로 선언한다.

List<Member> members =
        new ArrayList<>();

Map<Long, Member> memberMap =
        new HashMap<>();

외부에 컬렉션을 반환할 때 내부 컬렉션이 직접 변경되면 안 된다면 불변 복사본을 반환할 수 있다.

public List<Member> getMembers() {
    return List.copyOf(members);
}

Stream은 필터링, 변환, 집계가 연속적으로 이어질 때 가독성이 좋다.

members.stream()
        .filter(Member::isActive)
        .map(Member::getName)
        .sorted()
        .toList();

반면 복잡한 상태 변경, 예외 처리, 여러 단계의 분기가 포함되면 일반 반복문이 더 명확할 수 있다. Stream을 사용한다고 항상 더 좋은 코드는 아니다.

오늘 배운 내용 정리

이번 글에서는 Java 컬렉션 프레임워크와 함수형 데이터 처리 방법을 정리했다.

• 자료구조는 데이터를 효율적으로 저장하고 접근하고 수정하기 위한 조직 방식이다.
• 배열은 길이가 고정되어 있어 데이터 개수가 자주 변하는 상황에서 불편할 수 있다.
• 컬렉션 프레임워크는 여러 데이터를 쉽게 저장하고 처리하기 위한 인터페이스와 클래스의 집합이다.
• List는 입력 순서를 유지하고 중복을 허용한다.
• Set은 중복을 허용하지 않는다.
• Map은 Key와 Value의 쌍으로 데이터를 관리한다.
• Map의 Key는 중복될 수 없지만 Value는 중복될 수 있다.
• ArrayList는 배열 기반이므로 인덱스 조회가 빠르다.
• ArrayList의 중간 삽입과 삭제에는 요소 이동이 필요하다.
• LinkedList는 각 요소가 앞뒤 노드의 참조를 가지는 이중 연결 구조다.
• LinkedList는 인덱스 조회를 위해 연결을 따라 이동해야 한다.
• 일반적인 목록에는 ArrayList가 기본 선택으로 자주 사용된다.
• 컬렉션 순회 중 직접 요소를 삭제하면 ConcurrentModificationException이 발생할 수 있다.
• 순회 중 삭제에는 Iterator.remove() 또는 removeIf()를 사용할 수 있다.
• 인덱스로 삭제할 때는 뒤에서부터 순회하면 인덱스 이동 문제를 피할 수 있다.
• List<Integer>의 remove(int)는 값이 아니라 인덱스를 삭제한다.
• 제네릭은 불공변이므로 List<Dog>는 List<Animal>의 하위 타입이 아니다.
• Arrays.asList()는 크기를 변경할 수 없지만 요소 교체는 가능하다.
• HashSet과 HashMap은 hashCode()와 equals()를 이용해 객체를 구분한다.
• equals()를 재정의하면 hashCode()도 같은 기준으로 재정의해야 한다.
• HashSet은 내부적으로 HashMap을 사용한다.
• 사용자 정의 객체를 Map의 Key로 사용할 때는 비교 기준 필드를 변경하지 않는 것이 좋다.
• List.of(), Set.of(), Map.of()는 변경할 수 없는 컬렉션을 생성한다.
• List.of() 계열은 null을 허용하지 않는다.
• Collections.sort()나 List.sort()를 이용해 리스트를 정렬할 수 있다.
• Comparable은 클래스의 기본 정렬 기준을 정의한다.
• Comparator는 외부에서 다양한 정렬 기준을 제공한다.
• 람다 표현식은 함수형 인터페이스의 구현을 간결하게 표현한다.
• 함수형 인터페이스에는 추상 메서드가 하나만 존재해야 한다.
• 메서드 참조는 기존 메서드 하나를 호출하는 람다를 간결하게 표현한다.
• Consumer는 매개값을 받고 반환하지 않는다.
• Supplier는 매개값 없이 값을 반환한다.
• Function은 값을 받아 다른 값으로 변환한다.
• Operator는 동일한 타입을 받아 동일한 타입으로 반환한다.
• Predicate는 값을 받아 boolean을 반환한다.
• Optional은 값이 존재할 수도 있고 없을 수도 있는 상황을 표현한다.
• Optional의 값을 꺼낼 때 무조건 get()을 사용하는 것은 피하는 것이 좋다.
• Stream API는 배열과 컬렉션의 요소를 선언적인 방식으로 처리한다.
• Stream은 데이터를 저장하지 않으며 원본 컬렉션을 직접 변경하지 않는다.
• filter()는 조건에 맞는 요소를 선택한다.
• map()은 요소를 다른 값으로 변환한다.
• reduce()는 여러 요소를 하나의 결과로 합친다.
• Stream의 중간 연산은 최종 연산이 호출될 때 실행된다.

들어가며

Java로 프로그램을 작성하다 보면 다음과 같은 코드를 자주 만나게 된다.

List<String> names = new ArrayList<>();
Map<String, Integer> scores = new HashMap<>();

여기서 <String>, <Integer>처럼 사용할 타입을 지정하는 문법이 제네릭(Generic) 이다.

또한 주문 상태나 회원 등급처럼 사용할 수 있는 값이 제한되어 있다면 다음과 같이 enum을 사용한다.

OrderStatus status = OrderStatus.PAID;

메서드 위에 붙는 @Override, @Deprecated와 같은 표현도 자주 볼 수 있다.

@Override
public String toString() {
    return "Member";
}

이처럼 제네릭, 열거 타입, 어노테이션은 서로 완전히 다른 문법처럼 보이지만 모두 프로그램의 타입 안정성을 높이고 코드의 의미를 명확하게 만드는 데 사용된다.

이번 글에서는 제네릭이 필요한 이유부터 제네릭 클래스와 메서드, 타입 제한, 와일드카드, 타입 소거를 살펴본다. 이어서 Enum을 이용해 제한된 값을 안전하게 관리하는 방법과 Annotation으로 코드에 메타데이터를 추가하는 방법까지 정리해보려고 한다.

제네릭으로 타입을 안전하게 관리하기

제네릭이란?

제네릭은 클래스, 인터페이스, 메서드에서 사용할 타입을 외부에서 지정할 수 있도록 만드는 문법이다.

제네릭을 사용하면 다양한 타입의 객체를 하나의 코드로 처리하면서도 컴파일 단계에서 타입을 검사할 수 있다.

List<String> names = new ArrayList<>();

위 코드는 names 리스트가 String 객체만 저장하도록 제한한다.

names.add("Java");

// names.add(100);
// 컴파일 오류

잘못된 타입을 저장하려고 하면 프로그램 실행 전 컴파일 단계에서 오류를 발견할 수 있다.

Object만 사용했을 때의 문제

제네릭이 도입되기 전에는 다양한 객체를 저장하기 위해 Object 타입을 많이 사용했다.

public class ObjectBox {

    private Object value;

    public void set(Object value) {
        this.value = value;
    }

    public Object get() {
        return value;
    }
}

모든 클래스는 Object를 상속하므로 어떤 객체든 저장할 수 있다.

ObjectBox box = new ObjectBox();

box.set("Java");

하지만 값을 꺼낼 때마다 강제 타입 변환이 필요하다.

String value = (String) box.get();

실수로 잘못된 타입으로 변환하면 실행 중 ClassCastException이 발생한다.

box.set(100);

String value = (String) box.get();

이 코드는 컴파일될 수 있지만 실행 중 오류가 발생한다.

제네릭을 사용하면 이러한 문제를 컴파일 단계에서 방지할 수 있다.

제네릭 클래스 선언

클래스 이름 뒤에 <T>와 같이 타입 파라미터를 선언하면 제네릭 클래스를 만들 수 있다.

public class Box<T> {

    private T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }
}

T는 실제 타입이 아니라 나중에 사용할 타입이 들어갈 자리다.

문자열을 저장하려면 다음과 같이 사용한다.

public class BoxExample {

    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();

        stringBox.set("Java");

        String value = stringBox.get();

        System.out.println(value);
    }
}

정수를 저장하는 객체도 같은 클래스로 만들 수 있다.

Box<Integer> integerBox = new Box<>();

integerBox.set(100);

Integer number = integerBox.get();

하나의 Box 클래스를 여러 타입에 재사용하면서도 각 객체에는 지정된 타입만 저장할 수 있다.

타입 파라미터 이름

타입 파라미터의 이름은 자유롭게 작성할 수 있지만 일반적으로 한 글자의 대문자를 사용한다.

예를 들어 Map은 키와 값을 사용하므로 다음과 같이 표현한다.

Map<K, V>

실제 사용 시에는 구체적인 타입을 전달한다.

Map<String, Integer> scores = new HashMap<>();

여러 개의 타입 파라미터

하나의 제네릭 클래스에 여러 타입 파라미터를 선언할 수도 있다.

public class Pair<K, V> {

    private final K key;
    private final V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }
}

사용할 때는 각 타입을 지정한다.

public class PairExample {

    public static void main(String[] args) {
        Pair<String, Integer> score =
                new Pair<>("김자바", 95);

        System.out.println(score.getKey());
        System.out.println(score.getValue());
    }
}

제네릭 인터페이스

인터페이스도 제네릭으로 선언할 수 있다.

public interface Repository<T> {

    void save(T value);

    T findById(long id);
}

구현 클래스에서 실제 타입을 지정한다.

public class MemberRepository
        implements Repository<Member> {

    @Override
    public void save(Member value) {
        System.out.println(
                value.getName() + " 저장"
        );
    }

    @Override
    public Member findById(long id) {
        return new Member(id, "김자바");
    }
}

Repository<Member>로 구현했기 때문에 모든 메서드가 Member 타입을 기준으로 동작한다.

제네릭의 장점

제네릭을 사용하는 가장 큰 이유는 타입 안정성과 코드 재사용성이다.

제네릭을 사용하지 않는 경우

Object로 저장
→ 값을 꺼냄
→ 강제 타입 변환
→ 실행 중 오류 가능

제네릭을 사용하는 경우

사용할 타입 지정
→ 컴파일러가 타입 검사
→ 형변환 없이 사용

제네릭을 사용하면 다음과 같은 장점이 있다.

• 잘못된 타입 사용을 컴파일 단계에서 차단한다.
• 값을 꺼낼 때 강제 타입 변환이 필요 없다.
• 하나의 클래스나 메서드를 여러 타입에 재사용할 수 있다.
• 코드의 의도가 더 명확해진다.

제네릭 사용 시 알아야 할 규칙

Raw Type

제네릭 클래스에서 타입 인수를 생략한 형태를 Raw Type이라고 한다.

Box box = new Box();

컴파일은 가능하지만 제네릭의 타입 검사가 제대로 적용되지 않는다.

box.set("Java");
box.set(100);

서로 다른 타입의 값을 자유롭게 저장할 수 있기 때문에 타입 안정성을 잃는다.

String value = (String) box.get();

저장된 값이 Integer라면 실행 중 오류가 발생할 수 있다.

따라서 특별한 이유가 없다면 Raw Type을 사용하지 않아야 한다.

Box<String> box = new Box<>();

@SuppressWarnings

Raw Type이나 확인되지 않은 형변환을 사용하면 컴파일러가 경고를 표시한다.

@SuppressWarnings("rawtypes")

여러 경고를 동시에 억제할 수도 있다.

@SuppressWarnings({
        "rawtypes",
        "unchecked",
        "unused"
})

다만 경고를 숨긴다고 코드의 문제가 해결되는 것은 아니다.

@SuppressWarnings는 경고가 발생하는 이유를 정확하게 이해하고, 해당 코드가 안전하다는 것을 보장할 수 있을 때만 제한적으로 사용해야 한다.

기본 타입은 제네릭 타입으로 사용할 수 없다

제네릭의 타입 인수에는 기본 타입을 직접 사용할 수 없다.

// Box<int> box;
// 사용할 수 없음

기본 타입 대신 래퍼 클래스를 사용해야 한다.

Box<Integer> box = new Box<>();
Box<Double> doubleBox = new Box<>();

컬렉션에서도 동일하다.

List<Integer> numbers = new ArrayList<>();

int 값은 오토박싱을 통해 Integer 객체로 변환되어 저장된다.

numbers.add(10);

개념적으로 다음과 같은 변환이 일어난다.

numbers.add(Integer.valueOf(10));

static 멤버에서 클래스 타입 파라미터를 사용할 수 없다

클래스의 타입 파라미터는 객체를 생성할 때 결정된다.

Box<String> stringBox = new Box<>();
Box<Integer> integerBox = new Box<>();

반면 static 멤버는 객체가 아니라 클래스에 소속된다.

따라서 클래스 타입 파라미터 T를 정적 필드나 정적 메서드에서 직접 사용할 수 없다.

public class Box<T> {

    // 사용할 수 없음
    // private static T value;
}

각 객체마다 T가 다를 수 있는데 정적 필드는 모든 객체가 하나를 공유하기 때문이다.

정적 메서드에서 제네릭이 필요하다면 메서드 자체에 별도의 타입 파라미터를 선언해야 한다.

public static <T> void print(T value) {
    System.out.println(value);
}

제네릭 메서드

메서드의 반환 타입 앞에 타입 파라미터를 선언하면 제네릭 메서드를 만들 수 있다.

public class GenericMethodExample {

    public static <T> void print(T value) {
        System.out.println(value);
    }

    public static void main(String[] args) {
        print("Java");
        print(100);
        print(3.14);
    }
}

호출할 때 전달한 인수를 기준으로 타입이 추론된다.

print("Java");

위 호출에서는 T가 String으로 결정된다.

명시적으로 타입을 지정할 수도 있다.

GenericMethodExample.<String>print("Java");

대부분의 경우 컴파일러가 타입을 추론하므로 직접 작성할 필요는 없다.

제네릭 메서드의 반환값

제네릭 메서드는 전달받은 타입과 동일한 타입의 값을 반환할 수 있다.

public class GenericMethodExample {

    public static <T> T getFirst(T[] values) {
        if (values == null || values.length == 0) {
            return null;
        }

        return values[0];
    }

    public static void main(String[] args) {
        String[] names = {"Java", "Spring"};
        Integer[] numbers = {10, 20, 30};

        String firstName = getFirst(names);
        Integer firstNumber = getFirst(numbers);

        System.out.println(firstName);
        System.out.println(firstNumber);
    }
}

타입의 범위를 제한하기

한정 타입 파라미터

모든 타입을 허용하지 않고 특정 타입과 그 하위 타입만 사용하도록 제한할 수 있다.

<T extends Number>

위 선언은 T가 Number이거나 Number의 하위 타입이어야 한다는 뜻이다.

public class NumberCalculator {

    public static <T extends Number>
    double doubleValue(T number) {
        return number.doubleValue();
    }

    public static void main(String[] args) {
        System.out.println(doubleValue(10));
        System.out.println(doubleValue(3.14));

        // doubleValue("Java");
        // 컴파일 오류
    }
}

Integer, Double, Long 등은 Number를 상속하므로 사용할 수 있다.

인터페이스로 타입 제한하기

클래스뿐 아니라 인터페이스를 기준으로도 제한할 수 있다.

<T extends Comparable<T>>

여기서 extends는 클래스 상속뿐 아니라 인터페이스 구현까지 포함하는 의미로 사용된다.

public static <T extends Comparable<T>>
T max(T first, T second) {
    if (first.compareTo(second) >= 0) {
        return first;
    }

    return second;
}

public class MaxExample {

    public static <T extends Comparable<T>>
    T max(T first, T second) {
        return first.compareTo(second) >= 0
                ? first
                : second;
    }

    public static void main(String[] args) {
        System.out.println(max(10, 20));
        System.out.println(max("Java", "Spring"));
    }
}

여러 제한 조건

여러 타입 제한을 동시에 적용할 수 있다.

<T extends Parent & InterfaceA & InterfaceB>

클래스 제한이 있다면 가장 앞에 한 번만 작성해야 한다.

<T extends Number & Comparable<T>>

클래스는 하나만 사용할 수 있지만 인터페이스는 여러 개 지정할 수 있다.

타입 소거와 제네릭의 한계

타입 소거란?

Java의 제네릭 타입 정보는 주로 컴파일 단계에서 타입 검사를 위해 사용된다.

컴파일러는 제네릭 코드를 검사하고 필요한 형변환 등을 추가한 뒤 일부 타입 정보를 제거한다. 이를 타입 소거(Type Erasure) 라고 한다.

예를 들어 다음 코드가 있다고 가정해보자.

Box<String> stringBox = new Box<>();
Box<Integer> integerBox = new Box<>();

런타임에는 Box<String>과 Box<Integer>가 완전히 별개의 클래스 파일로 생성되는 것이 아니다.

기본적으로 같은 Box 클래스를 공유한다.

System.out.println(
        stringBox.getClass()
                == integerBox.getClass()
);

결과는 true다.

타입 소거 후의 형태

다음과 같은 제네릭 클래스가 있다고 가정해보자.

public class Box<T> {

    private T value;

    public T get() {
        return value;
    }
}

타입 파라미터에 제한이 없다면 컴파일 이후 개념적으로 Object를 기준으로 처리된다.

public class Box {

    private Object value;

    public Object get() {
        return value;
    }
}

한정 타입이 있다면 해당 상한 타입이 기준이 된다.

public class NumberBox<T extends Number> {
}

이 경우 T는 소거 후 Number를 기준으로 처리된다.

new T()를 사용할 수 없는 이유

다음 코드는 사용할 수 없다.

public class Box<T> {

    public T create() {
        // return new T();
        // 컴파일 오류
    }
}

런타임에는 T가 어떤 구체적인 타입인지 알 수 없기 때문이다.

객체 생성이 필요하다면 생성자를 외부에서 전달받는 방법을 사용할 수 있다.

import java.util.function.Supplier;

public class Factory<T> {

    private final Supplier<T> supplier;

    public Factory(Supplier<T> supplier) {
        this.supplier = supplier;
    }

    public T create() {
        return supplier.get();
    }
}

public class FactoryExample {

    public static void main(String[] args) {
        Factory<Member> factory =
                new Factory<>(Member::new);

        Member member = factory.create();

        System.out.println(member);
    }
}

instanceof T를 사용할 수 없는 이유

다음 코드 역시 사용할 수 없다.

public boolean check(Object value) {
    // return value instanceof T;
}

instanceof는 런타임에 실제 타입을 검사하지만, 런타임에는 T의 구체적인 타입 정보가 소거되기 때문이다.

필요하다면 Class<T> 객체를 전달받을 수 있다.

public class TypeChecker<T> {

    private final Class<T> type;

    public TypeChecker(Class<T> type) {
        this.type = type;
    }

    public boolean check(Object value) {
        return type.isInstance(value);
    }
}

TypeChecker<String> checker =
        new TypeChecker<>(String.class);

System.out.println(checker.check("Java"));
System.out.println(checker.check(100));

제네릭 배열 생성

제네릭 타입의 배열을 직접 생성할 수 없다.

// T[] values = new T[10];
// 컴파일 오류

다음과 같은 배열도 생성할 수 없다.

// List<String>[] lists = new List<String>[10];

배열은 런타임에 자신의 요소 타입을 확인하지만 제네릭 타입 정보는 타입 소거로 인해 충분히 유지되지 않기 때문이다.

일반적으로 제네릭 데이터는 배열보다 List<T>와 같은 컬렉션으로 관리한다.

List<T> values = new ArrayList<>();

와일드카드로 제네릭의 범위 넓히기

제네릭은 서로 다른 타입이다

다음과 같은 클래스 관계가 있다고 가정해보자.

public class Animal {
}

public class Dog extends Animal {
}

Dog는 Animal의 자식이지만 다음 두 리스트는 서로 상속 관계가 아니다.

List<Dog>
List<Animal>

따라서 다음 대입은 불가능하다.

List<Dog> dogs = new ArrayList<>();

// List<Animal> animals = dogs;
// 컴파일 오류

만약 허용된다면 animals를 통해 Cat을 추가할 수 있게 되고, 원래 List<Dog>였던 리스트의 타입 안정성이 깨질 수 있기 때문이다.

여러 제네릭 타입을 유연하게 처리하려면 와일드카드를 사용한다.

제한 없는 와일드카드

<?>는 구체적인 타입을 알 수 없는 제네릭 타입을 의미한다.

List<?> values;

List<String>, List<Integer>, List<Member> 등을 모두 참조할 수 있다.

public static void printAll(List<?> values) {
    for (Object value : values) {
        System.out.println(value);
    }
}

printAll(List.of("Java", "Spring"));
printAll(List.of(10, 20, 30));

어떤 타입인지 알 수 없기 때문에 값을 꺼낼 때는 Object로만 안전하게 받을 수 있다.

Object value = values.get(0);

새로운 값을 추가하는 것은 거의 불가능하다.

// values.add("Java");
// values.add(100);

실제 리스트가 어떤 타입인지 모르기 때문이다.

null은 모든 참조 타입에 저장할 수 있으므로 추가할 수 있다.

values.add(null);

다만 List.of()처럼 수정 불가능한 리스트라면 null 추가 여부와 관계없이 변경 자체가 불가능하다.

상한 제한 와일드카드

<? extends T>는 T 또는 T의 하위 타입을 의미한다.

List<? extends Animal>

다음 타입들을 참조할 수 있다.

List<Animal>
List<Dog>
List<Cat>

값을 꺼낼 때는 최소한 Animal이라는 사실이 보장된다.

public static void makeSounds(
        List<? extends Animal> animals
) {
    for (Animal animal : animals) {
        animal.sound();
    }
}

하지만 구체적인 리스트 타입을 알 수 없기 때문에 새로운 객체를 추가할 수 없다.

// animals.add(new Dog());
// 컴파일 오류

실제 리스트가 List<Cat>일 수도 있기 때문이다.

상한 제한 와일드카드는 데이터를 주로 읽는 경우에 적합하다.

하한 제한 와일드카드

<? super T>는 T 또는 T의 부모 타입을 의미한다.

List<? super Dog>

다음 타입들을 참조할 수 있다.

List<Dog>
List<Animal>
List<Object>

Dog 객체는 안전하게 추가할 수 있다.

public static void addDog(
        List<? super Dog> values
) {
    values.add(new Dog());
}

Dog의 자식 객체가 있다면 그 객체도 추가할 수 있다.

하지만 꺼낸 값의 정확한 타입은 알 수 없다.

Object value = values.get(0);

실제 리스트가 List<Object>일 수도 있기 때문에 Dog 타입이라고 보장할 수 없다.

PECS 원칙

와일드카드를 기억할 때 자주 사용하는 원칙이 PECS다.

Producer Extends
Consumer Super

데이터를 제공하고 꺼내는 생산자라면 extends를 사용한다.

List<? extends Animal>

데이터를 전달받아 저장하는 소비자라면 super를 사용한다.

List<? super Dog>

다음 복사 메서드를 보면 PECS를 이해하기 쉽다.

public static <T> void copy(
        List<? extends T> source,
        List<? super T> destination
) {
    for (T value : source) {
        destination.add(value);
    }
}

source는 값을 꺼내는 생산자이므로 extends를 사용하고, destination은 값을 넣는 소비자이므로 super를 사용한다.

public class CopyExample {

    public static void main(String[] args) {
        List<Integer> source =
                List.of(10, 20, 30);

        List<Number> destination =
                new ArrayList<>();

        copy(source, destination);

        System.out.println(destination);
    }

    public static <T> void copy(
            List<? extends T> source,
            List<? super T> destination
    ) {
        for (T value : source) {
            destination.add(value);
        }
    }
}

와일드카드 비교

Enum으로 제한된 값을 안전하게 관리하기

열거 타입이란?

열거 타입은 변수가 가질 수 있는 값을 미리 정해 놓는 타입이다.

회원 등급이 다음 세 가지로만 구성된다고 생각해보자.

GOLD
SILVER
BRONZE

문자열로 관리하면 다음과 같은 문제가 생길 수 있다.

String grade = "GLOD";

오타가 있어도 단순 문자열이기 때문에 컴파일러가 문제를 발견하지 못한다.

상수로 관리할 수도 있다.

public static final String GOLD = "GOLD";
public static final String SILVER = "SILVER";

하지만 문자열이기 때문에 다른 의미의 문자열도 저장할 수 있다.

String grade = "ADMIN";

Enum을 사용하면 허용된 값만 저장하도록 제한할 수 있다.

Enum 선언

열거 타입은 enum 키워드를 사용한다.

public enum Grade {
    GOLD,
    SILVER,
    BRONZE
}

Enum 내부에 선언된 각각의 값을 열거 상수라고 한다.

열거 상수는 일반적인 상수 이름 규칙에 따라 대문자로 작성하고, 여러 단어로 구성되면 언더바를 사용한다.

public enum OrderStatus {
    PAYMENT_PENDING,
    PAID,
    SHIPPING,
    DELIVERED,
    CANCELED
}

Enum 사용

열거 타입 변수에는 해당 Enum에 선언된 상수와 null만 저장할 수 있다.

Grade grade = Grade.GOLD;

다른 Enum 타입이나 임의의 문자열을 저장할 수 없다.

// Grade grade = "GOLD";
// 컴파일 오류

비교할 때는 ==를 사용할 수 있다.

if (grade == Grade.GOLD) {
    System.out.println("골드 회원입니다.");
}

각 열거 상수는 하나의 고정된 객체이므로 == 비교가 안전하다.

switch와 Enum

Enum은 switch문과 잘 어울린다.

public class GradeExample {

    public static void main(String[] args) {
        Grade grade = Grade.GOLD;

        String benefit = switch (grade) {
            case GOLD -> "10% 할인";
            case SILVER -> "5% 할인";
            case BRONZE -> "적립금 제공";
        };

        System.out.println(benefit);
    }
}

모든 열거 상수를 처리하면 default를 생략할 수 있다.

새로운 Enum 상수가 추가되었을 때 처리하지 않은 부분을 컴파일러가 알려줄 수 있다는 장점도 있다.

Enum은 클래스다

Enum은 단순한 상수 모음이 아니다.

내부적으로 java.lang.Enum을 상속하는 특별한 클래스다.

따라서 다음 요소를 가질 수 있다.

• 필드
• 생성자
• 메서드
• 추상 메서드
• 인터페이스 구현

회원 등급마다 할인율을 가지도록 만들 수 있다.

public enum Grade {

    GOLD(0.10),
    SILVER(0.05),
    BRONZE(0.01);

    private final double discountRate;

    Grade(double discountRate) {
        this.discountRate = discountRate;
    }

    public int calculateDiscount(int price) {
        return (int) (price * discountRate);
    }

    public double getDiscountRate() {
        return discountRate;
    }
}

public class GradeExample {

    public static void main(String[] args) {
        Grade grade = Grade.GOLD;

        int discount =
                grade.calculateDiscount(100_000);

        System.out.println(discount);
    }
}

실행 결과는 다음과 같다.

10000

Enum이 자신의 데이터와 동작을 직접 가지기 때문에 등급별 조건문을 외부에 반복해서 작성하지 않아도 된다.

Enum 생성자

Enum 생성자는 외부에서 직접 호출할 수 없다.

// Grade grade = new Grade();
// 사용할 수 없음

열거 상수를 선언할 때 내부적으로 생성자가 호출된다.

GOLD(0.10)

Enum 생성자는 명시적으로 public이나 protected로 선언할 수 없으며 외부에서 객체를 추가로 생성할 수 없다.

values()

values()는 Enum에 선언된 모든 상수를 배열로 반환한다.

public class EnumMethodExample {

    public static void main(String[] args) {
        for (Grade grade : Grade.values()) {
            System.out.println(grade);
        }
    }
}

실행 결과는 다음과 같다.

GOLD
SILVER
BRONZE

valueOf()

valueOf()는 문자열과 이름이 일치하는 열거 상수를 반환한다.

Grade grade = Grade.valueOf("GOLD");

System.out.println(grade);

이름이 일치하지 않으면 IllegalArgumentException이 발생한다.

// Grade.valueOf("gold");
// 대소문자가 달라 오류 발생

외부 입력을 Enum으로 변환할 때는 예외 처리가 필요할 수 있다.

name()과 ordinal()

name()은 열거 상수의 이름을 문자열로 반환한다.

System.out.println(Grade.GOLD.name());

결과는 "GOLD"다.

ordinal()은 열거 상수가 선언된 순서를 반환한다.

System.out.println(Grade.GOLD.ordinal());
System.out.println(Grade.SILVER.ordinal());

결과는 각각 0, 1이다.

하지만 ordinal() 값을 데이터베이스 저장값이나 업무 로직에 사용하는 것은 피해야 한다.

Enum 선언 순서가 바뀌면 값도 함께 달라지기 때문이다.

GOLD = 0
SILVER = 1

중간에 새로운 상수가 추가되면 기존 값의 의미가 달라질 수 있다.

저장용 코드가 필요하다면 별도의 필드를 선언하는 것이 안전하다.

public enum Grade {

    GOLD("G"),
    SILVER("S"),
    BRONZE("B");

    private final String code;

    Grade(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }
}

Enum에 추상 메서드 선언하기

열거 상수마다 서로 다른 동작을 구현할 수도 있다.

public enum Operation {

    PLUS {
        @Override
        public int calculate(int left, int right) {
            return left + right;
        }
    },

    MINUS {
        @Override
        public int calculate(int left, int right) {
            return left - right;
        }
    },

    MULTIPLY {
        @Override
        public int calculate(int left, int right) {
            return left * right;
        }
    };

    public abstract int calculate(
            int left,
            int right
    );
}

public class OperationExample {

    public static void main(String[] args) {
        int result =
                Operation.PLUS.calculate(10, 20);

        System.out.println(result);
    }
}

이 방식은 Enum 상수별로 동작이 확실히 구분될 때 사용할 수 있다.

Enum이 문자열보다 좋은 이유

Annotation으로 코드에 정보 추가하기

Annotation이란?

어노테이션은 소스 코드에 추가하는 메타데이터다.

일반 주석은 사람이 읽기 위한 설명이지만, 어노테이션은 컴파일러, JVM, 라이브러리, 프레임워크 등이 읽고 활용할 수 있다.

@Override
public String toString() {
    return "Member";
}

@Override는 해당 메서드가 부모 클래스의 메서드를 재정의한 것임을 컴파일러에게 알려준다.

어노테이션은 코드의 실제 실행 내용을 직접 작성하기보다 코드에 대한 추가 정보나 처리 규칙을 전달하는 역할을 한다.

Java의 기본 어노테이션

Java에서 자주 사용하는 기본 어노테이션은 다음과 같다.

@Override

부모 클래스나 인터페이스의 메서드를 재정의했음을 나타낸다.

public class Member {

    @Override
    public String toString() {
        return "Member";
    }
}

메서드 이름이나 매개변수를 잘못 작성하면 컴파일러가 오류를 알려준다.

@Override
public String toStrings() {
    return "Member";
}

Object에 toStrings()라는 메서드가 없으므로 컴파일 오류가 발생한다.

오버라이딩할 때는 항상 @Override를 작성하는 것이 좋다.

@Deprecated

더 이상 사용을 권장하지 않는 클래스, 생성자, 메서드 등에 표시한다.

public class MemberService {

    @Deprecated
    public void oldRegister() {
        System.out.println("이전 등록 방식");
    }

    public void register() {
        System.out.println("새로운 등록 방식");
    }
}

기존 코드와의 호환성을 위해 기능을 바로 삭제할 수 없지만 새로운 코드에서는 사용하지 않도록 안내할 때 사용한다.

문서화를 더 명확하게 하기 위해 Javadoc의 @deprecated 태그와 함께 사용할 수 있다.

/**
 * @deprecated register()를 사용하세요.
 */
@Deprecated
public void oldRegister() {
}

Java 9부터는 추가 속성도 지정할 수 있다.

@Deprecated(
        since = "2.0",
        forRemoval = true
)
public void oldRegister() {
}

since는 사용 중단이 시작된 버전을 나타내고, forRemoval은 향후 제거 예정 여부를 나타낸다.

@SuppressWarnings

컴파일러가 발생시키는 특정 경고를 억제한다.

@SuppressWarnings("unused")
private void test() {
    int number = 10;
}

여러 경고를 함께 억제할 수 있다.

@SuppressWarnings({
        "rawtypes",
        "unchecked"
})
public void legacyCode() {
}

경고를 단순히 숨기기 위한 용도로 남발하면 실제 문제를 놓칠 수 있다. 가능한 한 경고의 원인을 해결하고, 의도적으로 안전하다고 판단한 범위에만 적용해야 한다.

@FunctionalInterface

추상 메서드를 하나만 가지는 함수형 인터페이스에 사용한다.

@FunctionalInterface
public interface Calculator {

    int calculate(int left, int right);
}

함수형 인터페이스는 람다 표현식의 대상이 될 수 있다.

Calculator add =
        (left, right) -> left + right;

System.out.println(add.calculate(10, 20));

@FunctionalInterface를 작성한 인터페이스에 추상 메서드를 두 개 이상 선언하면 컴파일 오류가 발생한다.

@FunctionalInterface
public interface Calculator {

    int calculate(int left, int right);

    // void print();
    // 추가하면 컴파일 오류
}

사용자 정의 Annotation 만들기

어노테이션 선언

사용자 정의 어노테이션은 @interface를 사용해 선언한다.

public @interface Author {
}

인터페이스 선언과 비슷하지만 앞에 @가 붙는다.

사용할 때는 다음과 같이 작성한다.

@Author
public class MemberService {
}

어노테이션 속성

어노테이션 내부에는 추상 메서드와 비슷한 형태로 속성을 선언한다.

public @interface Author {

    String name();

    String date();
}

사용할 때는 속성이름 = 값 형태로 작성한다.

@Author(
        name = "김자바",
        date = "2026-07-28"
)
public class MemberService {
}

어노테이션 속성에는 반환 타입만 작성하며 매개변수는 선언할 수 없다.

기본값 지정

default 키워드로 속성의 기본값을 지정할 수 있다.

public @interface Author {

    String name();

    String date() default "미작성";
}

기본값이 있는 속성은 사용 시 생략할 수 있다.

@Author(name = "김자바")
public class MemberService {
}

value 속성

속성 이름이 value이고 다른 필수 속성이 없다면 이름을 생략할 수 있다.

public @interface Description {

    String value();
}

다음 두 사용법은 같다.

@Description(value = "회원 서비스")

@Description("회원 서비스")

Spring의 많은 어노테이션에서 value 속성 이름을 생략하는 형태를 볼 수 있다.

@RequestMapping("/members")

어노테이션 속성에서 사용할 수 있는 타입

어노테이션 속성에는 제한된 타입만 사용할 수 있다.

대표적으로 다음 타입을 사용할 수 있다.

• 기본 타입
• String
• Class
• Enum
• 다른 Annotation
• 위 타입들의 배열

public @interface ApiInfo {

    String name();

    int version();

    Class<?> responseType();

    HttpMethod method();

    String[] tags();
}

다음과 같은 일반 객체 타입은 속성으로 사용할 수 없다.

// Member member();
// 사용할 수 없음

메타 어노테이션

메타 어노테이션이란?

메타 어노테이션은 다른 어노테이션의 적용 방법을 설정하는 어노테이션이다.

대표적인 메타 어노테이션은 다음과 같다.

@Target

어노테이션을 적용할 수 있는 위치를 지정한다.

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
public @interface LogExecution {
}

위 어노테이션은 메서드에만 사용할 수 있다.

@LogExecution
public void save() {
}

여러 위치를 허용할 수도 있다.

@Target({
        ElementType.TYPE,
        ElementType.METHOD
})
public @interface Audit {
}

자주 사용하는 ElementType은 다음과 같다.

@Retention

어노테이션 정보를 언제까지 유지할지 지정한다.

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface LogExecution {
}

유지 정책은 다음 세 가지다.

컴파일러만 사용하는 어노테이션은 SOURCE가 적절할 수 있다.

프레임워크가 런타임에 어노테이션을 읽어야 한다면 RUNTIME을 사용한다.

Spring의 많은 어노테이션은 런타임에 Reflection으로 분석되므로 RUNTIME 정책을 사용한다.

@Documented

@Documented가 적용된 어노테이션은 Javadoc 생성 시 문서에 포함될 수 있다.

import java.lang.annotation.Documented;

@Documented
public @interface ApiDescription {
}

@Inherited

@Inherited가 적용된 클래스 수준 어노테이션은 자식 클래스가 상속받은 것처럼 조회할 수 있다.

import java.lang.annotation.Inherited;

@Inherited
public @interface Role {
}

다만 인터페이스 구현이나 메서드 어노테이션까지 자동으로 상속되는 것은 아니다.

@Repeatable

같은 어노테이션을 한 대상에 여러 번 작성할 수 있도록 한다.

import java.lang.annotation.Repeatable;

@Repeatable(Roles.class)
public @interface Role {

    String value();
}

컨테이너 어노테이션도 필요하다.

public @interface Roles {

    Role[] value();
}

사용할 때는 다음과 같이 작성할 수 있다.

@Role("ADMIN")
@Role("MANAGER")
public class MemberService {
}

Reflection으로 Annotation 읽기

런타임 유지 정책을 가진 어노테이션은 Reflection을 통해 읽을 수 있다.

사용자 정의 어노테이션

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ServiceInfo {

    String name();

    int version() default 1;
}

어노테이션 적용

@ServiceInfo(
        name = "회원 서비스",
        version = 2
)
public class MemberService {
}

어노테이션 조회

public class AnnotationExample {

    public static void main(String[] args) {
        Class<MemberService> type =
                MemberService.class;

        ServiceInfo info =
                type.getAnnotation(
                        ServiceInfo.class
                );

        if (info != null) {
            System.out.println(info.name());
            System.out.println(info.version());
        }
    }
}

실행 결과는 다음과 같다.

회원 서비스
2

프레임워크는 이와 유사한 방식으로 클래스와 메서드에 붙은 어노테이션을 분석한 뒤 객체 생성, 요청 매핑, 유효성 검사 같은 기능을 수행한다.

실무에서 제네릭, Enum, Annotation은 어떻게 사용할까?

제네릭

Java 컬렉션과 여러 API는 대부분 제네릭으로 설계되어 있다.

List<Member>
Set<String>
Map<Long, Product>
Optional<Member>
ResponseEntity<UserResponse>
Page<ProductResponse>

제네릭 덕분에 하나의 API가 다양한 타입을 처리하면서도 컴파일 단계에서 타입 안정성을 제공할 수 있다.

메서드의 매개변수와 반환 타입을 설계할 때는 지나치게 광범위한 Object보다 구체적인 제네릭 타입을 사용하는 것이 좋다.

List<Member> findAll();

또한 컬렉션을 읽기만 하거나 채워 넣는 메서드를 작성할 때 와일드카드와 PECS 원칙을 활용할 수 있다.

Enum

실무에서는 상태값, 권한, 등급, 결제 방식처럼 가능한 값이 명확히 제한된 데이터에 Enum을 사용한다.

public enum OrderStatus {
    CREATED,
    PAID,
    SHIPPING,
    DELIVERED,
    CANCELED
}

문자열 상수 대신 Enum을 사용하면 오타를 줄이고 타입 안정성을 높일 수 있다.

상태별 동작이 있다면 조건문을 외부에 늘어놓기보다 Enum이 직접 책임지도록 설계할 수도 있다.

status.canCancel();
status.getDescription();

다만 데이터베이스에 Enum을 저장할 때 ordinal() 순서를 사용하는 것은 피하고 문자열 이름이나 별도의 코드를 사용하는 것이 안전하다.

Annotation

Spring에서는 어노테이션이 매우 광범위하게 사용된다.

@Controller
@Service
@Repository
@Component

@GetMapping
@PostMapping
@RequestBody
@PathVariable

@Transactional
@Valid
@NotNull

개발자는 어노테이션으로 의도를 표현하고, 프레임워크가 해당 정보를 읽어 필요한 기능을 수행한다.

하지만 어노테이션을 사용한다고 해서 실제 동작이 자동으로 생기는 것은 아니다. 어노테이션을 분석하고 처리하는 컴파일러, 라이브러리 또는 프레임워크 코드가 있어야 한다.

헷갈리기 쉬운 개념

List<Object>와 List<?>

List<Object>

Object 또는 모든 자식 객체를 저장할 수 있는 리스트다.

List<Object> values =
        new ArrayList<>();

values.add("Java");
values.add(100);

반면

List<?>

구체적인 요소 타입을 알 수 없는 리스트를 참조한다.

List<?> values = List.of("Java");

List<String>일 수도 있고 List<Integer>일 수도 있으므로 새로운 값을 추가할 수 없다.

List<Object>
→ 요소 타입이 Object라고 확정

List<?>
→ 요소 타입을 알 수 없음

<T extends Animal>과 <? extends Animal>

<T extends Animal>

메서드나 클래스가 사용하는 타입 파라미터를 선언한다.

public static <T extends Animal>
void print(T value) {
}

<? extends Animal>

이미 선언된 제네릭 타입의 범위를 표현하는 와일드카드다.

List<? extends Animal> animals;

타입 파라미터는 타입 사이의 관계를 유지해야 할 때 유용하고, 와일드카드는 다양한 제네릭 타입을 유연하게 받을 때 유용하다.

Enum과 상수 클래스

public static final String GOLD = "GOLD";

문자열 상수는 값 자체만 제한적으로 제공한다.

public enum Grade {
    GOLD,
    SILVER
}

Enum은 독립적인 타입이며 필드, 메서드, 생성자를 가질 수 있다.

서로 다른 Enum 타입의 상수는 이름이 같아도 호환되지 않는다.

Annotation과 일반 주석

// 회원을 저장한다.

일반 주석은 사람이 읽는다.

@Override

어노테이션은 컴파일러나 프레임워크가 읽을 수 있다.

다만 어노테이션 자체가 실행 로직을 가진 것은 아니다. 어노테이션을 처리하는 별도의 코드가 있어야 한다.

@interface와 interface

public interface Payment {
}

객체가 구현해야 하는 기능의 규격을 정의한다.

public @interface Audit {
}

코드에 부착할 메타데이터 타입을 정의한다.

문법이 비슷하지만 목적은 완전히 다르다.

오늘 배운 내용 정리

이번 글에서는 Java 제네릭, Enum, Annotation을 함께 정리했다.

• 제네릭은 클래스, 인터페이스, 메서드에서 사용할 타입을 외부에서 지정하는 문법이다.
• 제네릭은 컴파일 단계에서 타입을 검사하여 타입 안정성을 높인다.
• 제네릭을 사용하면 값을 꺼낼 때 불필요한 강제 타입 변환을 줄일 수 있다.
• 타입 파라미터는 일반적으로 T, E, K, V 등의 이름을 사용한다.
• 하나의 제네릭 클래스에 여러 타입 파라미터를 선언할 수 있다.
• 인터페이스와 메서드에도 제네릭을 적용할 수 있다.
• Raw Type은 타입 검사를 우회하므로 사용하지 않는 것이 좋다.
• 제네릭에는 기본 타입 대신 래퍼 클래스를 사용해야 한다.
• 클래스의 타입 파라미터는 정적 필드나 정적 메서드에서 직접 사용할 수 없다.
• 정적 메서드에 제네릭이 필요하면 메서드 자체의 타입 파라미터를 선언해야 한다.
• <T extends Number>와 같이 타입의 범위를 제한할 수 있다.
• Java 제네릭은 타입 소거 방식으로 구현된다.
• 타입 소거로 인해 new T(), instanceof T, 제네릭 배열 생성 등이 제한된다.
• <?>는 요소의 구체적인 타입을 알 수 없는 제네릭 타입이다.
• <? extends T>는 데이터를 읽는 생산자에 적합하다.
• <? super T>는 데이터를 저장하는 소비자에 적합하다.
• PECS는 Producer Extends, Consumer Super를 의미한다.
• Enum은 변수가 가질 수 있는 값을 미리 제한하는 특별한 클래스다.
• 열거 상수는 하나의 고정된 Enum 객체다.
• Enum은 필드, 생성자, 메서드를 가질 수 있다.
• Enum은 switch와 함께 사용하기 좋다.
• values()는 모든 열거 상수를 반환한다.
• valueOf()는 이름과 일치하는 열거 상수를 반환한다.
• ordinal()은 선언 순서를 반환하지만 저장용 업무 값으로 사용하지 않는 것이 좋다.
• Annotation은 코드에 추가하는 메타데이터다.
• 어노테이션은 컴파일러, JVM, 라이브러리, 프레임워크 등이 활용할 수 있다.
• 사용자 정의 어노테이션은 @interface로 선언한다.
• 어노테이션의 속성은 추상 메서드와 비슷한 형태로 선언한다.
• 속성에는 default로 기본값을 지정할 수 있다.
• value 속성은 조건에 따라 이름을 생략할 수 있다.
• @Target은 어노테이션의 적용 위치를 제한한다.
• @Retention은 어노테이션 정보가 유지되는 기간을 지정한다.
• 런타임 어노테이션은 Reflection으로 조회할 수 있다.
• Spring은 어노테이션을 분석하여 객체 생성, 요청 처리, 트랜잭션 등의 기능을 제공한다.

면접과 평가에서 자주 나오는 질문

제네릭을 사용하는 이유는?

컴파일 단계에서 타입 안정성을 확보하고 불필요한 형변환을 줄이며 하나의 코드를 여러 타입에 재사용하기 위해 사용한다.

Raw Type이란?

제네릭 타입에서 타입 인수를 생략한 형태다.

List list = new ArrayList();

하위 호환성을 위해 남아 있지만 타입 안정성을 잃으므로 새로운 코드에서는 사용하지 않는 것이 좋다.

List<Object>와 List<?>의 차이는?

List<Object>는 요소 타입이 Object로 확정된 리스트다. 다양한 객체를 추가할 수 있다.

List<?>는 요소 타입을 알 수 없는 리스트다. 구체적인 타입을 모르기 때문에 null 이외의 값을 안전하게 추가할 수 없다.

PECS란?

Producer Extends
Consumer Super

데이터를 꺼내는 생산자에는 extends, 데이터를 넣는 소비자에는 super를 사용하는 원칙이다.

Java의 제네릭이 공변인가?

기본적으로 불공변이다.

List<Dog>

는 List<Animal>의 하위 타입이 아니다.

와일드카드를 통해 제한적인 공변성과 반공변성을 표현할 수 있다.

List<? extends Animal>
List<? super Dog>

Enum과 문자열 상수의 차이는?

Enum은 독립적인 타입이므로 허용된 값만 저장할 수 있고, 필드와 메서드를 포함할 수 있다. 문자열 상수는 임의의 문자열과 구분되지 않아 타입 안정성이 약하다.

equals로 Enum을 비교해도 되는가?

가능하지만 Enum은 각 상수가 하나의 고정 객체이므로 일반적으로 ==를 사용하는 것이 명확하고 안전하다.

Annotation과 Interface의 차이는?

인터페이스는 객체가 구현해야 하는 기능의 규격이다.

어노테이션은 코드에 부착하는 메타데이터 타입이다.

RetentionPolicy의 차이는?

SOURCE
→ 소스 코드에서만 유지

CLASS
→ 클래스 파일까지 유지

RUNTIME
→ 실행 중에도 유지, Reflection 조회 가능

Spring은 어노테이션을 어떻게 처리하는가?

클래스 패스 스캔, Reflection, 프록시, Bean 후처리기 등의 기능을 이용해 어노테이션이 부착된 클래스와 메서드를 분석하고 추가 동작을 적용한다.

들어가며

이전 글에서는 다형성과 추상 클래스, 캡슐화를 공부했다.

추상 클래스를 이용하면 공통 기능을 부모 클래스에 모아 코드의 중복을 줄일 수 있었고, 다형성을 이용하면 부모 타입 하나로 다양한 자식 객체를 사용할 수 있었다.

하지만 객체지향 프로그래밍에서는 기능만 정의하고 구현은 각 객체에게 맡기고 싶은 경우도 자주 발생한다.

예를 들어

• 결제할 수 있는 객체
• 출력할 수 있는 객체
• 이동할 수 있는 객체
• 저장할 수 있는 객체

처럼 "무엇을 할 수 있는가" 만 정의하고 싶은 경우가 있다.

이럴 때 사용하는 것이 인터페이스(Interface) 이다.

인터페이스는 객체가 가져야 하는 기능의 규격을 정의하며, Java에서 다형성을 가장 많이 활용하는 방법이기도 하다.

이번 글에서는 인터페이스의 개념부터 구현 클래스, 다형성, default 메서드, static 메서드, private 메서드, 그리고 추상 클래스와의 차이까지 정리해보려고 한다.

인터페이스란 무엇인가

인터페이스의 개념

인터페이스는 객체의 사용 방법을 정의한 타입이다.

객체 내부가 어떻게 구현되어 있는지는 알 필요 없이,

어떤 기능을 사용할 수 있는지만 정의한다.

예를 들어 TV와 에어컨의 리모컨을 생각해보자.

사용자는

• 전원 켜기
• 전원 끄기
• 볼륨 조절

버튼만 알고 있으면 된다.

리모컨 내부 회로가 어떻게 동작하는지는 몰라도 사용할 수 있다.

인터페이스도 이와 동일하다.

개발자는 구현 방법을 몰라도 인터페이스만 알면 객체를 사용할 수 있다.

인터페이스를 사용하는 이유

인터페이스를 사용하면

개발 코드와 실제 객체를 분리할 수 있다.

개발 코드
      ↓
 Interface
      ↓
 실제 객체

개발 코드는 인터페이스만 바라본다.

따라서 구현 객체가 변경되어도 개발 코드는 수정하지 않아도 된다.

예를 들어

Payment payment = new CardPayment();

이 코드를

Payment payment = new KakaoPayment();

으로 변경해도

사용하는 코드는 그대로 유지된다.

이것이 인터페이스가 제공하는 가장 큰 장점이다.

인터페이스 선언하기

인터페이스는 클래스와 동일하게 .java 파일로 작성한다.

public interface RemoteControl {

}

클래스와 비슷하지만 중요한 차이가 있다.

인터페이스는 객체를 생성할 수 없다.

따라서 생성자를 가질 수 없다.

인터페이스의 구성 요소

인터페이스에는 대표적으로 다음 요소를 선언할 수 있다.

• 상수
• 추상 메서드
• default 메서드
• static 메서드
• private 메서드(Java9 이상)

상수 필드

인터페이스에는 일반 필드를 만들 수 없다.

오직 상수만 선언할 수 있다.

public interface RemoteControl {

    int MAX_VOLUME = 10;

}

위 코드는 실제로 컴파일되면 다음과 동일하다.

public interface RemoteControl {

    public static final int MAX_VOLUME = 10;

}

즉,

public
static
final

은 자동으로 추가된다.

상수 이름은 관례적으로 모두 대문자를 사용하며

단어 사이는 _를 사용한다.

추상 메서드

인터페이스는 객체의 기능을 정의하는 것이 목적이다.

따라서 대부분 메서드는 구현부 없이 선언만 존재한다.

public interface RemoteControl {

    void turnOn();

    void turnOff();

}

실제로는

public abstract void turnOn();

과 같다.

public abstract는 생략 가능하다.

인터페이스 구현하기

인터페이스는 객체를 만들 수 없기 때문에

반드시 구현 클래스가 필요하다.

public interface RemoteControl {

    void turnOn();

}

구현 클래스는

implements

키워드를 사용한다.

public class Television implements RemoteControl {

    @Override
    public void turnOn() {
        System.out.println("TV 전원 ON");
    }

}

인터페이스의 모든 추상 메서드를 반드시 구현해야 한다.

구현 객체 사용하기

객체는 인터페이스 타입으로 참조한다.

RemoteControl rc = new Television();

rc.turnOn();

실제 객체는 Television이지만

개발 코드는 RemoteControl만 알고 있다.

이처럼 인터페이스를 이용하면 구현 객체를 쉽게 교체할 수 있다.

인터페이스와 다형성

인터페이스도 부모 클래스처럼 다형성을 구현할 수 있다.

RemoteControl rc;

rc = new Television();

rc = new Audio();

같은 변수지만

저장되는 객체에 따라 실행 결과가 달라진다.

자동 타입 변환

인터페이스를 구현한 객체는

자동으로 인터페이스 타입으로 변환된다.

RemoteControl rc = new Television();

이는 다음과 같은 의미이다.

Television tv = new Television();

RemoteControl rc = tv;

별도의 형변환 없이 자동으로 변환된다.

매개변수의 다형성

인터페이스는 매개변수에서도 매우 많이 사용된다.

public class User {

    public void use(RemoteControl rc) {
        rc.turnOn();
    }

}

호출할 때는

user.use(new Television());

user.use(new Audio());

처럼 다양한 구현 객체를 전달할 수 있다.

실제 실행되는 메서드는

각 객체가 구현한 메서드이다.

다중 인터페이스 구현

Java는 클래스의 다중 상속은 지원하지 않는다.

하지만

인터페이스는 여러 개를 동시에 구현할 수 있다.

public interface Printer {

    void print();

}

public interface Scanner {

    void scan();

}

public class MultiFunctionPrinter
        implements Printer, Scanner {

    @Override
    public void print() {
        System.out.println("출력");
    }

    @Override
    public void scan() {
        System.out.println("스캔");
    }

}

하나의 객체가 여러 인터페이스 타입으로 사용될 수 있다.

Printer printer = new MultiFunctionPrinter();

Scanner scanner = new MultiFunctionPrinter();

인터페이스의 새로운 기능(Java8 이후)

Java8 이전에는 인터페이스에는

추상 메서드만 존재했다.

하지만 Java8부터 여러 기능이 추가되었다.

default 메서드

인터페이스에서도 구현부를 가진 메서드를 작성할 수 있다.

public interface RemoteControl {

    void turnOn();

    default void setMute() {
        System.out.println("무음 처리");
    }

}

구현 클래스는

필요하면 그대로 사용하고

원한다면 오버라이딩할 수도 있다.

default 메서드가 필요한 이유

이미 배포된 인터페이스에 새로운 메서드를 추가하면

모든 구현 클래스가 컴파일 오류가 발생한다.

이를 해결하기 위해

default 메서드가 만들어졌다.

기존 구현 클래스는 수정하지 않아도 된다.

static 메서드

인터페이스도 static 메서드를 가질 수 있다.

public interface RemoteControl {

    static void changeBattery() {
        System.out.println("배터리 교체");
    }

}

객체를 생성하지 않고 사용할 수 있다.

RemoteControl.changeBattery();

private 메서드

Java9부터는

default 메서드 내부에서 사용할 private 메서드도 만들 수 있다.

public interface RemoteControl {

    default void turnOn() {
        checkBattery();
    }

    private void checkBattery() {
        System.out.println("배터리 확인");
    }

}

외부에서는 호출할 수 없다.

인터페이스 내부의 코드 중복을 줄이기 위해 사용된다.

추상 클래스와 인터페이스

추상 클래스와 인터페이스는 매우 비슷해 보인다.

하지만 목적이 다르다.

추상 클래스는

공통 기능과 상태를 공유하기 위한 부모 클래스이다.

인터페이스는

객체가 반드시 가져야 하는 기능의 규격이다.

예를 들어

동물은 모두 이름과 나이가 있다.

이 경우

abstract class Animal

이 적절하다.

반면

날 수 있는 기능은

새도 가능하고

비행기도 가능하다.

공통 부모가 존재하지 않는다.

이 경우

interface Flyable

이 적절하다.

추상 클래스와 인터페이스 비교

간단히 정리하면

"공통 기능은 추상 클래스"

"공통 규격은 인터페이스"

라고 이해하면 된다.

인터페이스가 많이 사용되는 이유

Java의 대표적인 API들도 대부분 인터페이스를 중심으로 설계되어 있다.

예를 들어

List<String> list = new ArrayList<>();

변수는 List 인터페이스 타입이다.

실제 객체는 ArrayList이다.

필요하면

list = new LinkedList<>();

로 변경해도 사용하는 코드는 거의 수정하지 않는다.

Spring Framework에서도

의존성 주입(DI)은 대부분 인터페이스를 기반으로 이루어진다.

즉,

인터페이스는 객체를 유연하게 교체할 수 있도록 만드는 핵심 기술이다.

오늘 배운 내용 정리

이번 글에서는 인터페이스의 개념과 활용 방법을 정리했다.

• 인터페이스는 객체의 사용 방법을 정의한 타입이다.
• 객체의 구현과 개발 코드를 분리하여 결합도를 낮춘다.
• 인터페이스는 객체를 생성할 수 없으며 생성자를 가질 수 없다.
• 인터페이스에는 상수와 추상 메서드를 선언할 수 있다.
• 인터페이스를 구현하는 클래스는 implements를 사용한다.
• 구현 클래스는 모든 추상 메서드를 반드시 오버라이딩해야 한다.
• 구현 객체는 인터페이스 타입으로 자동 타입 변환된다.
• 인터페이스 역시 다형성을 구현하는 핵심 요소이다.
• 매개변수와 필드에서도 인터페이스 타입을 사용할 수 있다.
• 하나의 클래스는 여러 인터페이스를 동시에 구현할 수 있다.
• Java8부터는 default 메서드와 static 메서드를 지원한다.
• Java9부터는 private 메서드도 작성할 수 있다.
• 추상 클래스는 공통 기능을 위한 부모 클래스이고, 인터페이스는 기능의 규격을 정의하기 위한 타입이다.
• Java API와 Spring Framework는 대부분 인터페이스 중심으로 설계되어 있다.

들어가며

앞선 글에서는 상속을 통해 부모 클래스의 필드와 메서드를 자식 클래스가 재사용하고, 오버라이딩을 통해 부모의 기능을 자식 클래스에 맞게 다시 정의하는 방법을 살펴보았다.

상속 관계가 만들어지면 자식 객체는 자신의 타입뿐 아니라 부모 타입으로도 다룰 수 있다.

Dog dog = new Dog();
Animal animal = dog;

실제 객체는 Dog이지만 이를 Animal 타입의 변수로 참조할 수 있다.

이처럼 하나의 객체를 여러 타입으로 다룰 수 있는 성질을 다형성이라고 한다.

다형성을 사용하면 코드 하나로 여러 종류의 객체를 처리할 수 있다. 새로운 자식 클래스가 추가되더라도 기존 코드를 크게 수정하지 않고 기능을 확장할 수 있기 때문에 객체지향 프로그래밍에서 매우 중요한 개념이다.

이번 글에서는 자동 타입 변환과 강제 타입 변환, instanceof, 필드와 매개변수의 다형성, 동적 바인딩, 추상 클래스, 캡슐화, 싱글톤 패턴, 그리고 Object 클래스의 주요 메서드까지 정리해보려고 한다.

부모 타입으로 자식 객체 사용하기

참조 타입에도 타입 변환이 있다

기본 타입의 값이 다른 기본 타입으로 변환될 수 있었던 것처럼 클래스와 클래스 사이에도 타입 변환이 존재한다.

다만 참조 타입의 형변환은 아무 클래스 사이에서나 가능한 것은 아니다. 기본적으로 상속 관계에 있는 클래스 사이에서만 가능하다.

public class Animal {

    public void eat() {
        System.out.println("먹이를 먹습니다.");
    }
}

public class Cat extends Animal {

    public void meow() {
        System.out.println("야옹");
    }
}

Cat은 Animal을 상속하므로 다음과 같이 사용할 수 있다.

Cat cat = new Cat();
Animal animal = cat;

한 문장으로 작성할 수도 있다.

Animal animal = new Cat();

자식 타입의 객체를 부모 타입 변수에 저장하는 변환은 자동으로 이루어지므로 캐스팅 연산자를 작성하지 않아도 된다.

이를 자동 타입 변환, 업캐스팅, 또는 묵시적 형변환이라고 한다.

바로 위 부모가 아니어도 변환할 수 있다

상속 계층에서 상위에 있는 타입이라면 바로 위의 부모가 아니어도 자동 타입 변환이 가능하다.

Object
  ↑
Animal
  ↑
Cat

Cat cat = new Cat();

Animal animal = cat;
Object object = cat;

Cat 객체는 Animal이면서 동시에 Object이기도 하므로 두 타입 모두로 참조할 수 있다.

Object object = new Cat();

모든 Java 클래스가 Object를 최상위 부모로 가지므로 모든 객체는 Object 타입 변수에 저장할 수 있다.

참조 변수 타입에 따라 사용할 수 있는 멤버가 달라진다

다음 코드에서 실제로 Heap 영역에 생성된 객체는 Cat이다.

Animal animal = new Cat();

하지만 참조 변수의 타입은 Animal이다.

따라서 컴파일러는 Animal 클래스에 선언된 멤버만 직접 사용할 수 있도록 제한한다.

animal.eat();

// animal.meow();
// 컴파일 오류

실제 객체에는 meow()가 존재하지만 Animal 타입만 보고 있는 변수에서는 해당 메서드를 알 수 없다.

실제 객체: Cat

Cat 객체가 가진 기능
- eat()
- meow()

Animal 타입 변수로 보이는 기능
- eat()

객체가 실제로 가지고 있는 것과 현재 참조 변수를 통해 사용할 수 있는 것은 다를 수 있다.

오버라이딩된 메서드는 실제 객체 기준으로 호출된다

부모 타입 변수에서는 부모 클래스에 선언된 메서드만 호출할 수 있다.

그러나 그 메서드가 자식 클래스에서 오버라이딩되었다면 부모 메서드가 아니라 자식 클래스에서 재정의한 메서드가 호출된다.

public class Animal {

    public void sound() {
        System.out.println("동물이 소리를 냅니다.");
    }
}

public class Cat extends Animal {

    @Override
    public void sound() {
        System.out.println("야옹");
    }

    public void meow() {
        System.out.println("고양이가 웁니다.");
    }
}

public class PolymorphismExample {

    public static void main(String[] args) {
        Animal animal = new Cat();

        animal.sound();

        // animal.meow();
        // Animal 타입에 선언되지 않아 호출 불가
    }
}

실행 결과는 다음과 같다.

야옹

참조 변수는 Animal 타입이지만 실제 객체가 Cat이므로 Cat에서 오버라이딩한 sound()가 실행된다.

이것이 다형성의 핵심이다.

호출 가능한 메서드
→ 참조 변수 타입을 기준으로 결정

실제로 실행되는 오버라이딩 메서드
→ 실제 객체 타입을 기준으로 결정

다형성으로 유연한 코드 만들기

다형성이란?

다형성은 같은 사용 방법으로 여러 종류의 객체를 다룰 수 있고, 실제 객체에 따라 서로 다른 실행 결과를 만들 수 있는 성질이다.

다형성은 주로 다음 두 가지를 통해 구현된다.

• 부모 타입으로 자식 객체를 참조하는 타입 변환
• 자식 클래스의 메서드 오버라이딩

다음과 같은 동물 클래스가 있다고 가정해보자.

public class Animal {

    public void sound() {
        System.out.println("동물이 소리를 냅니다.");
    }
}

public class Dog extends Animal {

    @Override
    public void sound() {
        System.out.println("멍멍");
    }
}

public class Cat extends Animal {

    @Override
    public void sound() {
        System.out.println("야옹");
    }
}

같은 Animal 타입 변수에 서로 다른 자식 객체를 저장할 수 있다.

Animal first = new Dog();
Animal second = new Cat();

first.sound();
second.sound();

실행 결과는 다음과 같다.

멍멍
야옹

호출 방법은 모두 sound()로 같지만 실제 객체에 따라 서로 다른 동작이 실행된다.

필드의 다형성

필드를 부모 타입으로 선언하면 여러 종류의 자식 객체를 저장할 수 있다.

자동차에 장착되는 타이어를 예로 들어보자.

public class Tire {

    public void roll() {
        System.out.println("일반 타이어가 회전합니다.");
    }
}

public class WinterTire extends Tire {

    @Override
    public void roll() {
        System.out.println("겨울용 타이어가 눈길에서 회전합니다.");
    }
}

public class SportsTire extends Tire {

    @Override
    public void roll() {
        System.out.println("스포츠 타이어가 빠르게 회전합니다.");
    }
}

자동차 클래스의 필드를 부모 타입으로 선언한다.

public class Car {

    private Tire tire;

    public Car(Tire tire) {
        this.tire = tire;
    }

    public void run() {
        tire.roll();
    }

    public void changeTire(Tire tire) {
        this.tire = tire;
    }
}

실행 클래스는 다음과 같다.

public class CarExample {

    public static void main(String[] args) {
        Car car = new Car(new WinterTire());

        car.run();

        car.changeTire(new SportsTire());

        car.run();
    }
}

실행 결과는 다음과 같다.

겨울용 타이어가 눈길에서 회전합니다.
스포츠 타이어가 빠르게 회전합니다.

Car 클래스는 구체적인 타이어 종류를 알 필요가 없다. Tire 타입만 알고 있어도 여러 자식 객체를 사용할 수 있다.

매개변수의 다형성

메서드의 매개변수를 부모 타입으로 선언하면 부모 객체뿐 아니라 모든 자식 객체를 인수로 받을 수 있다.

public class AnimalHospital {

    public void checkup(Animal animal) {
        System.out.println("진료를 시작합니다.");
        animal.sound();
    }
}

public class HospitalExample {

    public static void main(String[] args) {
        AnimalHospital hospital = new AnimalHospital();

        hospital.checkup(new Dog());
        hospital.checkup(new Cat());
    }
}

실행 결과는 다음과 같다.

진료를 시작합니다.
멍멍
진료를 시작합니다.
야옹

다형성을 사용하지 않았다면 각 타입마다 별도의 메서드를 만들어야 할 수도 있다.

void checkupDog(Dog dog) {
}

void checkupCat(Cat cat) {
}

부모 타입 하나로 받으면 자식 클래스가 추가되더라도 기존 메서드를 재사용할 수 있다.

println()도 다형성을 사용한다

System.out.println()에는 여러 오버로딩이 존재하며 객체를 출력하는 메서드는 Object 타입을 받을 수 있다.

System.out.println(new Dog());
System.out.println(new Cat());
System.out.println(new Person());

모든 클래스는 Object를 상속하므로 어떤 객체든 Object 타입 매개변수로 전달할 수 있다.

public void printObject(Object object) {
    System.out.println(object);
}

다만 Object처럼 너무 상위 타입을 사용하면 받을 수 있는 객체의 범위는 넓어지지만, 해당 타입에서 사용할 수 있는 기능은 줄어든다.

따라서 실제 비즈니스 로직에서는 처리하려는 객체들의 공통 부모나 인터페이스를 적절하게 선택하는 것이 중요하다.

배열의 다형성

배열은 같은 타입의 데이터만 저장할 수 있다.

Dog[] dogs = new Dog[3];

Dog[]에는 Dog 객체만 저장할 수 있다.

부모 타입 배열을 사용하면 여러 자식 타입 객체를 하나의 배열에서 관리할 수 있다.

public class AnimalArrayExample {

    public static void main(String[] args) {
        Animal[] animals = new Animal[3];

        animals[0] = new Animal();
        animals[1] = new Dog();
        animals[2] = new Cat();

        for (Animal animal : animals) {
            animal.sound();
        }
    }
}

실제 객체에 따라 오버라이딩된 메서드가 실행된다.

동물이 소리를 냅니다.
멍멍
야옹

Object 배열에는 모든 객체를 저장할 수 있다

Object는 모든 클래스의 최상위 부모이므로 Object[]에는 어떤 참조 타입 객체든 저장할 수 있다.

public class ObjectArrayExample {

    public static void main(String[] args) {
        Object[] values = new Object[4];

        values[0] = "Java";
        values[1] = new Dog();
        values[2] = new Cat();
        values[3] = Integer.valueOf(100);

        for (Object value : values) {
            System.out.println(value);
        }
    }
}

기본 타입 값도 오토박싱을 통해 래퍼 객체로 변환되므로 저장할 수 있다.

values[3] = 100;

실제로는 다음과 비슷한 변환이 일어난다.

values[3] = Integer.valueOf(100);

이러한 구조는 Java 컬렉션이 여러 객체를 저장할 수 있는 기반이 되었다.

다만 현대 Java의 컬렉션은 제네릭을 사용하므로 일반적으로 Object로 모든 값을 섞어 저장하기보다 저장할 타입을 명시한다.

List<Animal> animals = new ArrayList<>();

부모 타입을 다시 자식 타입으로 변환하기

강제 타입 변환

부모 타입 변수에서는 자식 클래스에만 선언된 멤버를 직접 사용할 수 없다.

Animal animal = new Cat();

// animal.meow();
// 호출 불가

실제 객체가 Cat이라는 사실이 확실하다면 부모 타입 참조를 다시 자식 타입으로 변환할 수 있다.

Cat cat = (Cat) animal;

cat.meow();

부모 타입을 자식 타입으로 변환하는 것을 강제 타입 변환, 다운캐스팅, 또는 명시적 형변환이라고 한다.

자동 타입 변환

Cat → Animal
자식 → 부모

강제 타입 변환

Animal → Cat
부모 → 자식

강제 타입 변환이 가능한 조건

부모 타입 변수라고 해서 무조건 자식 타입으로 변환할 수 있는 것은 아니다.

원래 자식 객체가 부모 타입으로 자동 변환되어 저장된 경우에만 다시 해당 자식 타입으로 변환할 수 있다.

Animal animal = new Cat();

Cat cat = (Cat) animal;

위 코드는 실제 객체가 Cat이므로 정상적으로 동작한다.

반면 다음 코드는 실제 객체가 Animal이다.

Animal animal = new Animal();

Cat cat = (Cat) animal;

컴파일은 될 수 있지만 실행 중 ClassCastException이 발생한다.

java.lang.ClassCastException

참조 변수 타입만 보는 것이 아니라 Heap에 실제로 어떤 객체가 생성되어 있는지가 중요하다.

instanceof로 객체 타입 확인하기

안전하게 강제 타입 변환하려면 먼저 instanceof 연산자로 실제 객체 타입을 확인할 수 있다.

객체 instanceof 타입

검사 결과는 boolean으로 반환된다.

Animal animal = new Cat();

boolean result = animal instanceof Cat;

System.out.println(result);

결과는 true다.

안전한 변환 코드는 다음과 같다.

public class TypeCheckExample {

    public static void main(String[] args) {
        Animal animal = new Cat();

        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;

            cat.meow();
        }
    }
}

instanceof 패턴 매칭

Java 16부터는 instanceof 검사와 타입 변환을 한 문장으로 처리하는 패턴 매칭을 사용할 수 있다.

if (animal instanceof Cat cat) {
    cat.meow();
}

기존 코드와 비교하면 다음과 같다.

if (animal instanceof Cat) {
    Cat cat = (Cat) animal;

    cat.meow();
}

패턴 매칭을 사용하면 중복된 캐스팅 코드를 줄이고 타입 검사가 성공한 영역에서 바로 변수를 사용할 수 있다.

메서드에서 타입에 따라 자식 기능 사용하기

public class AnimalService {

    public void handle(Animal animal) {
        animal.sound();

        if (animal instanceof Cat cat) {
            cat.meow();
        }

        if (animal instanceof Dog dog) {
            dog.guard();
        }
    }
}

다만 instanceof가 너무 많이 등장한다면 다형성을 충분히 활용하지 못한 설계일 가능성도 있다.

자식마다 다른 동작이 필요하다면 부모 클래스나 인터페이스에 공통 메서드를 선언하고 오버라이딩하는 방식이 더 적절할 수 있다.

public abstract class Animal {

    public abstract void performSpecialAction();
}

각 자식 객체가 자신의 행동을 직접 책임지도록 만들면 외부 코드에서 타입을 계속 검사할 필요가 줄어든다.

참조 타입과 실제 객체의 메서드 연결

정적 바인딩

바인딩은 메서드나 필드 호출이 실제 코드와 연결되는 것을 의미한다.

컴파일 시점에 참조 변수의 타입을 기준으로 연결이 결정되는 것을 정적 바인딩이라고 한다.

대표적인 경우는 다음과 같다.

• 필드
• static 메서드
• 오버로딩된 메서드
• private 메서드
• final 메서드

부모와 자식 클래스에 같은 이름의 필드가 존재하는 예제를 살펴보자.

public class Parent {

    String name = "부모 필드";

    static void printType() {
        System.out.println("Parent static method");
    }
}

public class Child extends Parent {

    String name = "자식 필드";

    static void printType() {
        System.out.println("Child static method");
    }
}

public class StaticBindingExample {

    public static void main(String[] args) {
        Parent value = new Child();

        System.out.println(value.name);
        value.printType();
    }
}

실행 결과는 다음과 같다.

부모 필드
Parent static method

실제 객체는 Child지만 필드와 정적 메서드는 참조 변수 타입인 Parent를 기준으로 연결된다.

동적 바인딩

오버라이딩된 인스턴스 메서드는 프로그램 실행 시 실제 객체 타입에 따라 연결된다.

이를 동적 바인딩이라고 한다.

public class Parent {

    public void print() {
        System.out.println("Parent");
    }
}

public class Child extends Parent {

    @Override
    public void print() {
        System.out.println("Child");
    }
}

public class DynamicBindingExample {

    public static void main(String[] args) {
        Parent value = new Child();

        value.print();
    }
}

실행 결과는 다음과 같다.

Child

참조 타입은 Parent지만 실제 객체가 Child이므로 가장 마지막에 오버라이딩된 Child.print()가 실행된다.

필드와 static 메서드
→ 참조 변수 타입 기준

오버라이딩된 인스턴스 메서드
→ 실제 객체 타입 기준

이 차이가 다형성을 이해할 때 매우 중요하다.

추상 클래스로 공통 설계 규격 만들기

추상 클래스란?

여러 실체 클래스가 공통으로 가져야 하는 필드와 메서드를 추출해 선언한 클래스를 추상 클래스라고 한다.

추상 클래스는 직접 객체를 생성하기 위한 클래스가 아니라 자식 클래스의 공통 부모와 설계 규격 역할을 한다.

public abstract class Animal {
}

abstract 키워드를 사용해 선언한다.

추상 클래스는 new 연산자로 직접 객체를 생성할 수 없다.

// Animal animal = new Animal();
// 컴파일 오류

상속을 통해 자식 클래스를 만든 뒤 자식 객체를 생성해야 한다.

Animal animal = new Dog();

추상 클래스의 용도

추상 클래스는 크게 두 가지 목적으로 사용한다.

첫째, 여러 자식 클래스에 공통으로 필요한 필드와 메서드를 제공한다.

둘째, 자식 클래스가 반드시 구현해야 하는 기능을 추상 메서드로 선언하여 설계 규격을 통일한다.

public abstract class Animal {

    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + "이(가) 먹이를 먹습니다.");
    }

    public abstract void sound();
}

name, 생성자, eat()은 모든 동물이 공통으로 사용한다.

sound()는 모든 동물에게 필요하지만 구체적인 실행 내용은 자식마다 다르므로 추상 메서드로 선언한다.

추상 클래스도 생성자를 가진다

추상 클래스는 직접 객체를 만들 수 없지만 필드와 생성자를 선언할 수 있다.

public abstract class Animal {

    protected String name;

    public Animal(String name) {
        this.name = name;
    }
}

자식 객체가 생성될 때 super()를 통해 추상 클래스의 생성자가 실행된다.

public class Dog extends Animal {

    public Dog(String name) {
        super(name);
    }

    @Override
    public void sound() {
        System.out.println(name + ": 멍멍");
    }
}

public class Cat extends Animal {

    public Cat(String name) {
        super(name);
    }

    @Override
    public void sound() {
        System.out.println(name + ": 야옹");
    }
}

추상 메서드

추상 메서드는 메서드 선언부만 있고 실행 블록이 없는 메서드다.

public abstract void sound();

중괄호가 없고 세미콜론으로 끝난다.

추상 메서드를 하나라도 가진 클래스는 반드시 추상 클래스로 선언해야 한다.

public abstract class Animal {

    public abstract void sound();
}

추상 클래스를 상속한 일반 자식 클래스는 모든 추상 메서드를 반드시 오버라이딩해야 한다.

public class Dog extends Animal {

    @Override
    public void sound() {
        System.out.println("멍멍");
    }
}

재정의하지 않으려면 자식 클래스 역시 추상 클래스로 선언해야 한다.

public abstract class Mammal extends Animal {
}

추상 클래스를 활용한 다형성

public class AbstractExample {

    public static void main(String[] args) {
        Animal[] animals = {
                new Dog("초코"),
                new Cat("나비")
        };

        for (Animal animal : animals) {
            animal.eat();
            animal.sound();
        }
    }
}

실행 결과는 다음과 같다.

초코이(가) 먹이를 먹습니다.
초코: 멍멍
나비이(가) 먹이를 먹습니다.
나비: 야옹

Animal은 직접 생성할 수 없지만 자식 객체를 부모 타입으로 관리하는 기준 역할을 한다.

캡슐화로 객체의 데이터 보호하기

캡슐화란?

캡슐화는 객체의 데이터와 기능을 하나로 묶고 내부 상태를 외부에서 함부로 변경하지 못하도록 보호하는 객체지향 특성이다.

필드를 public으로 공개하면 외부에서 어떤 값이든 직접 저장할 수 있다.

public class BankAccount {

    public long balance;
}

BankAccount account = new BankAccount();

account.balance = -100_000;

잔액에 음수가 직접 저장되면서 객체가 유효하지 않은 상태가 될 수 있다.

필드를 private으로 숨기고 공개 메서드를 통해서만 변경하도록 제한할 수 있다.

public class BankAccount {

    private long balance;

    public void deposit(long amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException(
                    "입금액은 0보다 커야 합니다."
            );
        }

        balance += amount;
    }

    public boolean withdraw(long amount) {
        if (amount <= 0 || amount > balance) {
            return false;
        }

        balance -= amount;

        return true;
    }

    public long getBalance() {
        return balance;
    }
}

객체 내부에서 유효성을 검사하기 때문에 잘못된 상태를 방지할 수 있다.

Getter와 Setter

private 필드의 값을 외부에서 읽고 변경할 필요가 있다면 Getter와 Setter 메서드를 제공할 수 있다.

public class Member {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException(
                    "이름은 비어 있을 수 없습니다."
            );
        }

        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException(
                    "나이는 음수일 수 없습니다."
            );
        }

        this.age = age;
    }
}

Getter는 값을 반환하는 메서드이고, Setter는 값을 변경하는 메서드다.

getName()
→ name 값을 읽음

setName(...)
→ name 값을 변경

다만 모든 필드에 무조건 Getter와 Setter를 만드는 것이 캡슐화는 아니다.

객체의 상태를 어떤 방식으로 변경해야 하는지에 맞는 의미 있는 메서드를 제공하는 것이 더 중요하다.

account.setBalance(1000);

보다 다음 방식이 객체의 의도를 더 잘 표현한다.

account.deposit(1000);

객체 생성을 제한하는 싱글톤 패턴

객체를 하나만 생성해야 하는 경우

프로그램에 따라 특정 클래스의 객체가 여러 개 필요하지 않을 수 있다.

예를 들어 다음과 같은 경우가 있다.

• 프로그램 전체에서 동일한 설정 객체를 사용할 때
• 공유 상태를 하나의 객체에서 관리해야 할 때
• 객체 생성 비용이 매우 커서 재사용해야 할 때
• 객체의 정체성을 하나로 유지해야 할 때

이때 클래스의 객체를 하나만 생성하고 프로그램 전체에서 공유하도록 만드는 설계 방식을 싱글톤 패턴이라고 한다.

싱글톤 패턴 구현

public final class Singleton {

    private static final Singleton INSTANCE =
            new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return INSTANCE;
    }

    public void sayHello() {
        System.out.println("Hello");
    }
}

구현 원리는 다음과 같다.

외부에서 생성자를 호출하지 못하도록 private 생성자를 선언한다.

private Singleton() {
}

클래스 내부에서 자신의 객체를 하나만 생성한다.

private static final Singleton INSTANCE =
        new Singleton();

객체를 외부에 제공하는 정적 메서드를 선언한다.

public static Singleton getInstance() {
    return INSTANCE;
}

싱글톤 객체 사용

public class SingletonExample {

    public static void main(String[] args) {
        Singleton first = Singleton.getInstance();
        Singleton second = Singleton.getInstance();

        System.out.println(first == second);

        first.sayHello();
    }
}

실행 결과는 다음과 같다.

true
Hello

두 변수는 같은 객체를 참조한다.

first  ──┐
         ├──→ Singleton 객체
second ──┘

싱글톤 사용 시 주의점

싱글톤은 객체를 하나만 유지할 수 있다는 장점이 있지만 전역 상태처럼 사용되기 쉬워 클래스 간 결합도를 높이고 테스트를 어렵게 만들 수 있다.

특히 변경 가능한 상태를 싱글톤이 가지고 있다면 여러 코드가 같은 값을 공유하면서 예상하지 못한 문제가 생길 수 있다.

Spring에서는 직접 싱글톤 코드를 작성하기보다 IoC 컨테이너가 Bean 객체의 생성과 생명주기를 관리한다. 기본적으로 Spring Bean은 싱글톤 스코프로 관리되지만 전통적인 싱글톤 패턴과 구현 방식은 다르다.

Object 클래스의 주요 메서드 재정의하기

Object 클래스

Java의 모든 클래스는 최상위 부모인 Object를 상속한다.

따라서 모든 객체는 다음과 같은 메서드를 사용할 수 있다.

toString()
equals()
hashCode()
getClass()

그중 toString(), equals(), hashCode()는 객체의 목적에 맞게 자주 재정의한다.

toString()

toString()은 객체를 문자열로 표현하는 메서드다.

재정의하지 않고 객체를 출력하면 클래스 이름과 해시 코드 기반 문자열이 출력된다.

public class Person {

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Person person = new Person("김자바", 20);

System.out.println(person);
System.out.println(person.toString());

println()에 객체를 전달하면 내부적으로 객체의 toString() 결과를 출력한다.

의미 있는 내용이 나오도록 재정의할 수 있다.

public class Person {

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{"
                + "name='" + name + '\''
                + ", age=" + age
                + '}';
    }
}

출력 결과는 다음과 같다.

Person{name='김자바', age=20}

equals()

참조 타입에 ==를 사용하면 두 변수가 같은 객체를 참조하는지 비교한다.

Person first = new Person("김자바", 20);
Person second = new Person("김자바", 20);

System.out.println(first == second);

두 객체는 별도로 생성되었으므로 결과는 false다.

객체의 필드 값을 기준으로 논리적인 동등성을 비교하려면 equals()를 재정의해야 한다.

import java.util.Objects;

public class Person {

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object object) {
        if (this == object) {
            return true;
        }

        if (!(object instanceof Person person)) {
            return false;
        }

        return age == person.age
                && Objects.equals(name, person.name);
    }
}

Person first = new Person("김자바", 20);
Person second = new Person("김자바", 20);

System.out.println(first.equals(second));

결과는 true다.

hashCode()

hashCode()는 객체를 구분하기 위해 사용하는 정수 형태의 해시값을 반환한다.

HashSet, HashMap, Hashtable 같은 해시 기반 자료구조는 객체를 저장하고 검색할 때 hashCode()와 equals()를 함께 사용한다.

equals()가 true인 두 객체는 반드시 같은 hashCode()를 반환해야 한다.

따라서 equals()를 재정의할 때는 hashCode()도 함께 재정의해야 한다.

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

완성된 클래스는 다음과 같다.

import java.util.Objects;

public class Person {

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object object) {
        if (this == object) {
            return true;
        }

        if (!(object instanceof Person person)) {
            return false;
        }

        return age == person.age
                && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person{"
                + "name='" + name + '\''
                + ", age=" + age
                + '}';
    }
}

HashSet에서 동등성 확인하기

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {

    public static void main(String[] args) {
        Set<Person> people = new HashSet<>();

        people.add(new Person("김자바", 20));
        people.add(new Person("김자바", 20));

        System.out.println(people.size());
    }
}

equals()와 hashCode()가 올바르게 재정의되어 있다면 논리적으로 같은 두 객체는 중복으로 저장되지 않는다.

실행 결과는 다음과 같다.

1

종합 예제: 결제 방식 다형성

추상 클래스와 다형성을 이용해 여러 결제 방식을 처리해보자.

Payment 추상 클래스

public abstract class Payment {

    private final long amount;

    protected Payment(long amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException(
                    "결제 금액은 0보다 커야 합니다."
            );
        }

        this.amount = amount;
    }

    public long getAmount() {
        return amount;
    }

    public abstract void pay();
}

결제 금액은 모든 결제 방식이 공통으로 가지지만 실제 결제 방식은 자식 클래스마다 다르므로 pay()를 추상 메서드로 선언한다.

CardPayment

public class CardPayment extends Payment {

    private final String cardNumber;

    public CardPayment(long amount, String cardNumber) {
        super(amount);
        this.cardNumber = cardNumber;
    }

    @Override
    public void pay() {
        System.out.printf(
                "카드 %s로 %,d원을 결제합니다.%n",
                cardNumber,
                getAmount()
        );
    }
}

CashPayment

public class CashPayment extends Payment {

    public CashPayment(long amount) {
        super(amount);
    }

    @Override
    public void pay() {
        System.out.printf(
                "현금으로 %,d원을 결제합니다.%n",
                getAmount()
        );
    }
}

PaymentService

public class PaymentService {

    public void process(Payment payment) {
        System.out.println("결제 처리를 시작합니다.");

        payment.pay();

        System.out.println("결제 처리가 완료되었습니다.");
    }
}

매개변수를 Payment 타입으로 선언했기 때문에 모든 자식 결제 객체를 받을 수 있다.

실행 클래스

public class PaymentExample {

    public static void main(String[] args) {
        PaymentService service = new PaymentService();

        Payment cardPayment = new CardPayment(
                50_000,
                "1234-5678"
        );

        Payment cashPayment = new CashPayment(30_000);

        service.process(cardPayment);

        System.out.println();

        service.process(cashPayment);
    }
}

실행 결과는 다음과 같다.

결제 처리를 시작합니다.
카드 1234-5678로 50,000원을 결제합니다.
결제 처리가 완료되었습니다.

결제 처리를 시작합니다.
현금으로 30,000원을 결제합니다.
결제 처리가 완료되었습니다.

PaymentService는 카드 결제인지 현금 결제인지 직접 확인하지 않는다.

단지 Payment 타입의 pay()를 호출할 뿐이며, 실제 객체에 따라 적절한 메서드가 실행된다.

이러한 구조를 사용하면 새로운 결제 방식이 추가되어도 PaymentService를 수정하지 않고 확장할 수 있다.

헷갈리기 쉬운 개념

자동 타입 변환과 강제 타입 변환

Animal animal = new Cat();

자식 객체를 부모 타입으로 저장하므로 자동 타입 변환이다.

Cat cat = (Cat) animal;

부모 타입 참조를 다시 자식 타입으로 바꾸므로 강제 타입 변환이다.

참조 타입과 실제 객체 타입

Animal animal = new Cat();

• 참조 변수 타입: Animal
• 실제 객체 타입: Cat

직접 호출할 수 있는 멤버는 Animal을 기준으로 결정되지만, 오버라이딩된 인스턴스 메서드는 Cat의 메서드가 실행된다.

오버로딩과 동적 바인딩

오버로딩된 메서드는 컴파일 시 전달한 인수와 참조 타입을 기준으로 선택된다.

오버라이딩된 메서드는 실행 시 실제 객체 타입을 기준으로 선택된다.

오버로딩
→ 컴파일 시점

오버라이딩
→ 실행 시점

추상 클래스와 일반 클래스

추상 클래스도 필드, 생성자, 일반 메서드를 가질 수 있다.

차이점은 직접 객체를 생성할 수 없고 추상 메서드를 선언할 수 있다는 것이다.

public abstract class Animal {
}

추상 메서드와 빈 메서드

다음은 추상 메서드다.

public abstract void sound();

실행 내용이 없으며 자식 클래스가 구현해야 한다.

다음은 빈 일반 메서드다.

public void sound() {
}

이미 구현이 완료된 일반 메서드이므로 자식 클래스가 반드시 오버라이딩할 필요가 없다.

final 참조 변수와 불변 객체

final List<String> names = new ArrayList<>();

names가 다른 리스트를 참조하도록 바꿀 수는 없지만 리스트 안의 요소는 추가하거나 삭제할 수 있다.

names.add("Java");

final은 참조 변경을 막는 것이지 객체 내부 상태를 자동으로 불변으로 만드는 것은 아니다.

equals()와 ==

first == second

같은 객체를 참조하는지 비교한다.

first.equals(second)

클래스에서 정의한 논리적인 동등성 기준으로 비교한다.

equals()를 재정의하지 않으면 Object.equals()는 기본적으로 참조 동일성을 비교한다.

실무에서는 어떻게 사용할까?

다형성은 객체지향 설계에서 조건문을 줄이고 기능 확장을 쉽게 만드는 데 사용된다.

다음과 같은 코드는 타입이 추가될 때마다 조건문을 수정해야 한다.

if (payment instanceof CardPayment) {
    // 카드 결제
} else if (payment instanceof CashPayment) {
    // 현금 결제
}

다형성을 활용하면 각 객체가 자신의 동작을 책임질 수 있다.

payment.pay();

새로운 결제 방식이 추가되더라도 Payment를 구현하거나 상속하고 pay()만 재정의하면 된다.

추상 클래스는 여러 구현 클래스가 상태와 공통 로직을 공유해야 할 때 적합하다. 단순히 동작의 규격만 필요하다면 이후 학습할 인터페이스가 더 적절할 수 있다.

객체의 필드는 기본적으로 private으로 숨기고, 객체가 유효한 상태를 유지할 수 있도록 의미 있는 메서드를 제공하는 것이 좋다.

order.changeStatus(OrderStatus.PAID);

단순 Setter보다 객체의 업무 의미가 드러나는 메서드를 사용하는 것이 유지보수에 유리하다.

싱글톤은 필요할 때만 제한적으로 사용해야 한다. Spring 환경에서는 객체 생성을 직접 통제하는 싱글톤 코드보다 컨테이너에 객체 관리를 맡기는 경우가 많다.

equals()와 hashCode()는 DTO, 값 객체, 컬렉션의 키처럼 논리적 동등성이 중요한 클래스에서 함께 재정의해야 한다. Java의 record를 사용하면 컴파일러가 두 메서드와 toString()을 자동으로 생성해주므로 값 전달 객체를 표현할 때 유용하다.

오늘 배운 내용 정리

이번 글에서는 상속 관계의 객체를 유연하게 사용하는 다형성과 객체 형변환을 정리했다.

• 참조 타입도 상속 관계에서 타입 변환이 가능하다.
• 자식 객체는 부모 타입 변수에 자동으로 저장할 수 있다.
• 자식 타입에서 부모 타입으로의 변환을 업캐스팅이라고 한다.
• 바로 위 부모뿐 아니라 상속 계층의 더 상위 타입으로도 변환할 수 있다.
• 모든 객체는 Object 타입으로 참조할 수 있다.
• 부모 타입 변수에서는 부모 클래스에 선언된 멤버만 직접 사용할 수 있다.
• 부모 메서드가 자식 클래스에서 오버라이딩되었다면 실제 자식 객체의 메서드가 실행된다.
• 같은 호출 방식으로 객체마다 다른 결과가 나오는 성질을 다형성이라고 한다.
• 부모 타입 필드에는 여러 자식 객체를 저장할 수 있다.
• 부모 타입 매개변수에는 부모 객체와 모든 자식 객체를 전달할 수 있다.
• 부모 타입 배열을 사용하면 서로 다른 자식 객체를 하나의 배열에서 관리할 수 있다.
• Object[]에는 모든 참조 타입 객체를 저장할 수 있다.
• 기본 타입 값은 오토박싱을 통해 래퍼 객체로 변환되어 Object에 저장될 수 있다.
• 부모 타입을 다시 자식 타입으로 변환하는 것을 다운캐스팅이라고 한다.
• 강제 타입 변환은 실제 객체가 해당 자식 타입인 경우에만 안전하다.
• 잘못된 강제 타입 변환은 ClassCastException을 발생시킨다.
• instanceof로 객체의 실제 타입을 확인할 수 있다.
• Java 16부터 instanceof 패턴 매칭을 사용할 수 있다.
• 필드와 static 메서드는 참조 변수 타입을 기준으로 연결된다.
• 오버라이딩된 인스턴스 메서드는 실제 객체 타입을 기준으로 실행된다.
• 이를 동적 바인딩이라고 한다.
• 추상 클래스는 실체 클래스의 공통 상태와 기능을 추출한 부모 클래스다.
• 추상 클래스는 직접 객체를 생성할 수 없다.
• 추상 클래스도 필드, 생성자, 일반 메서드를 가질 수 있다.
• 추상 메서드는 실행 블록 없이 선언만 존재한다.
• 일반 자식 클래스는 부모의 추상 메서드를 반드시 오버라이딩해야 한다.
• 캡슐화는 객체의 데이터를 숨기고 공개 메서드로 접근을 통제하는 것이다.
• 필드를 private으로 선언하면 외부에서 직접 변경할 수 없다.
• Getter와 Setter는 필드 접근 통로가 될 수 있지만 무조건 만들어야 하는 것은 아니다.
• 객체의 의도를 나타내는 메서드를 제공하는 것이 더 좋은 캡슐화일 수 있다.
• 싱글톤 패턴은 객체를 하나만 생성해 공유하는 방식이다.
• 싱글톤은 private 생성자와 static 인스턴스 및 접근 메서드로 구현할 수 있다.
• toString()은 객체를 의미 있는 문자열로 표현하도록 재정의할 수 있다.
• equals()는 객체의 논리적인 동등성을 비교하도록 재정의할 수 있다.
• equals()를 재정의하면 hashCode()도 함께 재정의해야 한다.
• 해시 기반 컬렉션은 객체 비교에 hashCode()와 equals()를 함께 사용한다.

면접과 평가에서 자주 나오는 질문

업캐스팅과 다운캐스팅의 차이

업캐스팅
- 자식 타입 → 부모 타입
- 자동 변환
- 안전한 변환
- 사용할 수 있는 멤버 범위가 부모 기준으로 제한

다운캐스팅
- 부모 타입 → 자식 타입
- 명시적 캐스팅 필요
- 실제 객체 타입이 맞지 않으면 ClassCastException

부모 타입인데 왜 자식 메서드가 실행되는가?

부모 타입 변수로 호출 가능한 메서드는 컴파일 단계에서 결정되지만, 오버라이딩된 인스턴스 메서드의 실제 구현은 런타임에 실제 객체 타입을 기준으로 선택되기 때문이다. 이를 동적 바인딩이라고 한다.

필드는 다형성이 적용되는가?

메서드 오버라이딩과 같은 방식의 다형성이 적용되지 않는다. 중복된 필드는 참조 변수 타입을 기준으로 선택된다.

instanceof를 많이 쓰면 왜 좋지 않을 수 있는가?

객체별 동작을 외부 코드가 타입별로 분기하고 있다는 뜻일 수 있다. 자식 클래스가 자신의 동작을 오버라이딩하도록 설계하면 타입 검사 코드를 줄일 수 있다.

추상 클래스는 생성자가 왜 필요한가?

자식 객체가 생성될 때 부모 클래스에서 선언한 필드를 초기화하고 공통 초기화 작업을 수행하기 위해 필요하다.

추상 클래스에 일반 메서드를 작성할 수 있는가?

가능하다. 추상 클래스는 일반 클래스의 기능을 모두 가지면서 추상 메서드를 추가로 선언할 수 있다.

private 생성자는 상속을 막는가?

직접적인 자식 클래스의 생성자가 부모 생성자를 호출할 수 없기 때문에 일반적으로 상속이 불가능해진다. 다만 같은 최상위 클래스 내부에 선언된 중첩 클래스처럼 접근 가능한 특별한 위치는 예외가 될 수 있다.

equals만 재정의하면 어떤 문제가 생기는가?

HashSet이나 HashMap이 먼저 해시 코드를 기준으로 객체 위치를 찾기 때문에, 논리적으로 같은 객체가 서로 다른 버킷에 저장되어 중복 처리나 검색 실패가 발생할 수 있다.

들어가며

앞선 글에서는 객체와 클래스, 필드, 메서드, 생성자를 이용해 하나의 객체를 설계하는 방법을 살펴보았다.

하지만 실제 프로그램에서는 여러 클래스가 완전히 독립적으로 존재하지 않는다. 자동차와 전기 자동차처럼 공통된 속성과 기능을 가지는 클래스도 있고, 자동차와 엔진처럼 하나의 객체가 다른 객체를 부품으로 포함하는 경우도 있다.

예를 들어 Dog와 Cat 클래스가 모두 이름과 나이를 가지고 있으며 먹는 기능을 제공한다고 생각해보자.

public class Dog {

    String name;
    int age;

    void eat() {
        System.out.println("먹이를 먹습니다.");
    }

    void bark() {
        System.out.println("멍멍");
    }
}

public class Cat {

    String name;
    int age;

    void eat() {
        System.out.println("먹이를 먹습니다.");
    }

    void meow() {
        System.out.println("야옹");
    }
}

두 클래스에는 name, age, eat()이라는 코드가 중복되어 있다. 이런 공통 기능을 상위 클래스에 정의하고 하위 클래스가 물려받도록 만드는 기능이 상속이다.

이번 글에서는 Java의 상속과 포함 관계, 메서드 오버라이딩, super, Object, 패키지와 import, 접근 제한자와 final, 그리고 상속 범위를 제한하는 봉인 클래스까지 정리해보려고 한다.

상속으로 클래스의 공통 기능 재사용하기

상속이란?

상속은 기존 클래스가 가지고 있는 필드와 메서드를 새로운 클래스가 물려받아 재사용하는 기능이다.

기존 클래스를 부모 클래스 또는 상위 클래스라고 하며, 부모 클래스를 상속받는 클래스를 자식 클래스 또는 하위 클래스라고 한다.

부모 클래스
- 공통 속성
- 공통 기능

       ↓ 상속

자식 클래스
- 부모의 속성과 기능 사용
- 자신만의 속성과 기능 추가

Java에서는 extends 키워드를 이용해 상속 관계를 만든다.

public class Animal {

    String name;
    int age;

    void eat() {
        System.out.println(name + "이(가) 먹이를 먹습니다.");
    }
}

public class Dog extends Animal {

    void bark() {
        System.out.println(name + "이(가) 멍멍 짖습니다.");
    }
}

Dog 클래스에는 name, age, eat()이 직접 선언되어 있지 않지만 Animal 클래스로부터 상속받았기 때문에 사용할 수 있다.

public class AnimalExample {

    public static void main(String[] args) {
        Dog dog = new Dog();

        dog.name = "초코";
        dog.age = 3;

        dog.eat();
        dog.bark();
    }
}

실행 결과는 다음과 같다.

초코이(가) 먹이를 먹습니다.
초코이(가) 멍멍 짖습니다.

상속을 사용하면 여러 클래스에 반복되는 코드를 공통 부모 클래스로 옮길 수 있다.

Animal
- name
- age
- eat()

Dog extends Animal
- bark()

Cat extends Animal
- meow()

공통 기능을 부모 클래스에서 관리하기 때문에 부모 클래스의 코드를 수정하면 이를 상속받는 자식 클래스에도 변경 사항이 반영된다.

상속되지 않는 것

자식 클래스가 부모 클래스의 모든 코드를 그대로 물려받는 것은 아니다.

부모 클래스의 다음 요소는 자식 클래스에 직접 상속되지 않는다.

• 부모 클래스의 생성자
• 부모 클래스의 초기화 블록
• 접근할 수 없는 private 멤버

생성자는 객체를 초기화하기 위해 해당 클래스가 직접 실행하는 코드이므로 상속되지 않는다. 다만 자식 객체가 만들어질 때 부모 생성자는 반드시 호출된다.

public class Parent {

    Parent() {
        System.out.println("Parent 생성자 실행");
    }
}

public class Child extends Parent {

    Child() {
        System.out.println("Child 생성자 실행");
    }
}

public class ConstructorExample {

    public static void main(String[] args) {
        Child child = new Child();
    }
}

실행 결과는 다음과 같다.

Parent 생성자 실행
Child 생성자 실행

자식 객체를 만들 때 부모 부분이 먼저 초기화되고, 이후 자식 부분이 초기화된다.

상속은 is-a 관계다

상속 관계는 흔히 is-a 관계라고 표현한다.

Dog is an Animal.
강아지는 동물이다.

ElectricCar is a Car.
전기 자동차는 자동차다.

자식 객체를 부모 타입의 한 종류라고 자연스럽게 말할 수 있다면 상속 관계를 고려할 수 있다.

public class ElectricCar extends Car {
}

반대로 다음 관계는 자연스럽지 않다.

Engine is a Car.
엔진은 자동차다.

엔진은 자동차의 한 종류가 아니라 자동차가 가지고 있는 부품이다. 이런 관계는 상속이 아니라 포함 관계로 설계해야 한다.

Java가 단일 상속만 지원하는 이유

Java 클래스는 하나의 부모 클래스만 직접 상속할 수 있다.

public class Child extends Parent {
}

다음처럼 두 클래스를 동시에 상속할 수는 없다.

// 사용할 수 없는 문법
// public class Child extends ParentA, ParentB {
// }

만약 다중 상속을 허용했는데 두 부모 클래스에 동일한 이름과 형태의 메서드가 존재한다면 어떤 메서드를 사용해야 하는지 모호해질 수 있다.

ParentA
└─ print()

ParentB
└─ print()

Child
└─ 어느 print()를 상속해야 하는가?

Java는 이러한 복잡성을 줄이기 위해 클래스의 단일 상속만 허용한다.

다만 하나의 클래스가 여러 인터페이스를 구현하는 것은 가능하다.

public class SmartPhone
        implements Camera, MusicPlayer, Phone {
}

여러 객체의 기능이 필요하다면 인터페이스와 포함 관계를 함께 활용할 수 있다.

모든 클래스의 부모인 Object

Java의 모든 클래스는 최종적으로 Object 클래스를 상속한다.

다음 클래스에 extends가 작성되어 있지 않더라도

public class Person {
}

개념적으로는 다음과 같은 구조를 가진다.

public class Person extends Object {
}

따라서 모든 객체는 Object 클래스가 제공하는 메서드를 사용할 수 있다.

대표적인 메서드는 다음과 같다.

public class Person {

    String name;
}

public class ObjectExample {

    public static void main(String[] args) {
        Person person = new Person();

        System.out.println(person.toString());
        System.out.println(person.getClass());
        System.out.println(person.hashCode());
    }
}

이 메서드들은 Person에 직접 선언하지 않았지만 Object로부터 상속받았기 때문에 사용할 수 있다.

상속과 포함 관계를 구분하기

포함 관계란?

클래스를 재사용하는 방법에는 상속만 있는 것이 아니다.

하나의 클래스가 다른 클래스의 객체를 필드로 가지도록 설계할 수도 있다. 이를 포함 관계 또는 구성 관계라고 한다.

포함 관계는 보통 has-a 관계라고 표현한다.

Car has an Engine.
자동차는 엔진을 가지고 있다.

Computer has a CPU.
컴퓨터는 CPU를 가지고 있다.

public class Engine {

    void start() {
        System.out.println("엔진이 작동합니다.");
    }
}

public class Car {

    private final Engine engine;

    public Car() {
        this.engine = new Engine();
    }

    void start() {
        engine.start();
        System.out.println("자동차가 출발할 준비를 마쳤습니다.");
    }
}

public class CarExample {

    public static void main(String[] args) {
        Car car = new Car();

        car.start();
    }
}

Car는 Engine을 상속하지 않고 필드로 포함한다.

상속과 포함 중 무엇을 선택할까?

상속과 포함은 단순히 문법의 문제가 아니라 클래스 설계의 문제다.

Dog is an Animal
→ 상속

Car has an Engine
→ 포함

상속을 잘못 사용하면 부모 클래스와 자식 클래스가 지나치게 강하게 결합될 수 있다. 부모 클래스의 변경이 모든 자식 클래스에 영향을 주기 때문이다.

따라서 단순히 코드를 재사용하고 싶다는 이유만으로 상속을 사용하기보다, 실제로 자연스러운 is-a 관계가 성립하는지 먼저 생각해야 한다.

💡 상속보다 포함을 우선해서 고려하라는 설계 원칙을 “상속보다는 컴포지션을 선호하라”라고 표현하기도 한다.

메서드 오버라이딩과 super

메서드 오버라이딩이란?

부모 클래스에서 정의한 메서드가 자식 클래스의 상황에 맞지 않을 수 있다.

예를 들어 모든 동물이 소리를 낸다는 공통 기능은 있지만, 강아지와 고양이는 서로 다른 소리를 낸다.

public class Animal {

    void sound() {
        System.out.println("동물이 소리를 냅니다.");
    }
}

자식 클래스에서 부모 메서드를 자신의 동작에 맞게 다시 정의하는 것을 메서드 오버라이딩이라고 한다.

public class Dog extends Animal {

    @Override
    void sound() {
        System.out.println("멍멍");
    }
}

public class Cat extends Animal {

    @Override
    void sound() {
        System.out.println("야옹");
    }
}

public class OverrideExample {

    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();

        dog.sound();
        cat.sound();
    }
}

실행 결과는 다음과 같다.

멍멍
야옹

오버라이딩의 조건

부모 메서드를 오버라이딩하려면 기본적으로 다음 조건을 만족해야 한다.

• 메서드 이름이 같아야 한다.
• 매개변수의 타입, 개수, 순서가 같아야 한다.
• 반환 타입이 같거나 부모 반환 타입의 하위 타입이어야 한다.
• 접근 제한 범위는 부모 메서드보다 좁아질 수 없다.
• 부모 메서드보다 더 넓은 범위의 검사 예외를 선언할 수 없다.
• final, private, static 메서드는 일반적인 인스턴스 메서드 오버라이딩 대상이 아니다.

반환 타입은 반드시 완전히 같아야 하는 것은 아니다. 참조 타입이라면 부모 반환 타입의 하위 타입으로 변경할 수 있으며, 이를 공변 반환 타입이라고 한다.

public class Animal {

    Animal create() {
        return new Animal();
    }
}

public class Dog extends Animal {

    @Override
    Dog create() {
        return new Dog();
    }
}

Dog는 Animal의 하위 타입이기 때문에 허용된다.

@Override 어노테이션

오버라이딩한 메서드 위에는 @Override를 작성하는 것이 좋다.

@Override
void sound() {
    System.out.println("멍멍");
}

@Override는 컴파일러에게 해당 메서드가 부모 클래스나 인터페이스의 메서드를 재정의한 것임을 알려준다.

메서드 이름이나 매개변수를 잘못 작성하면 컴파일러가 오류를 알려준다.

public class Dog extends Animal {

    @Override
    void sounds() {
        System.out.println("멍멍");
    }
}

부모 클래스에 sounds()라는 메서드가 없다면 컴파일 오류가 발생한다.

@Override가 없다면 새로운 메서드를 선언한 것으로 처리될 수 있기 때문에 오버라이딩할 때는 항상 작성하는 것이 안전하다.

오버로딩과 오버라이딩

이름이 비슷하지만 완전히 다른 개념이다.

// 오버로딩
int add(int left, int right) {
    return left + right;
}

double add(double left, double right) {
    return left + right;
}

// 오버라이딩
@Override
void sound() {
    System.out.println("멍멍");
}

super로 부모 멤버 사용하기

this가 현재 객체를 가리킨다면 super는 현재 객체의 부모 클래스 부분을 가리킨다.

부모 메서드를 오버라이딩한 뒤 기존 기능도 함께 사용하고 싶다면 super.메서드()를 호출할 수 있다.

public class Animal {

    void introduce() {
        System.out.println("동물입니다.");
    }
}

public class Dog extends Animal {

    @Override
    void introduce() {
        super.introduce();
        System.out.println("그중에서도 강아지입니다.");
    }
}

public class SuperExample {

    public static void main(String[] args) {
        Dog dog = new Dog();

        dog.introduce();
    }
}

실행 결과는 다음과 같다.

동물입니다.
그중에서도 강아지입니다.

부모 메서드의 기존 기능을 재사용하면서 자식 기능을 추가할 수 있다.

this와 super

this.name

현재 객체의 멤버에 접근한다.

super.name

부모 클래스에 선언된 멤버에 접근한다.

부모와 자식 클래스에 같은 이름의 필드가 있다면 this와 super를 통해 구분할 수 있다.

public class Parent {

    String name = "부모 필드";
}

public class Child extends Parent {

    String name = "자식 필드";

    void printNames() {
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

다만 부모와 자식 클래스에 같은 이름의 필드를 중복해서 선언하는 것은 혼란을 만들 수 있으므로 특별한 이유가 없다면 피하는 것이 좋다.

super()와 부모 생성자

this()가 같은 클래스의 다른 생성자를 호출한다면 super()는 부모 클래스의 생성자를 호출한다.

public class Animal {

    String name;

    Animal(String name) {
        this.name = name;
    }
}

public class Dog extends Animal {

    String breed;

    Dog(String name, String breed) {
        super(name);
        this.breed = breed;
    }
}

public class ConstructorExample {

    public static void main(String[] args) {
        Dog dog = new Dog("초코", "푸들");

        System.out.println(dog.name);
        System.out.println(dog.breed);
    }
}

부모 클래스에 선언된 필드는 부모 생성자에서 초기화하고, 자식 클래스에 추가된 필드는 자식 생성자에서 초기화하는 구조다.

super() 사용 규칙

super()는 자식 생성자의 첫 번째 실행문으로만 작성할 수 있다.

Dog(String name, String breed) {
    super(name);
    this.breed = breed;
}

생성자의 첫 번째 줄에는 this() 또는 super() 중 하나만 올 수 있다.

this()
→ 같은 클래스의 다른 생성자 호출

super()
→ 부모 클래스의 생성자 호출

명시적으로 작성하지 않으면 컴파일러가 매개변수가 없는 super()를 자동으로 삽입한다.

Dog() {
    super();
}

따라서 부모 클래스에 매개변수가 없는 생성자가 없으면 자식 클래스에서 부모 생성자를 직접 호출해야 한다.

public class Animal {

    Animal(String name) {
    }
}

public class Dog extends Animal {

    Dog() {
        super("이름 없음");
    }
}

자식 객체를 생성하면 부모 클래스부터 Object까지 생성자가 위에서부터 순서대로 실행된다.

Object 생성자
→ 부모 생성자
→ 자식 생성자

정확히는 별도의 부모 객체와 자식 객체가 각각 따로 생성되는 것이 아니라, 하나의 자식 객체 내부에서 부모 클래스가 담당하는 부분부터 순서대로 초기화된다고 이해하는 것이 좋다.

클래스의 상속 범위와 구조 제한하기

final

final은 대상에 따라 “더 이상 변경하거나 확장할 수 없다”는 의미를 부여한다.

final 변수

final 변수는 한 번 값을 저장한 뒤 다시 변경할 수 없다.

final int maxCount = 100;

// maxCount = 200;
// 컴파일 오류

상수는 일반적으로 static final과 함께 선언한다.

public class MathConstants {

    public static final double PI = 3.141592;
}

System.out.println(MathConstants.PI);

final 필드가 객체마다 다른 값을 가져야 한다면 생성자에서 초기화할 수 있다. 이를 빈 final 필드 또는 blank final field라고 한다.

public class Member {

    private final String id;

    public Member(String id) {
        this.id = id;
    }
}

각 객체는 생성될 때 서로 다른 id를 한 번만 저장할 수 있다.

final 메서드

final 메서드는 자식 클래스에서 오버라이딩할 수 없다.

public class Account {

    final void printSecurityMessage() {
        System.out.println("보안 기능을 실행합니다.");
    }
}

public class SavingsAccount extends Account {

    // 오버라이딩할 수 없음
    // @Override
    // void printSecurityMessage() {
    // }
}

핵심 동작을 자식 클래스가 변경하지 못하도록 막을 때 사용할 수 있다.

final 클래스

final 클래스는 다른 클래스가 상속할 수 없다.

public final class Utility {
}

// 상속할 수 없음
// public class ChildUtility extends Utility {
// }

대표적인 final 클래스에는 String과 여러 불변 클래스가 있다.

다만 Math 클래스는 final 클래스이기도 하지만 생성자도 private으로 선언되어 객체 생성을 막고 정적 기능만 제공한다.

sealed class

final 클래스는 모든 상속을 금지한다.

하지만 특정 클래스에게만 상속을 허용하고 그 외 클래스의 상속은 막고 싶을 수 있다. 이때 봉인 클래스인 sealed class를 사용할 수 있다.

public sealed class Payment
        permits CardPayment, CashPayment {
}

Payment는 CardPayment와 CashPayment만 직접 상속할 수 있다.

허용된 자식 클래스는 반드시 다음 중 하나로 선언해야 한다.

• final
• sealed
• non-sealed

final 자식 클래스

더 이상의 상속을 허용하지 않는다.

public final class CashPayment extends Payment {
}

sealed 자식 클래스

자신의 자식 클래스도 제한한다.

public sealed class CardPayment extends Payment
        permits CreditCardPayment {
}

public final class CreditCardPayment
        extends CardPayment {
}

non-sealed 자식 클래스

부모 클래스에서 적용받은 봉인을 해제한다.

public non-sealed class CardPayment extends Payment {
}

이제 다른 클래스가 CardPayment를 자유롭게 상속할 수 있다.

public class CreditCardPayment extends CardPayment {
}

sealed class를 사용하는 이유

봉인 클래스는 상속 계층을 명확하게 제한할 수 있다.

Payment
├─ CardPayment
└─ CashPayment

결제 방식, 사용자 권한, 명령 종류처럼 가능한 하위 타입이 명확하게 제한되어야 하는 모델에 적합하다.

public sealed interface UserRole
        permits Admin, Member, Guest {
}

의도하지 않은 클래스가 상속 구조에 들어오는 것을 막을 수 있으며, 클래스 계층을 분석하기도 쉬워진다.

💡 sealed class는 Java 17에서 정식 기능으로 도입되었다.

permits는 항상 반드시 직접 작성해야 하는 것은 아니다. 허용할 자식 클래스가 같은 소스 파일에 선언되어 있다면 컴파일러가 이를 추론할 수 있어 생략할 수 있다.

public sealed class Shape {
}

final class Circle extends Shape {
}

final class Rectangle extends Shape {
}

패키지와 접근 범위 관리하기

패키지란?

프로그램의 클래스가 많아지면 관련된 클래스를 목적에 따라 분류할 필요가 있다.

컴퓨터에서 파일을 폴더로 나누어 관리하는 것처럼 Java에서는 클래스를 패키지로 나누어 관리한다.

com.example
├─ member
│  ├─ Member.java
│  └─ MemberService.java
│
├─ order
│  ├─ Order.java
│  └─ OrderService.java
│
└─ product
   ├─ Product.java
   └─ ProductService.java

패키지는 클래스를 분류하는 역할뿐만 아니라 클래스의 전체 이름을 구성한다.

com.example.member.Member

이처럼 패키지 이름과 클래스 이름을 모두 포함한 이름을 Fully Qualified Name, 즉 완전한 클래스 이름이라고 한다.

패키지 선언

패키지는 소스 파일의 주석과 공백을 제외한 첫 번째 문장에 선언한다.

package com.example.member;

public class Member {
}

하나의 소스 파일에는 하나의 패키지만 선언할 수 있다.

패키지를 선언하지 않은 클래스는 이름 없는 기본 패키지에 속하지만, 실제 프로젝트에서는 기본 패키지를 사용하지 않는 것이 좋다.

패키지 이름 작성 규칙

패키지 이름은 일반적으로 모두 소문자로 작성한다.

회사나 조직의 도메인을 역순으로 사용하고 프로젝트와 기능을 이어 붙이는 방식이 널리 사용된다.

com.company.project.member
com.company.project.order
org.example.application.product

예를 들어 다음과 같이 구성할 수 있다.

com.ssafy.project.member
com.ssafy.project.order
com.ssafy.project.common

import

현재 클래스와 다른 패키지에 있는 클래스를 짧은 이름으로 사용하려면 import를 작성한다.

package com.example.order;

import com.example.member.Member;

public class Order {

    Member member;
}

import를 사용하지 않으면 완전한 클래스 이름을 작성해야 한다.

public class Order {

    com.example.member.Member member;
}

import 작성 위치

import는 패키지 선언과 클래스 선언 사이에 작성한다.

package com.example.order;

import com.example.member.Member;
import java.util.ArrayList;
import java.util.List;

public class Order {
}

패키지 선언은 하나만 가능하지만 import는 여러 개 작성할 수 있다.

와일드카드 import

특정 패키지의 여러 클래스를 가져오려면 *를 사용할 수 있다.

import java.util.*;

다만 *는 해당 패키지에 직접 포함된 클래스만 가져온다. 하위 패키지까지 가져오지는 않는다.

import java.util.*;

위 코드는 다음 하위 패키지의 클래스까지 가져오지 않는다.

java.util.concurrent
java.util.function
java.util.stream

또한 와일드카드 import는 어떤 클래스를 사용하는지 한눈에 파악하기 어려울 수 있어 IDE가 생성하는 개별 import를 유지하는 경우가 많다.

이름이 같은 클래스 사용하기

서로 다른 패키지에 이름이 같은 클래스가 존재할 수 있다.

java.util.Date
java.sql.Date

두 클래스를 동시에 사용해야 한다면 하나는 완전한 클래스 이름으로 작성해야 한다.

import java.util.Date;

public class DateExample {

    Date utilDate;
    java.sql.Date sqlDate;
}

기본으로 import되는 패키지

java.lang 패키지는 별도로 import하지 않아도 자동으로 사용할 수 있다.

String
System
Math
Object
Integer

다음 import는 명시적으로 작성하지 않아도 된다.

import java.lang.*;

Eclipse 계열 IDE에서는 일반적으로 Ctrl + Shift + O를 이용해 import를 자동으로 정리할 수 있다.

접근 제한자로 객체 보호하기

제한자란?

제한자는 클래스, 필드, 생성자, 메서드 선언부에 추가적인 의미를 부여하는 키워드다.

제한자는 크게 접근 제한자와 그 외 제한자로 나눌 수 있다.

접근 제한자
- public
- protected
- default
- private

그 외 제한자
- static
- final
- abstract
- synchronized
- ...

하나의 선언에 여러 제한자를 함께 사용할 수 있다.

public static final int MAX_COUNT = 100;

순서는 문법적으로 크게 중요하지 않지만 일반적으로 접근 제한자를 가장 앞에 작성한다.

접근 제한자 비교

접근 제한자는 해당 클래스나 멤버를 어느 범위까지 사용할 수 있는지 결정한다.

default는 실제 키워드를 작성하는 것이 아니라 접근 제한자를 생략한 상태다.

class Member {
}

void print() {
}

public

public은 어디에서든 접근할 수 있다.

public class Member {

    public void introduce() {
        System.out.println("회원입니다.");
    }
}

다른 패키지에서도 import한 뒤 사용할 수 있다.

private

private은 해당 클래스 내부에서만 접근할 수 있다.

public class BankAccount {

    private long balance;

    public void deposit(long amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public long getBalance() {
        return balance;
    }
}

외부 코드가 balance를 직접 음수로 변경하지 못하도록 보호할 수 있다.

BankAccount account = new BankAccount();

// account.balance = -100_000;
// 접근 불가

이처럼 데이터를 외부에 직접 노출하지 않고 메서드를 통해 제어하는 것을 캡슐화라고 한다.

default

접근 제한자를 생략하면 같은 패키지 내부에서만 접근할 수 있다.

class PackageMember {

    void print() {
        System.out.println("같은 패키지에서 사용 가능");
    }
}

패키지 내부에서만 사용하는 클래스나 기능에 적합하다.

protected

protected는 같은 패키지에서는 default와 비슷하게 접근할 수 있다.

다른 패키지에서는 해당 클래스를 상속한 자식 클래스가 상속 관계를 통해 접근할 수 있다.

package parent;

public class Parent {

    protected int value = 10;
}

package child;

import parent.Parent;

public class Child extends Parent {

    void printValue() {
        System.out.println(value);
    }
}

다른 패키지의 일반 클래스에서는 사용할 수 없다.

protected는 “어디서나 자식 객체를 통해 접근 가능하다”는 단순한 의미가 아니며, 다른 패키지에서는 상속받은 자식 클래스 내부에서 상속 관계를 통해 사용해야 한다.

오버라이딩과 접근 제한자

자식 클래스에서 메서드를 오버라이딩할 때 접근 범위를 부모보다 좁게 만들 수 없다.

public class Parent {

    protected void print() {
    }
}

다음 오버라이딩은 가능하다.

public class Child extends Parent {

    @Override
    public void print() {
    }
}

protected보다 넓은 public으로 변경했기 때문이다.

다음 코드는 사용할 수 없다.

public class Child extends Parent {

    // 접근 범위를 좁힐 수 없음
    // @Override
    // private void print() {
    // }
}

부모 타입으로 사용할 수 있었던 기능이 자식 객체에서는 갑자기 사용할 수 없게 되면 다형성의 일관성이 깨질 수 있기 때문이다.

어노테이션으로 코드에 정보 추가하기

어노테이션이란?

어노테이션은 소스 코드에 추가하는 메타데이터다.

사전적으로는 주석이라는 의미지만 일반 주석과 달리 컴파일러, JVM, 프레임워크 등이 읽고 활용할 수 있다.

@Override
public String toString() {
    return "Member";
}

어노테이션은 코드 자체의 동작을 직접 작성하기보다 코드에 대한 정보나 처리 방법을 추가한다.

대표적인 기본 어노테이션은 다음과 같다.

@Deprecated

더 이상 사용을 권장하지 않는 클래스나 메서드에 사용한다.

public class LegacyService {

    @Deprecated
    public void oldMethod() {
        System.out.println("이전 방식");
    }

    public void newMethod() {
        System.out.println("새로운 방식");
    }
}

기존 코드와의 호환성을 위해 메서드는 남겨두되 새로운 코드에서는 사용하지 않도록 안내할 수 있다.

@SuppressWarnings

특정 경고를 의도적으로 무시할 때 사용한다.

@SuppressWarnings("deprecation")
public void useLegacyMethod() {
    LegacyService service = new LegacyService();
    service.oldMethod();
}

경고가 불편하다는 이유로 무조건 사용하는 것이 아니라, 경고가 발생하는 원인을 이해하고 의도적으로 무시해도 안전할 때만 사용해야 한다.

종합 예제: 회원 등급 상속 구조

지금까지 배운 내용을 이용해 회원 등급을 표현해보자.

Member 클래스

package member;

public class Member {

    private final String id;
    private String name;

    public Member(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public void printInfo() {
        System.out.println("아이디: " + id);
        System.out.println("이름: " + name);
    }

    public int calculatePoint(int price) {
        return price / 100;
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    protected void setName(String name) {
        this.name = name;
    }
}

id는 객체 생성 후 변경되어서는 안 되므로 final로 선언했다.

외부에서 필드에 직접 접근하지 못하도록 private으로 보호하고 필요한 기능만 메서드로 제공한다.

VipMember 클래스

package member;

public final class VipMember extends Member {

    private final double pointRate;

    public VipMember(
            String id,
            String name,
            double pointRate
    ) {
        super(id, name);
        this.pointRate = pointRate;
    }

    @Override
    public int calculatePoint(int price) {
        return (int) (price * pointRate);
    }

    @Override
    public void printInfo() {
        super.printInfo();
        System.out.println("회원 등급: VIP");
        System.out.printf(
                "적립률: %.1f%%%n",
                pointRate * 100
        );
    }
}

VipMember는 Member를 상속한다.

부모의 생성자는 super()를 이용해 호출하고, 포인트 계산 방식은 VIP 회원에게 맞게 오버라이딩한다.

printInfo()에서는 부모 메서드를 super.printInfo()로 재사용한 뒤 VIP 정보를 추가로 출력한다.

실행 클래스

package app;

import member.Member;
import member.VipMember;

public class MemberExample {

    public static void main(String[] args) {
        Member normalMember = new Member(
                "member01",
                "김자바"
        );

        VipMember vipMember = new VipMember(
                "vip01",
                "이자바",
                0.05
        );

        normalMember.printInfo();
        System.out.println(
                "적립 포인트: "
                        + normalMember.calculatePoint(100_000)
        );

        System.out.println();

        vipMember.printInfo();
        System.out.println(
                "적립 포인트: "
                        + vipMember.calculatePoint(100_000)
        );
    }
}

실행 결과는 다음과 같다.

아이디: member01
이름: 김자바
적립 포인트: 1000

아이디: vip01
이름: 이자바
회원 등급: VIP
적립률: 5.0%
적립 포인트: 5000

이 예제에는 다음 개념이 사용되었다.

• extends를 이용한 상속
• super()를 이용한 부모 생성자 호출
• @Override를 이용한 메서드 재정의
• super.메서드()를 이용한 부모 기능 재사용
• private을 이용한 데이터 은닉
• protected 멤버
• final 필드와 클래스
• 패키지와 import

헷갈리기 쉬운 개념

상속과 객체 생성

자식 객체를 생성한다고 해서 부모 객체와 자식 객체가 완전히 별개로 두 개 생성되는 것은 아니다.

Dog dog = new Dog();

하나의 Dog 객체 안에 Animal로부터 물려받은 부분과 Dog가 직접 선언한 부분이 함께 존재한다.

다만 초기화 순서는 부모 클래스부터 자식 클래스 순서로 진행된다.

상속과 접근

상속받았다고 해서 부모 클래스의 모든 멤버에 직접 접근할 수 있는 것은 아니다.

private String name;

private 멤버는 부모 클래스 내부에서만 접근할 수 있다.

자식 클래스가 사용해야 한다면 부모 클래스가 protected 또는 public 메서드를 제공해야 한다.

this()와 super()

this(...)

같은 클래스의 다른 생성자를 호출한다.

super(...)

부모 클래스의 생성자를 호출한다.

둘 다 생성자의 첫 번째 실행문에만 작성할 수 있으므로 동시에 직접 호출할 수 없다.

super와 부모 객체

super는 별도로 생성된 부모 객체를 가리키는 변수가 아니다.

현재 자식 객체 안에 포함된 부모 클래스 부분의 멤버에 접근하기 위한 키워드다.

final과 불변 객체

필드에 final을 붙였다고 해서 그 객체의 내부 상태까지 모두 변경할 수 없는 것은 아니다.

final StringBuilder builder = new StringBuilder("Java");

builder.append(" Programming");

builder가 다른 객체를 참조하도록 변경할 수는 없지만, 참조 중인 StringBuilder 객체의 내용은 변경할 수 있다.

// builder = new StringBuilder("Spring");
// 참조 변경은 불가능

실무에서는 어떻게 사용할까?

상속은 강력하지만 부모와 자식 클래스 사이의 결합을 강하게 만든다.

부모 클래스의 내부 구조가 바뀌면 여러 자식 클래스가 영향을 받을 수 있기 때문에, 실제 개발에서는 단순한 코드 재사용만을 목적으로 상속을 사용하지 않는다.

다음 조건을 만족할 때 상속을 고려하는 것이 좋다.

• 자식 클래스가 부모 클래스의 진짜 하위 종류다.
• 부모 타입으로 자식 객체를 사용해도 의미가 자연스럽다.
• 부모 클래스의 계약을 자식 클래스가 유지할 수 있다.
• 오버라이딩을 통해 행위를 확장하거나 구체화할 필요가 있다.

단순히 다른 클래스의 기능을 사용하고 싶다면 포함 관계가 더 적절할 수 있다.

public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

Spring에서도 서비스 클래스가 다른 서비스나 저장소 객체를 필드로 가지고 사용하는 포함 관계가 매우 많이 사용된다.

OrderService has a PaymentService

또한 필드는 가능한 한 private으로 보호하고, 외부에는 필요한 메서드만 공개하는 것이 일반적인 설계 방식이다.

private long balance;

public void deposit(long amount) {
}

상속 구조가 명확하게 제한되어야 하는 도메인에서는 sealed class를 활용할 수 있지만, 모든 프로젝트에서 반드시 사용할 필요는 없다. 일반적인 클래스 설계에서는 인터페이스, 조합, 의존성 주입도 함께 고려해야 한다.

오늘 배운 내용 정리

이번 글에서는 클래스의 기능을 재사용하고 확장하는 Java 상속을 정리했다.

• 상속은 부모 클래스의 필드와 메서드를 자식 클래스가 재사용하는 기능이다.
• Java에서는 extends 키워드로 클래스 상속 관계를 만든다.
• 부모 클래스의 생성자와 초기화 블록은 자식 클래스에 상속되지 않는다.
• 자식 객체를 생성할 때는 부모 클래스 부분부터 먼저 초기화된다.
• 상속은 일반적으로 is-a 관계가 성립할 때 사용한다.
• 포함 관계는 한 객체가 다른 객체를 필드로 가지는 has-a 관계다.
• Java 클래스는 하나의 부모 클래스만 직접 상속할 수 있다.
• 여러 기능이 필요할 때는 인터페이스와 포함 관계를 함께 활용할 수 있다.
• 모든 Java 클래스는 최종적으로 Object 클래스를 상속한다.
• 오버라이딩은 부모 메서드를 자식 클래스에 맞게 다시 정의하는 것이다.
• 오버라이딩한 메서드에는 @Override를 작성하는 것이 좋다.
• 오버라이딩 시 메서드 이름과 매개변수 목록이 같아야 한다.
• 참조 타입 반환값은 부모 반환 타입의 하위 타입으로 변경할 수 있다.
• 오버라이딩하는 메서드의 접근 범위는 부모보다 좁아질 수 없다.
• super는 부모 클래스의 멤버에 접근할 때 사용한다.
• super()는 부모 생성자를 호출하며 자식 생성자의 첫 번째 줄에 작성한다.
• 부모 생성자를 명시적으로 호출하지 않으면 컴파일러가 super()를 삽입한다.
• final 변수는 값을 다시 변경할 수 없다.
• final 메서드는 오버라이딩할 수 없다.
• final 클래스는 상속할 수 없다.
• static final은 모든 객체가 공유하는 상수를 표현할 때 사용한다.
• 봉인 클래스는 허용된 클래스만 상속하도록 제한한다.
• 봉인 클래스의 자식은 final, sealed, non-sealed 중 하나로 선언해야 한다.
• 패키지는 관련된 클래스를 계층적으로 분류하고 이름 충돌을 방지한다.
• 다른 패키지의 클래스를 사용할 때는 import를 사용할 수 있다.
• java.lang 패키지는 자동으로 import된다.
• 접근 제한자는 클래스와 멤버를 사용할 수 있는 범위를 결정한다.
• private은 클래스 내부, default는 같은 패키지, protected는 같은 패키지와 상속 관계, public은 모든 위치에서 접근할 수 있다.
• 필드를 private으로 보호하고 메서드를 통해 사용하도록 만드는 것이 캡슐화의 기본이다.
• 어노테이션은 컴파일러, JVM, 프레임워크가 활용할 수 있는 메타데이터다.

다음 글 예고

다음 글에서는 상속 관계를 활용하는 핵심 개념인 다형성을 다룬다.

Java 객체지향 ⑤ 다형성

- 자동 타입 변환
- 부모 타입과 자식 객체
- 메서드 오버라이딩과 동적 바인딩
- 강제 타입 변환
- instanceof
- instanceof 패턴 매칭
- 매개변수의 다형성
- 배열과 다형성

상속이 클래스 사이의 관계를 만드는 기능이라면, 다형성은 그 관계를 실제 프로그램에서 유연하게 사용하는 방법이라고 볼 수 있다.

📌 작성자 참고 메모 — 블로그에 넣지 않아도 되는 내용

이번 글의 시리즈 위치

이번 글은 사용자가 지정한 기준에 따라 Java 시리즈의 네 번째 글로 구성했다.

Java 객체지향 ① 변수와 타입 변환
Java 객체지향 ② 제어문과 배열
Java 객체지향 ③ 객체와 클래스
Java 객체지향 ④ 상속과 오버라이딩

다만 앞선 글 제목에 이미 다른 번호가 붙어 있다면 실제 게시 시리즈 이름에 맞춰 숫자만 조정하면 된다.

메모에서 수정한 내용

Object의 자식 클래스

메모의 “별도의 extends 선언이 없는 클래스는 extends Object가 생략된다”는 설명은 학습 관점에서 맞다. 다만 인터페이스는 클래스를 상속하지 않으며 Object를 직접 상속한다고 표현하지 않는다.

오버라이딩 반환 타입

메모에는 “리턴 타입이 같아야 한다”고 적혀 있었지만, 정확히는 다음과 같다.

• 기본 타입 반환값은 같아야 한다.
• 참조 타입 반환값은 부모 반환 타입과 같거나 그 하위 타입일 수 있다.

sealed 클래스의 permits

메모에는 sealed가 선언된 클래스는 permits가 반드시 필요하다고 되어 있지만 예외가 있다.

허용된 자식 클래스가 같은 컴파일 단위, 즉 같은 .java 파일에 함께 선언되어 있으면 permits를 생략할 수 있다.

sealed 철자

메모의 seald는 sealed로 수정했다.

final 클래스 예시

String은 final 클래스가 맞다. Math도 final 클래스지만 생성자까지 private이라 객체 생성을 막고 정적 유틸리티 기능을 제공한다.

Object까지 객체가 모두 만들어진다는 표현

부모 클래스마다 독립적인 객체가 여러 개 생성되는 것은 아니다.

하나의 자식 객체 내부에서 부모 클래스가 담당하는 상태가 포함되고, 생성자를 통해 부모 부분부터 자식 부분까지 순서대로 초기화된다.

모든 클래스는 패키지에 속한다는 표현

패키지 선언이 없는 클래스도 이름 없는 기본 패키지에 속한다고 볼 수 있다. 다만 실제 프로젝트에서는 기본 패키지를 권장하지 않는다.

면접이나 평가에서 자주 나오는 질문

오버로딩과 오버라이딩의 차이

오버로딩
- 같은 이름
- 다른 매개변수
- 컴파일 시점에 선택

오버라이딩
- 상속 관계
- 같은 메서드 선언
- 자식 클래스에서 재정의
- 실행 시 실제 객체 기준으로 선택

Java가 다중 상속을 지원하지 않는 이유

동일한 메서드를 가진 여러 부모 클래스를 동시에 상속할 때 어떤 구현을 사용할지 모호해질 수 있기 때문이다. Java는 클래스 단일 상속과 인터페이스 다중 구현을 채택했다.

private 메서드는 오버라이딩되는가?

아니다. private 메서드는 자식 클래스에서 보이지 않으므로 상속된 메서드를 재정의하는 오버라이딩이 성립하지 않는다. 자식 클래스에 같은 형태의 메서드를 선언해도 서로 별개의 메서드다.

static 메서드는 오버라이딩되는가?

인스턴스 메서드처럼 오버라이딩되지 않는다. 자식 클래스가 같은 형태의 정적 메서드를 선언하면 메서드 숨김이 발생한다.

생성자는 상속되는가?

상속되지 않는다. 다만 자식 객체 생성 시 super()를 통해 부모 생성자가 호출된다.

final 참조 변수는 불변 객체인가?

아니다. 참조 변수가 가리키는 대상을 바꿀 수 없다는 의미일 뿐, 참조 중인 객체의 내부 상태가 변경되지 않는다는 뜻은 아니다.

들어가며

지금까지 변수, 조건문, 반복문, 배열을 이용하면 비교적 간단한 프로그램을 만들 수 있었다.

하지만 프로그램의 규모가 커지면 수많은 변수와 메서드가 서로 뒤섞이기 시작한다. 회원의 이름, 나이, 이메일을 각각 다른 변수로 관리하고, 자동차의 속도나 색상도 별도의 변수로 흩어놓는다면 데이터와 기능의 관계를 파악하기 어려워진다.

객체지향 프로그래밍은 이 문제를 해결하기 위해 서로 관련된 데이터와 기능을 하나의 객체로 묶어 관리하는 방식이다.

예를 들어 자동차를 프로그램으로 표현한다면 자동차가 가진 데이터와 기능을 다음처럼 나눌 수 있다.

자동차 객체

속성
- 모델명
- 색상
- 현재 속도

동작
- 시동 걸기
- 가속하기
- 정지하기

Java에서는 객체가 가져야 하는 속성과 동작을 클래스에 정의하고, 그 클래스를 기반으로 실제 객체를 생성한다.

이번 글에서는 객체와 클래스의 관계부터 필드, 메서드, 생성자, this, static, 메서드 오버로딩, 초기화 블록까지 정리해보려고 한다.

1. 객체란?

객체는 물리적으로 존재하거나 추상적으로 생각할 수 있는 대상 중에서 자신의 속성을 가지며 다른 대상과 구분할 수 있는 것을 의미한다.

물리적으로 존재하지 않더라도 프로그램에서 하나의 대상으로 구분할 수 있다면 객체로 표현할 수 있다.

예를 들어 주문은 손으로 만질 수 있는 물건은 아니지만 다음과 같은 속성과 동작을 가진다.

주문

속성
- 주문 번호
- 주문자
- 주문 금액
- 주문 상태

동작
- 결제하기
- 취소하기
- 배송 상태 변경하기

객체는 속성과 동작으로 구성된다

객체는 크게 속성과 동작으로 구성된다.

객체 = 속성 + 동작

Java에서는 속성을 필드, 동작을 메서드로 표현한다.

public class Car {

    // 속성
    String model;
    String color;
    int speed;

    // 동작
    void accelerate() {
        speed += 10;
    }

    void stop() {
        speed = 0;
    }
}

위 클래스에서 model, color, speed는 자동차 객체의 데이터를 나타내는 필드이고, accelerate()와 stop()은 자동차 객체가 수행할 수 있는 동작을 나타내는 메서드다.

2. 객체의 상호작용

실제 프로그램은 하나의 객체만으로 구성되지 않는다.

회원 객체가 주문 객체를 생성하고, 주문 객체가 결제 객체의 기능을 호출하며, 결제 객체는 은행 시스템과 통신할 수 있다.

객체들은 주로 메서드를 호출하면서 서로 상호작용한다.

회원 객체
    ↓ 주문 요청
주문 객체
    ↓ 결제 요청
결제 객체

객체가 다른 객체의 기능을 이용하는 것을 메서드 호출이라고 한다.

payment.pay();

여기서 payment는 결제 객체를 참조하는 변수이고, pay()는 결제 객체가 제공하는 기능이다.

객체 간의 관계

객체는 여러 형태의 관계를 맺을 수 있다.

집합 관계

집합 관계는 완성품과 부품 사이의 관계다.

자동차 - 엔진
컴퓨터 - CPU
주문 - 주문 상품

자동차 객체가 엔진 객체를 필드로 가지고 있다면 집합 관계로 볼 수 있다.

public class Engine {

    void start() {
        System.out.println("엔진이 작동합니다.");
    }
}

public class Car {

    Engine engine = new Engine();

    void start() {
        engine.start();
    }
}

사용 관계

사용 관계는 하나의 객체가 다른 객체의 기능을 일시적으로 이용하는 관계다.

public class Calculator {

    int add(int left, int right) {
        return left + right;
    }
}

public class CalculatorExample {

    public static void main(String[] args) {
        Calculator calculator = new Calculator();

        int result = calculator.add(10, 20);

        System.out.println(result);
    }
}

CalculatorExample은 Calculator 객체의 add() 메서드를 사용한다.

상속 관계

상속 관계는 부모 객체가 가진 속성과 기능을 자식 객체가 물려받는 관계다.

동물
├─ 강아지
├─ 고양이
└─ 새

Java에서는 extends 키워드로 상속 관계를 표현한다.

public class Animal {

    void eat() {
        System.out.println("먹이를 먹습니다.");
    }
}

public class Dog extends Animal {

    void bark() {
        System.out.println("멍멍");
    }
}

상속은 이후 글에서 더 자세하게 다루는 것이 좋다.

3. 객체지향 프로그래밍이란?

객체지향 프로그래밍은 프로그램에서 필요한 대상들을 객체로 정의하고, 객체들이 서로 상호작용하도록 프로그램을 구성하는 방식이다.

예를 들어 쇼핑몰 프로그램을 만든다면 다음과 같은 객체를 설계할 수 있다.

회원
상품
장바구니
주문
결제
배송

각 객체는 자신의 데이터와 기능을 책임진다.

회원
- 이름
- 이메일
- 로그인()

상품
- 상품명
- 가격
- 재고
- 재고감소()

주문
- 주문번호
- 주문금액
- 주문생성()
- 주문취소()

객체지향 프로그래밍은 각각의 객체를 설계한 뒤 조립하여 전체 프로그램을 완성한다.

객체지향 프로그래밍의 장점

객체지향 프로그래밍은 관련된 데이터와 기능을 하나의 단위로 묶기 때문에 다음과 같은 장점을 가진다.

모듈화

프로그램을 독립적인 객체 단위로 나눌 수 있다.

회원 기능을 수정하더라도 주문이나 상품 코드에 미치는 영향을 줄일 수 있다.

재사용성

이미 작성한 클래스를 여러 곳에서 다시 사용할 수 있다.

Calculator calculator1 = new Calculator();
Calculator calculator2 = new Calculator();

같은 클래스를 기반으로 여러 객체를 생성할 수 있다.

유지보수성

특정 기능이 어디에 정의되어 있는지 찾기 쉬워지고, 코드 수정 범위를 줄일 수 있다.

확장성

기존 코드를 최대한 유지하면서 새로운 기능을 추가하기 쉬워진다.

4. 객체지향의 핵심 특징

객체지향 프로그래밍의 대표적인 특징은 다음 네 가지다.

추상화
캡슐화
상속
다형성

메모에 적힌 “OOP is a PIE”는 객체지향의 특징을 기억하기 위한 표현으로 볼 수 있다.

• Polymorphism: 다형성
• Inheritance: 상속
• Encapsulation: 캡슐화

여기에 Abstraction, 즉 추상화를 함께 객체지향의 핵심 특징으로 다룬다.

추상화

추상화는 현실의 객체가 가진 수많은 특징 중에서 프로그램에 필요한 것만 선택해 표현하는 과정이다.

자동차에는 수많은 부품과 정보가 있지만 자동차 관리 프로그램에서 다음 정보만 필요할 수 있다.

모델명
색상
속도

필요한 특징만 선택하여 클래스로 표현하는 것이 추상화다.

캡슐화와 데이터 보호

캡슐화는 객체의 데이터와 기능을 하나로 묶고, 외부에서 내부 데이터를 함부로 변경하지 못하도록 보호하는 것이다.

public class BankAccount {

    private int balance;

    public void deposit(int amount) {
        if (amount <= 0) {
            return;
        }

        balance += amount;
    }

    public int getBalance() {
        return balance;
    }
}

balance를 private으로 선언하면 외부에서 직접 변경할 수 없다.

BankAccount account = new BankAccount();

// account.balance = -10000;
// 직접 접근 불가

반드시 deposit() 같은 메서드를 통해 정상적인 방식으로 변경해야 한다.

상속

상속은 부모 클래스가 가진 필드와 메서드를 자식 클래스가 물려받는 기능이다.

공통 코드를 재사용할 수 있다.

다형성

다형성은 하나의 객체를 여러 타입으로 참조할 수 있는 특성이다.

Animal animal = new Dog();

실제 객체는 Dog지만 부모 타입인 Animal로 참조할 수 있다.

다형성 역시 상속과 인터페이스를 학습한 뒤 자세히 다루는 것이 자연스럽다.

5. 클래스와 객체

클래스는 객체를 생성하기 위한 설계도다.

객체는 클래스를 기반으로 실제 메모리에 생성된 실체다.

클래스
→ 객체를 만들기 위한 설계도

객체
→ 클래스를 바탕으로 만들어진 실제 대상

자동차 설계도 하나로 여러 자동차를 만들 수 있는 것처럼 클래스 하나로 여러 객체를 생성할 수 있다.

Car firstCar = new Car();
Car secondCar = new Car();

firstCar와 secondCar는 같은 Car 클래스로부터 만들어졌지만 서로 다른 객체다.

인스턴스란?

인스턴스는 특정 클래스로부터 생성된 객체를 의미한다.

Car car = new Car();

위에서 car가 참조하는 객체는 다음처럼 표현할 수 있다.

car는 Car 클래스의 인스턴스다.

객체와 인스턴스는 비슷한 의미로 사용되지만, 인스턴스는 어떤 클래스로부터 만들어졌는지를 강조하는 표현이다.

6. 객체지향 프로그래밍의 기본 단계

Java에서 객체를 이용하는 과정은 다음과 같다.

1. 클래스 설계
2. 클래스로 객체 생성
3. 객체의 필드와 메서드 사용

예제를 살펴보자.

클래스 설계

public class Student {

    String name;
    int age;

    void study() {
        System.out.println(name + "이(가) 공부합니다.");
    }
}

객체 생성

Student student = new Student();

객체 사용

student.name = "김자바";
student.age = 20;

student.study();

전체 코드는 다음과 같다.

public class StudentExample {

    public static void main(String[] args) {
        Student student = new Student();

        student.name = "김자바";
        student.age = 20;

        System.out.println(student.name);
        System.out.println(student.age);

        student.study();
    }
}

7. 클래스 선언

클래스는 다음 형식으로 선언한다.

public class 클래스이름 {
}

public class Student {
}

클래스 이름은 일반적으로 첫 글자를 대문자로 작성하는 PascalCase를 사용한다.

Student
BankAccount
OrderItem
UserService

클래스 이름 작성 규칙

클래스 이름은 다음 규칙을 따라야 한다.

• 하나 이상의 문자로 구성한다.
• 첫 글자에 숫자를 사용할 수 없다.
• $와 _를 제외한 특수문자를 사용할 수 없다.
• 공백을 사용할 수 없다.
• Java 예약어를 사용할 수 없다.
• 대문자와 소문자를 구분한다.

다음은 사용할 수 없는 클래스 이름이다.

// public class 1Student {}
// public class User-Info {}
// public class class {}

문법적으로 $와 _를 사용할 수 있지만 일반적인 클래스 이름에는 사용하지 않는 것이 좋다.

8. new 연산자를 이용한 객체 생성

객체는 new 연산자를 사용해 생성한다.

new Student();

new 연산자는 Heap 영역에 새로운 객체를 생성하고 그 객체를 참조할 수 있는 값을 반환한다.

보통 객체의 참조값을 변수에 저장한다.

Student student;

student = new Student();

선언과 생성을 한 문장으로 작성할 수도 있다.

Student student = new Student();

객체 생성 과정

Student student = new Student();

이 문장은 개념적으로 다음 과정을 거친다.

1. Student 타입의 참조 변수 student가 생성된다.
2. new Student()가 Heap 영역에 객체를 생성한다.
3. 생성자가 실행되어 객체를 초기화한다.
4. 생성된 객체의 참조값이 반환된다.
5. 참조값이 student 변수에 저장된다.

메모리 구조는 다음과 같이 이해할 수 있다.

JVM Stack                    Heap

student ───────────────→ Student 객체
                          ┌───────────┐
                          │ name=null │
                          │ age=0     │
                          └───────────┘

9. 클래스의 두 가지 용도

입문 단계의 Java 프로그램에서는 클래스를 두 용도로 나누어 작성하는 경우가 많다.

라이브러리 클래스

라이브러리 클래스는 객체를 생성하고 사용할 수 있도록 필드, 생성자, 메서드를 제공한다.

public class Student {

    String name;
    int age;

    void study() {
        System.out.println(name + "이(가) 공부합니다.");
    }
}

실행 클래스

실행 클래스는 main() 메서드를 제공하여 프로그램의 시작점을 담당한다.

public class StudentExample {

    public static void main(String[] args) {
        Student student = new Student();

        student.name = "김자바";
        student.study();
    }
}

실제 프로젝트에서는 하나의 실행 클래스가 여러 라이브러리 클래스를 조합하여 프로그램을 실행한다.

10. 클래스의 구성 요소

클래스는 대표적으로 필드, 생성자, 메서드로 구성된다.

public class ClassName {

    // 필드
    int fieldName;

    // 생성자
    ClassName() {
    }

    // 메서드
    void methodName() {
    }
}

각 구성 요소의 역할은 다음과 같다.

11. 필드란?

필드는 객체가 가져야 하는 데이터를 저장한다.

대표적으로 다음과 같은 정보를 필드로 선언할 수 있다.

• 객체의 고유 데이터
• 현재 상태
• 다른 부품 객체에 대한 참조

public class Car {

    String model;
    String color;
    int speed;
    Engine engine;
}

model, color, speed는 자동차의 상태를 저장하고, engine은 자동차가 포함하는 다른 객체를 참조한다.

필드 선언 위치

필드는 클래스의 중괄호 내부에 선언하되, 생성자나 메서드 블록 바깥에 선언한다.

public class Person {

    String name; // 필드

    Person() {
        int age = 20; // 로컬 변수
    }

    void introduce() {
        String message = "안녕하세요."; // 로컬 변수
    }
}

생성자나 메서드 내부에 선언된 변수는 필드가 아니라 로컬 변수다.

필드와 로컬 변수의 차이

public class Person {

    String name; // 자동으로 null
    int age;     // 자동으로 0

    void introduce() {
        int count;

        // System.out.println(count);
        // 로컬 변수는 초기화 전 사용 불가
    }
}

필드의 기본값

필드는 명시적으로 초기화하지 않아도 타입에 맞는 기본값으로 초기화된다.

public class Person {

    String name;
    int age;
    boolean active;
}

public class PersonExample {

    public static void main(String[] args) {
        Person person = new Person();

        System.out.println(person.name);
        System.out.println(person.age);
        System.out.println(person.active);
    }
}

실행 결과는 다음과 같다.

null
0
false

12. 필드 사용

클래스 내부에서는 필드 이름으로 바로 접근할 수 있다.

public class Car {

    int speed;

    void accelerate() {
        speed += 10;
    }
}

클래스 외부에서는 객체를 생성한 뒤 점 연산자 .를 이용한다.

Car car = new Car();

car.speed = 50;

System.out.println(car.speed);

다만 실무에서는 필드를 외부에 직접 공개하기보다 private으로 보호하고 메서드를 통해 접근하는 방식을 권장한다.

public class Car {

    private int speed;

    public void accelerate() {
        speed += 10;
    }

    public int getSpeed() {
        return speed;
    }
}

13. 변수의 종류

Java의 변수는 선언 위치와 static 여부에 따라 나눌 수 있다.

변수
├─ 멤버 변수
│  ├─ 인스턴스 멤버 변수
│  └─ 클래스 멤버 변수
│
└─ 지역 변수
   ├─ 로컬 변수
   └─ 매개변수

14. 인스턴스 멤버 변수

클래스 영역에 선언되고 static이 붙지 않은 필드를 인스턴스 멤버 변수라고 한다.

public class Person {

    String name;
    int age;
}

인스턴스 필드는 객체가 생성될 때 객체마다 별도로 만들어진다.

Person first = new Person();
Person second = new Person();

first.name = "김자바";
second.name = "이자바";

System.out.println(first.name);
System.out.println(second.name);

두 객체는 각각 고유한 name 값을 가진다.

first  → Person 객체 {name="김자바"}
second → Person 객체 {name="이자바"}

인스턴스 필드는 객체가 Garbage Collector에 의해 제거될 때 함께 사라진다.

15. 클래스 멤버 변수

필드에 static을 붙이면 클래스 멤버 변수가 된다.

public class Person {

    static String scientificName = "Homo sapiens";

    String name;
}

클래스 변수는 특정 객체에 속하지 않고 클래스 자체에 속한다.

모든 객체가 하나의 값을 공유한다.

Person first = new Person();
Person second = new Person();

Person.scientificName = "Homo sapiens sapiens";

System.out.println(first.scientificName);
System.out.println(second.scientificName);

두 객체에서 동일한 값이 출력된다.

클래스 이름으로 접근하기

static 멤버는 객체가 아니라 클래스 이름으로 접근하는 것이 권장된다.

Person.scientificName = "Homo sapiens";

객체를 통해서도 접근은 가능하지만 권장되지 않는다.

Person person = new Person();

person.scientificName = "변경된 값";

IDE에서는 다음과 비슷한 경고가 나타날 수 있다.

The static field Person.scientificName
should be accessed in a static way

static 값은 객체마다 고유한 값이 아니라 모든 객체가 공유하는 값이므로 클래스 이름을 사용하는 것이 의도를 명확하게 보여준다.

static은 고정값이 아니다

static을 값이 변하지 않는다는 의미로 오해하기 쉽다.

그러나 static은 객체가 아니라 클래스에 소속된다는 뜻이다.

public class Counter {

    static int count;
}

Counter.count = 10;
Counter.count = 20;

값은 변경할 수 있다.

변경할 수 없는 상수를 만들려면 static final을 함께 사용한다.

public class MathConstants {

    public static final double PI = 3.141592;
}

16. 지역 변수와 매개변수

메서드, 생성자, 초기화 블록 내부에서 선언된 변수는 지역 변수다.

public class Calculator {

    int add(int left, int right) {
        int result = left + right;

        return result;
    }
}

위 코드에서 다음 변수는 모두 지역 변수 계열이다.

• left: 매개변수
• right: 매개변수
• result: 로컬 변수

지역 변수는 해당 코드가 실행될 때 Stack 프레임에 생성되고, 블록을 벗어나거나 메서드가 종료되면 사라진다.

또한 사용하기 전에 반드시 초기화해야 한다.

17. 메서드란?

메서드는 객체의 동작이나 기능을 코드로 표현한 것이다.

public class Calculator {

    int add(int left, int right) {
        return left + right;
    }
}

메서드를 작성하면 반복되는 코드를 하나로 묶어 재사용할 수 있다.

int firstResult = calculator.add(10, 20);
int secondResult = calculator.add(100, 200);

메서드가 필요한 이유

메서드를 사용하지 않으면 동일한 계산 코드를 여러 번 작성해야 한다.

int firstResult = 10 + 20;
int secondResult = 30 + 40;
int thirdResult = 50 + 60;

기능을 메서드로 분리하면 중복을 줄이고 의미를 명확하게 표현할 수 있다.

int firstResult = add(10, 20);
int secondResult = add(30, 40);
int thirdResult = add(50, 60);

18. 메서드 선언 구조

메서드는 다음 구조를 가진다.

리턴타입 메서드이름(매개변수 목록) {
    실행문

    return 반환값;
}

int add(int left, int right) {
    int result = left + right;

    return result;
}

리턴 타입

리턴 타입은 메서드를 호출한 곳으로 돌려주는 값의 타입이다.

int add(int left, int right) {
    return left + right;
}

add()는 int 값을 반환한다.

반환할 값이 없다면 void를 사용한다.

void printMessage() {
    System.out.println("안녕하세요.");
}

메서드는 직접적으로 하나의 값만 반환할 수 있다.

여러 데이터를 반환해야 한다면 배열이나 객체를 반환할 수 있다.

int[] calculate(int left, int right) {
    return new int[]{
            left + right,
            left - right
    };
}

실무에서는 관련된 여러 값을 별도의 결과 객체로 묶는 방법도 많이 사용한다.

메서드 이름

메서드 이름은 기능을 쉽게 파악할 수 있도록 동사 형태로 작성하는 경우가 많다.

calculateTotalPrice()
findUser()
saveOrder()
deleteReview()
printResult()

다음처럼 의미가 불분명한 이름은 피하는 것이 좋다.

doIt()
work()
process1()

매개변수

매개변수는 메서드를 호출할 때 전달받을 값을 선언한다.

int add(int left, int right) {
    return left + right;
}

호출할 때 전달하는 실제 값을 인수 또는 인자라고 부른다.

calculator.add(10, 20);

• left, right: 매개변수
• 10, 20: 인수

메서드 호출 과정에서 자동 타입 변환이 적용될 수 있다.

void printDouble(double value) {
    System.out.println(value);
}

printDouble(10);

int 값 10이 double로 자동 변환된다.

19. 메서드의 return

반환 타입이 void가 아니라면 메서드는 반드시 해당 타입의 값을 반환해야 한다.

int add(int left, int right) {
    return left + right;
}

조건문에 따라 값을 반환한다면 가능한 모든 실행 경로에서 값이 반환되어야 한다.

String getGrade(int score) {
    if (score >= 90) {
        return "A";
    }

    if (score >= 80) {
        return "B";
    }

    return "C";
}

다음 코드는 일부 상황에서 반환값이 없으므로 컴파일 오류가 발생한다.

int getNumber(boolean condition) {
    if (condition) {
        return 10;
    }

    // condition이 false일 때 반환값 없음
}

void 메서드의 return

void 메서드는 반환값이 없으므로 return을 생략할 수 있다.

다만 메서드를 즉시 종료할 목적으로 사용할 수 있다.

void register(String name) {
    if (name == null || name.isBlank()) {
        return;
    }

    System.out.println(name + " 등록 완료");
}

20. 가변 인자

동일한 타입의 인수가 몇 개 전달될지 알 수 없다면 가변 인자를 사용할 수 있다.

int addAll(int... numbers) {
    int sum = 0;

    for (int number : numbers) {
        sum += number;
    }

    return sum;
}

다양한 개수의 인수를 전달할 수 있다.

public class VariableArgumentsExample {

    public static void main(String[] args) {
        Calculator calculator = new Calculator();

        System.out.println(calculator.addAll(1, 2, 3));
        System.out.println(calculator.addAll(1, 2, 3, 4, 5));
    }
}

public class Calculator {

    int addAll(int... numbers) {
        int sum = 0;

        for (int number : numbers) {
            sum += number;
        }

        return sum;
    }
}

가변 인자는 내부적으로 배열로 처리된다.

int... numbers

호출 시 전달한 값의 개수에 맞춰 배열이 생성된다.

가변 인자 주의사항

가변 인자는 매개변수 목록의 마지막에만 선언할 수 있다.

void print(String title, int... values) {
}

다음 형태는 사용할 수 없다.

// void print(int... values, String title) {
// }

가변 인자는 한 메서드에 하나만 선언할 수 있다.

21. 메서드 오버로딩

메서드 오버로딩은 같은 클래스 내부에 이름이 같은 메서드를 여러 개 선언하는 기능이다.

단, 매개변수의 타입, 개수 또는 순서가 달라야 한다.

public class Calculator {

    int add(int left, int right) {
        return left + right;
    }

    double add(double left, double right) {
        return left + right;
    }

    int add(int first, int second, int third) {
        return first + second + third;
    }
}

호출할 때 전달한 인수에 맞는 메서드가 선택된다.

Calculator calculator = new Calculator();

System.out.println(calculator.add(10, 20));
System.out.println(calculator.add(1.5, 2.5));
System.out.println(calculator.add(10, 20, 30));

오버로딩의 조건

다음 중 하나 이상이 달라야 한다.

• 매개변수의 개수
• 매개변수의 타입
• 매개변수의 선언 순서

void print(int value) {
}

void print(String value) {
}

void print(int count, String text) {
}

void print(String text, int count) {
}

매개변수 이름만 바꾸는 것은 오버로딩이 아니다.

void print(int value) {
}

// void print(int number) {
//     중복 선언 오류
// }

리턴 타입만 다른 것도 오버로딩이 아니다.

int calculate(int value) {
    return value;
}

// double calculate(int value) {
//     중복 선언 오류
// }

메서드를 호출할 때는 반환 타입이 아니라 메서드 이름과 인수 목록으로 구분하기 때문이다.

22. 클래스 멤버와 인스턴스 멤버의 호출

가장 중요한 기준은 호출하려는 멤버가 현재 메모리에 존재하는지다.

static 멤버는 클래스가 로딩될 때 사용할 수 있지만, 인스턴스 멤버는 객체가 생성되어야 사용할 수 있다.

public class MemberExample {

    static int classValue = 10;

    int instanceValue = 20;

    static void classMethod() {
        System.out.println(classValue);

        // System.out.println(instanceValue);
        // 객체가 없으므로 직접 접근 불가
    }

    void instanceMethod() {
        System.out.println(classValue);
        System.out.println(instanceValue);
    }
}

인스턴스 메서드에서 static 멤버 접근

인스턴스 메서드는 객체가 생성된 이후 호출된다.

이 시점에는 클래스 멤버와 인스턴스 멤버가 모두 존재하므로 둘 다 접근할 수 있다.

void instanceMethod() {
    System.out.println(classValue);
    System.out.println(instanceValue);
}

static 메서드에서 인스턴스 멤버 접근

static 메서드는 객체가 생성되지 않아도 호출할 수 있다.

따라서 어떤 객체의 인스턴스 필드를 사용해야 하는지 알 수 없다.

static void classMethod() {
    // System.out.println(instanceValue);
}

객체를 명시적으로 생성하거나 전달받으면 접근할 수 있다.

static void printInstanceValue(MemberExample example) {
    System.out.println(example.instanceValue);
}

23. 메서드 호출 스택

Java에서 메서드가 호출되면 JVM Stack에 해당 메서드를 위한 프레임이 생성된다.

Stack은 LIFO 구조다.

Last In, First Out
마지막에 들어온 것이 먼저 나간다.

다음 코드를 살펴보자.

public class CallStackExample {

    public static void main(String[] args) {
        methodA();
    }

    static void methodA() {
        methodB();
    }

    static void methodB() {
        System.out.println("methodB 실행");
    }
}

호출 과정은 다음과 같다.

1. main() 프레임 생성
2. methodA() 프레임 생성
3. methodB() 프레임 생성
4. methodB() 종료 및 프레임 제거
5. methodA() 종료 및 프레임 제거
6. main() 종료

메모리 구조를 개념적으로 표현하면 다음과 같다.

┌───────────────┐
│ methodB()     │ ← 현재 실행
├───────────────┤
│ methodA()     │ ← 대기
├───────────────┤
│ main()        │ ← 대기
└───────────────┘

항상 Stack 맨 위에 있는 프레임이 현재 실행 중인 메서드다.

24. Java는 Call by Value다

Java는 메서드를 호출할 때 변수에 저장된 값을 복사해 전달한다.

따라서 Java의 매개변수 전달 방식은 항상 Call by Value다.

기본 타입과 참조 타입 모두 동일하게 값이 복사된다. 다만 참조 타입 변수에 저장된 값이 객체를 가리키는 참조값이라는 차이가 있다.

기본 타입 전달

public class PrimitiveParameterExample {

    public static void main(String[] args) {
        int number = 10;

        change(number);

        System.out.println(number);
    }

    static void change(int value) {
        value = 100;
    }
}

실행 결과는 10이다.

number의 값 10이 value에 복사되었기 때문에 value를 변경해도 원본 변수에는 영향을 주지 않는다.

number = 10
     ↓ 값 복사
value = 10

참조 타입 전달

public class Person {

    String name;
}

public class ReferenceParameterExample {

    public static void main(String[] args) {
        Person person = new Person();
        person.name = "김자바";

        changeName(person);

        System.out.println(person.name);
    }

    static void changeName(Person target) {
        target.name = "이자바";
    }
}

결과는 "이자바"다.

person과 target은 서로 다른 변수지만 같은 객체를 가리키는 참조값을 가지고 있다.

person ──┐
         ├──→ Person 객체
target ──┘

따라서 target을 통해 객체의 필드를 변경하면 person으로도 변경된 값을 확인할 수 있다.

참조 변수 자체를 바꾸는 경우

public class ReferenceParameterExample {

    public static void main(String[] args) {
        Person person = new Person();
        person.name = "김자바";

        replace(person);

        System.out.println(person.name);
    }

    static void replace(Person target) {
        target = new Person();
        target.name = "새로운 객체";
    }
}

결과는 여전히 "김자바"다.

메서드 내부의 target 변수에 새로운 참조값을 저장했을 뿐, 호출한 쪽의 person 변수는 변경되지 않는다.

Java는 객체를 참조로 전달하는 언어가 아니라, 객체를 가리키는 참조값을 값으로 복사해 전달하는 언어다.

25. 생성자란?

생성자는 new 연산자로 객체를 생성할 때 호출되는 특별한 코드 블록이다.

생성자는 객체의 필드를 초기화하거나 객체를 사용할 준비를 하는 역할을 한다.

public class Person {

    String name;
    int age;

    Person() {
        name = "이름 없음";
        age = 0;
    }
}

객체를 생성하면 생성자가 실행된다.

Person person = new Person();

생성자는 메서드와 비슷하지만 다르다

생성자는 메서드와 비슷한 형태를 가지지만 다음 차이가 있다.

• 이름이 클래스 이름과 같다.
• 반환 타입을 작성하지 않는다.
• new 연산자로 객체를 생성할 때 호출된다.
• 객체 초기화를 담당한다.

public class Person {

    Person() {
    }
}

다음처럼 void를 작성하면 생성자가 아니라 일반 메서드가 된다.

public class Person {

    void Person() {
        System.out.println("일반 메서드");
    }
}

26. 기본 생성자

클래스에 생성자를 하나도 선언하지 않으면 컴파일러가 매개변수가 없는 기본 생성자를 자동으로 추가한다.

소스 코드가 다음과 같다고 가정해보자.

public class Car {
}

개념적으로 컴파일러는 다음 생성자를 제공한다.

public class Car {

    public Car() {
    }
}

따라서 생성자를 직접 작성하지 않아도 객체를 생성할 수 있다.

Car car = new Car();

기본 생성자가 자동 생성되지 않는 경우

클래스에 생성자를 하나라도 직접 선언하면 컴파일러는 기본 생성자를 추가하지 않는다.

public class Car {

    Car(String model) {
    }
}

따라서 다음 코드는 컴파일 오류가 발생한다.

// Car car = new Car();

직접 선언한 생성자를 사용해야 한다.

Car car = new Car("아반떼");

매개변수가 없는 생성자도 필요하다면 직접 선언해야 한다.

public class Car {

    Car() {
    }

    Car(String model) {
    }
}

27. 매개변수가 있는 생성자

생성자에 매개변수를 선언하면 객체를 생성할 때 초기값을 전달할 수 있다.

public class Person {

    String name;
    int age;

    Person(String personName, int personAge) {
        name = personName;
        age = personAge;
    }
}

객체 생성 시 인수를 전달한다.

Person person = new Person("김자바", 20);

이 방식은 객체 생성 직후 반드시 필요한 값을 설정할 수 있다는 장점이 있다.

28. this

this는 현재 객체 자신을 참조하는 키워드다.

인스턴스 메서드나 생성자 내부에서 현재 객체의 필드와 메서드에 접근할 때 사용할 수 있다.

public class Person {

    String name;

    void printName() {
        System.out.println(this.name);
    }
}

this.name은 현재 메서드를 호출한 객체의 name 필드를 의미한다.

필드와 매개변수 이름이 같은 경우

생성자의 매개변수 이름은 필드 이름과 같게 작성하는 경우가 많다.

public class Person {

    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

왼쪽의 this.name은 필드이고, 오른쪽의 name은 매개변수다.

this.name = name;
필드          매개변수

this를 생략하면 매개변수 자신에게 값을 다시 대입하는 코드가 된다.

Person(String name) {
    name = name;
}

이 코드는 객체의 필드를 초기화하지 못한다.

29. 생성자 오버로딩

생성자도 메서드처럼 오버로딩할 수 있다.

매개변수의 타입, 개수 또는 순서가 다른 생성자를 여러 개 선언할 수 있다.

public class Person {

    String name;
    int age;

    Person() {
    }

    Person(String name) {
        this.name = name;
    }

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

객체를 다양한 방식으로 생성할 수 있다.

Person first = new Person();
Person second = new Person("김자바");
Person third = new Person("이자바", 25);

생성자 오버로딩이 아닌 경우

매개변수 이름만 다르고 타입과 개수가 같다면 오버로딩이 아니다.

Person(String name) {
}

// Person(String userName) {
//     중복 선언 오류
// }

30. this()를 이용한 다른 생성자 호출

생성자 오버로딩이 많아지면 필드 초기화 코드가 중복될 수 있다.

public class Person {

    String name;
    int age;
    String address;

    Person(String name) {
        this.name = name;
        this.age = 0;
        this.address = "주소 없음";
    }

    Person(String name, int age) {
        this.name = name;
        this.age = age;
        this.address = "주소 없음";
    }

    Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
}

this()를 사용하면 다른 생성자를 호출하여 중복을 줄일 수 있다.

public class Person {

    String name;
    int age;
    String address;

    Person() {
        this("이름 없음", 0, "주소 없음");
    }

    Person(String name) {
        this(name, 0, "주소 없음");
    }

    Person(String name, int age) {
        this(name, age, "주소 없음");
    }

    Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
}

필드 초기화는 마지막 생성자에 집중되어 있다.

this() 사용 규칙

this()는 생성자 내부의 첫 번째 실행문으로만 사용할 수 있다.

Person(String name) {
    this(name, 0);
}

다음처럼 다른 실행문 뒤에 작성할 수 없다.

Person(String name) {
    // System.out.println("생성 시작");
    // this(name, 0);
}

한 생성자 안에서 this()와 super()를 함께 호출할 수도 없다. 둘 다 생성자의 첫 번째 줄에만 올 수 있기 때문이다.

31. 필드 초기화 순서

인스턴스 필드는 객체가 생성될 때 대략 다음 순서로 초기화된다.

1. 타입의 기본값
2. 명시적 필드 초기화
3. 인스턴스 초기화 블록
4. 생성자

예제를 살펴보자.

public class InitializationOrder {

    int number = printAndReturn("명시적 필드 초기화", 10);

    {
        System.out.println("인스턴스 초기화 블록");
        number = 20;
    }

    InitializationOrder() {
        System.out.println("생성자");
        number = 30;
    }

    int printAndReturn(String message, int value) {
        System.out.println(message);

        return value;
    }
}

객체 생성 시 출력 순서는 다음과 같다.

명시적 필드 초기화
인스턴스 초기화 블록
생성자

마지막 number 값은 30이다.

32. 초기화 블록

초기화 블록은 생성자처럼 멤버 변수를 초기화하거나 객체 생성 시 공통으로 실행할 코드를 작성하는 데 사용할 수 있다.

초기화 블록은 이름이 없기 때문에 직접 호출할 수 없고 매개변수도 받을 수 없다.

인스턴스 초기화 블록

중괄호만 작성한 블록은 인스턴스 초기화 블록이다.

public class Person {

    String name;

    {
        System.out.println("객체 생성 전 공통 초기화");
        name = "이름 없음";
    }

    Person() {
        System.out.println("생성자 실행");
    }
}

객체가 생성될 때마다 생성자보다 먼저 실행된다.

new
→ 명시적 필드 초기화
→ 인스턴스 초기화 블록
→ 생성자

여러 생성자에서 공통으로 실행해야 하는 코드가 있을 때 사용할 수 있지만, 일반적으로는 생성자나 별도 메서드로 초기화 과정을 표현하는 편이 더 읽기 쉬운 경우가 많다.

클래스 초기화 블록

static이 붙은 블록은 클래스 초기화 블록이다.

public class ApplicationConfig {

    static String environment;

    static {
        System.out.println("클래스 초기화");
        environment = "development";
    }
}

클래스가 처음 로딩될 때 한 번 실행된다.

클래스 로딩
→ static 필드 초기화
→ static 초기화 블록

객체 생성 여부와 관계없이 클래스 단위로 한 번 실행된다.

33. 객체 생성과 JVM 메모리

객체 생성과 메서드 호출을 메모리 관점에서 정리해보자.

public class Person {

    static String species = "Human";

    String name;

    Person(String name) {
        this.name = name;
    }

    void introduce() {
        String message = "안녕하세요.";

        System.out.println(message + " " + name);
    }
}

public class PersonExample {

    public static void main(String[] args) {
        Person person = new Person("김자바");

        person.introduce();
    }
}

개념적인 메모리 구조는 다음과 같다.

Method Area
┌────────────────────────┐
│ Person 클래스 정보      │
│ 필드 정보               │
│ 생성자 코드             │
│ introduce() 코드        │
│ static species          │
└────────────────────────┘

JVM Stack
┌────────────────────────┐
│ introduce() 프레임      │
│ message = "안녕하세요." │
├────────────────────────┤
│ main() 프레임           │
│ person = 참조값          │
└────────────────────────┘

Heap
┌────────────────────────┐
│ Person 객체             │
│ name = "김자바"         │
└────────────────────────┘

실제 JVM의 내부 구현은 더 복잡하지만, 입문 단계에서는 클래스 정보, 메서드 실행 공간, 객체 저장 공간을 구분해서 이해하는 것이 중요하다.

34. 종합 예제: 은행 계좌 클래스

지금까지 배운 내용을 활용해 은행 계좌 클래스를 만들어보자.

public class BankAccount {

    static int accountCount;

    String owner;
    String accountNumber;
    private long balance;

    BankAccount(String owner, String accountNumber) {
        this(owner, accountNumber, 0);
    }

    BankAccount(
            String owner,
            String accountNumber,
            long initialBalance
    ) {
        this.owner = owner;
        this.accountNumber = accountNumber;
        this.balance = initialBalance;

        accountCount++;
    }

    void deposit(long amount) {
        if (amount <= 0) {
            System.out.println("입금액은 0보다 커야 합니다.");
            return;
        }

        balance += amount;

        System.out.printf(
                "%,d원이 입금되었습니다.%n",
                amount
        );
    }

    boolean withdraw(long amount) {
        if (amount <= 0) {
            System.out.println("출금액은 0보다 커야 합니다.");
            return false;
        }

        if (amount > balance) {
            System.out.println("잔액이 부족합니다.");
            return false;
        }

        balance -= amount;

        System.out.printf(
                "%,d원이 출금되었습니다.%n",
                amount
        );

        return true;
    }

    long getBalance() {
        return balance;
    }

    void printAccountInfo() {
        System.out.println("예금주: " + owner);
        System.out.println("계좌번호: " + accountNumber);
        System.out.printf("잔액: %,d원%n", balance);
    }

    static int getAccountCount() {
        return accountCount;
    }
}

실행 클래스는 다음과 같다.

public class BankAccountExample {

    public static void main(String[] args) {
        BankAccount firstAccount = new BankAccount(
                "김자바",
                "100-123-456789"
        );

        BankAccount secondAccount = new BankAccount(
                "이자바",
                "200-456-789012",
                100_000
        );

        firstAccount.deposit(50_000);
        firstAccount.withdraw(10_000);

        System.out.println();
        firstAccount.printAccountInfo();

        System.out.println();
        secondAccount.printAccountInfo();

        System.out.println();
        System.out.println(
                "생성된 계좌 수: "
                        + BankAccount.getAccountCount()
        );
    }
}

이 예제에는 다음 개념이 포함되어 있다.

• 인스턴스 필드
• static 클래스 필드
• 필드 캡슐화
• 생성자 오버로딩
• this()
• this.필드
• 반환값이 있는 메서드
• void 메서드
• 가드 클로즈
• 객체마다 다른 상태
• 모든 객체가 공유하는 클래스 변수

헷갈리기 쉬운 개념 정리

클래스와 객체

클래스
→ 객체를 만들기 위한 설계도

객체
→ 설계도를 기반으로 메모리에 생성된 실체

public class Person {
}

Person은 클래스다.

Person person = new Person();

new Person()으로 생성된 대상이 객체다.

객체와 인스턴스

객체는 독립적으로 존재하는 대상을 의미하고, 인스턴스는 어떤 클래스로부터 생성되었는지를 강조한다.

person은 객체다.
person은 Person 클래스의 인스턴스다.

필드와 로컬 변수

public class Person {

    String name; // 필드

    void introduce() {
        String message = "안녕하세요."; // 로컬 변수
    }
}

필드는 객체나 클래스에 소속되며 자동 초기화된다. 로컬 변수는 실행 블록에 소속되며 직접 초기화해야 한다.

인스턴스 멤버와 클래스 멤버

String name;
static int count;

• name: 객체마다 따로 존재
• count: 모든 객체가 공유

static과 final

static int count;

클래스에 소속되지만 값은 변경 가능하다.

static final int MAX_COUNT = 100;

클래스에 소속되며 한 번 초기화한 후 값을 변경할 수 없다.

생성자와 메서드

Person() {
}

생성자는 클래스 이름과 같고 반환 타입이 없다.

void introduce() {
}

메서드는 이름을 자유롭게 정할 수 있고 반환 타입을 작성한다.

this와 this()

this.name

현재 객체의 필드를 의미한다.

this("김자바", 20);

현재 클래스의 다른 생성자를 호출한다.

오버로딩과 오버라이딩

이번 글에서 다룬 것은 오버로딩이다.

오버로딩
→ 같은 클래스에서 같은 이름을 사용하되 매개변수를 다르게 선언

오버라이딩
→ 상속받은 부모 메서드를 자식 클래스에서 다시 정의

오늘 배운 내용 정리

오늘은 Java 객체지향 프로그래밍의 시작점이 되는 객체, 클래스, 필드, 메서드, 생성자를 정리했다.

• 객체는 자신의 속성과 동작을 가지며 다른 대상과 식별할 수 있는 프로그래밍 대상이다.
• 객체의 속성은 필드로, 동작은 메서드로 표현한다.
• 객체들은 메서드를 호출하며 서로 상호작용한다.
• 객체 간에는 집합 관계, 사용 관계, 상속 관계 등이 존재할 수 있다.
• 객체지향 프로그래밍은 필요한 객체를 설계하고 서로 조립하여 프로그램을 만드는 방식이다.
• 객체지향의 대표적인 특징은 추상화, 캡슐화, 상속, 다형성이다.
• 클래스는 객체를 만들기 위한 설계도이고, 인스턴스는 클래스로부터 생성된 객체다.
• new 연산자는 Heap 영역에 객체를 생성하고 참조값을 반환한다.
• 클래스는 필드, 생성자, 메서드로 구성된다.
• 필드는 객체의 고유 데이터와 상태를 저장한다.
• 필드는 자동으로 기본값이 설정되지만 로컬 변수는 직접 초기화해야 한다.
• 인스턴스 필드는 객체마다 따로 생성된다.
• 클래스 필드는 static으로 선언하며 모든 객체가 공유한다.
• static은 값이 고정된다는 의미가 아니며, 상수는 static final로 표현할 수 있다.
• 메서드는 객체의 동작을 정의하고 코드 중복을 줄인다.
• 메서드는 반환 타입, 이름, 매개변수 목록, 구현부로 구성된다.
• 가변 인자는 전달된 값의 개수에 따라 내부적으로 배열을 생성한다.
• 메서드 오버로딩은 같은 이름의 메서드를 매개변수 목록을 다르게 하여 여러 개 선언하는 것이다.
• Java는 기본 타입과 참조 타입 모두 Call by Value 방식으로 값을 전달한다.
• 참조 타입을 매개변수로 전달할 때는 객체의 참조값이 복사된다.
• 생성자는 객체 생성 시 호출되어 필드 초기화와 준비 작업을 담당한다.
• 생성자를 선언하지 않으면 기본 생성자가 자동으로 추가된다.
• 생성자를 하나라도 직접 작성하면 기본 생성자는 자동 생성되지 않는다.
• this는 현재 객체 자신을 가리킨다.
• this()는 같은 클래스의 다른 생성자를 호출하며 반드시 생성자의 첫 줄에 작성해야 한다.
• 인스턴스 초기화 블록은 객체 생성 때마다 실행되고, 클래스 초기화 블록은 클래스 로딩 시 한 번 실행된다.

들어가며

Java 프로그램은 기본적으로 main() 메서드의 시작 중괄호부터 끝 중괄호까지 위에서 아래로 한 줄씩 실행된다.

public class Main {

    public static void main(String[] args) {
        System.out.println("첫 번째 실행");
        System.out.println("두 번째 실행");
        System.out.println("세 번째 실행");
    }
}

하지만 실제 프로그램은 언제나 모든 코드를 같은 순서로 실행하지 않는다.

사용자의 나이에 따라 다른 문장을 출력하거나, 로그인 여부에 따라 접근을 허용해야 할 수 있다. 상품 목록을 모두 출력하려면 같은 작업을 여러 번 반복해야 한다.

이처럼 프로그램의 실행 순서를 조건에 따라 나누거나 특정 코드를 반복하도록 만드는 문법을 제어문이라고 한다.

Java의 제어문은 크게 다음과 같이 구분할 수 있다.

제어문
├─ 조건문
│  ├─ if
│  └─ switch
│
└─ 반복문
   ├─ for
   ├─ while
   └─ do-while

반복문이나 switch의 실행을 제어하기 위해 break와 continue도 함께 사용한다.

1. 조건문이란?

조건문은 조건식의 결과에 따라 서로 다른 코드를 실행한다.

Java의 조건식에는 반드시 true 또는 false를 결과로 만드는 표현식이나 boolean 타입 변수가 와야 한다.

int age = 20;

boolean isAdult = age >= 19;

if (isAdult) {
    System.out.println("성인입니다.");
}

Java에서는 숫자 0이나 1을 조건식으로 사용할 수 없다.

int number = 1;

// if (number) {
//     컴파일 오류
// }

C나 JavaScript와 달리 Java의 if 조건에는 반드시 boolean 결과가 필요하다.

2. if문

if문은 조건식이 true일 때 중괄호 내부의 실행문을 실행한다.

if (조건식) {
    조건식이 true일 때 실행할 코드
}

예를 들어 사용자의 점수가 60점 이상일 때 합격을 출력할 수 있다.

public class Main {

    public static void main(String[] args) {
        int score = 75;

        if (score >= 60) {
            System.out.println("합격입니다.");
        }

        System.out.println("프로그램을 종료합니다.");
    }
}

score >= 60이 true이므로 "합격입니다."가 출력된다.

중괄호는 생략하지 않는 것이 좋다

실행문이 한 줄뿐이라면 중괄호를 생략할 수 있다.

if (score >= 60)
    System.out.println("합격입니다.");

그러나 코드가 추가될 때 실수하기 쉽기 때문에 중괄호를 항상 작성하는 것이 안전하다.

if (score >= 60) {
    System.out.println("합격입니다.");
}

다음 코드는 들여쓰기만 보면 두 문장이 모두 조건에 포함된 것 같지만, 실제로는 첫 번째 문장만 if문의 영향을 받는다.

if (score >= 60)
    System.out.println("합격입니다.");

    System.out.println("축하합니다.");

"축하합니다."는 조건과 관계없이 항상 실행된다.

들여쓰기는 사람이 코드를 읽기 쉽게 만들 뿐, Java의 실행 범위를 결정하지 않는다. 실행 범위는 중괄호가 결정한다.

3. if-else문

조건식이 true인 경우와 false인 경우에 각각 다른 코드를 실행하려면 else를 사용한다.

if (조건식) {
    조건식이 true일 때 실행
} else {
    조건식이 false일 때 실행
}

public class Main {

    public static void main(String[] args) {
        int score = 55;

        if (score >= 60) {
            System.out.println("합격입니다.");
        } else {
            System.out.println("불합격입니다.");
        }
    }
}

두 블록 중 하나만 실행된다.

4. if-else if-else문

조건이 여러 개라면 else if를 사용한다.

if (조건식1) {
    실행문 A
} else if (조건식2) {
    실행문 B
} else {
    실행문 C
}

점수에 따라 등급을 출력하는 프로그램을 만들어보자.

public class Main {

    public static void main(String[] args) {
        int score = 85;
        char grade;

        if (score >= 90) {
            grade = 'A';
        } else if (score >= 80) {
            grade = 'B';
        } else if (score >= 70) {
            grade = 'C';
        } else if (score >= 60) {
            grade = 'D';
        } else {
            grade = 'F';
        }

        System.out.println("학점: " + grade);
    }
}

조건은 위에서부터 순서대로 검사하며, 처음으로 true가 된 블록만 실행한다.

따라서 조건의 순서가 매우 중요하다.

조건 순서를 잘못 작성한 경우

int score = 95;

if (score >= 60) {
    System.out.println("D 이상");
} else if (score >= 90) {
    System.out.println("A");
}

95는 첫 번째 조건인 score >= 60을 만족하므로 두 번째 조건은 검사하지 않는다.

범위를 판별하는 조건은 일반적으로 큰 값부터 작은 값 순서로 작성한다.

if (score >= 90) {
    System.out.println("A");
} else if (score >= 80) {
    System.out.println("B");
} else if (score >= 70) {
    System.out.println("C");
}

5. 중첩 if문

if문 내부에 또 다른 if문을 작성할 수 있다.

public class Main {

    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;

        if (age >= 19) {
            if (hasTicket) {
                System.out.println("입장할 수 있습니다.");
            } else {
                System.out.println("티켓이 필요합니다.");
            }
        } else {
            System.out.println("성인만 입장할 수 있습니다.");
        }
    }
}

다만 중첩이 너무 깊어지면 코드를 이해하기 어려워진다.

다음과 같이 논리 연산자를 활용해 조건을 합칠 수 있다.

if (age >= 19 && hasTicket) {
    System.out.println("입장할 수 있습니다.");
}

6. switch문

switch문은 하나의 변수나 표현식의 결과를 여러 값과 비교할 때 사용한다.

switch (변수 또는 표현식) {
    case 값1:
        실행문 A;
        break;

    case 값2:
        실행문 B;
        break;

    default:
        실행문 C;
}

요일 번호를 입력받아 요일을 출력하는 예제를 살펴보자.

public class Main {

    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("월요일");
                break;

            case 2:
                System.out.println("화요일");
                break;

            case 3:
                System.out.println("수요일");
                break;

            case 4:
                System.out.println("목요일");
                break;

            case 5:
                System.out.println("금요일");
                break;

            default:
                System.out.println("주말입니다.");
        }
    }
}

switch문의 break

기존 형태의 switch문에서 break는 현재 switch문을 종료한다.

break를 작성하지 않으면 일치하는 case 이후의 코드까지 계속 실행된다. 이를 fall-through라고 한다.

public class Main {

    public static void main(String[] args) {
        int number = 1;

        switch (number) {
            case 1:
                System.out.println("첫 번째");

            case 2:
                System.out.println("두 번째");

            case 3:
                System.out.println("세 번째");
        }
    }
}

실행 결과는 다음과 같다.

첫 번째
두 번째
세 번째

의도적으로 여러 case를 함께 처리하는 경우가 아니라면 break를 빠뜨리지 않아야 한다.

여러 case를 함께 처리하기

기존 switch문에서는 여러 case를 이어 작성할 수 있다.

public class Main {

    public static void main(String[] args) {
        int month = 2;

        switch (month) {
            case 12:
            case 1:
            case 2:
                System.out.println("겨울");
                break;

            case 3:
            case 4:
            case 5:
                System.out.println("봄");
                break;

            case 6:
            case 7:
            case 8:
                System.out.println("여름");
                break;

            default:
                System.out.println("가을");
        }
    }
}

7. switch 표현식

최근 Java에서는 화살표 ->를 사용하는 switch 표현식을 사용할 수 있다.

switch 표현식은 다음과 같은 장점이 있다.

• switch 자체가 값을 반환할 수 있다.
• 자동으로 해당 case만 실행하므로 break가 필요 없다.
• 여러 조건을 쉼표로 묶을 수 있다.
• 코드가 간결해진다.

public class Main {

    public static void main(String[] args) {
        int score = 85;

        char grade = switch (score / 10) {
            case 10, 9 -> 'A';
            case 8 -> 'B';
            case 7 -> 'C';
            case 6 -> 'D';
            default -> 'F';
        };

        System.out.println("학점: " + grade);
    }
}

화살표 형태의 switch는 Java 14부터 정식 문법으로 사용할 수 있다.

switch 표현식에서 여러 문장 실행하기

한 case에서 여러 문장을 실행하고 값을 반환하려면 중괄호와 yield를 사용한다.

public class Main {

    public static void main(String[] args) {
        String membership = "GOLD";

        int discountRate = switch (membership) {
            case "VIP" -> {
                System.out.println("VIP 회원입니다.");
                yield 20;
            }

            case "GOLD" -> {
                System.out.println("GOLD 회원입니다.");
                yield 10;
            }

            default -> {
                System.out.println("일반 회원입니다.");
                yield 0;
            }
        };

        System.out.println("할인율: " + discountRate + "%");
    }
}

yield는 switch 표현식의 결과값을 반환한다.

메서드에서 사용하는 return과 비슷해 보이지만, yield는 현재 switch 표현식의 값을 결정한다.

8. if문과 switch문의 차이