Hyeonjoon's code

모듈식 모놀리스와 헥사고날 아키텍처로 구성된 Nearby 서버 구조 분석하기

dev_Hyeonjoon — Fri, 17 Jul 2026 23:39:37 +0900

아키텍처 선택 이유

SOPT에서 세미나, 솝커톤, 합동 세미나 모두 모두 레이어드 아키텍처를 사용해왔다. 하지만 이번 AppJam에서는 새로운 구조를 직접 경험하고, 기존 방식과 어떤 차이가 있는지 알아보고 싶었다.

처음에는 어떤 아키텍처가 있고 어떤 걸 선택해야 하는지 또 각 아키텍처가 어떤 특징을 가지는지 충분히 알지 못 하였다. 이후 서버 리드가 제안한 모듈식 모놀리스와 헥사고날 아키텍처의 도입 배경을 듣고, 새로운 구조를 학습할 좋은 기회라고 생각해 해당 아키텍처를 적용하게 되었다.

아키텍처를 이해하고 프로젝트 구조를 파악하는 과정에서 가장 많은 도움을 받은 글은 다음 글이었다.

미리 회고하자면

아키텍처를 선택한 이후 가장 큰 문제는 이를 실제 코드로 구현하는 방법이었다. 팀 내에 모듈식 모놀리스와 헥사고날 아키텍처를 충분히 경험해 본 사람이 없었기 때문에, 명확한 기준 없이 구조를 만들어가야 했다.

프로젝트를 진행하면서 모듈식 모놀리스에서는 단순히 Gradle 모듈이나 패키지를 여러 개로 나누는 것보다, 먼저 도메인의 경계와 각 도메인의 책임을 명확하게 정의하는 것이 중요하다는 점을 알게 되었다.

처음부터 모듈식 모놀리스를 적용하기보다는 하나의 모놀리스로 시작해 도메인에 대한 이해가 충분히 쌓인 이후, 경계를 기준으로 모듈을 분리하는 접근도 있다는 사실도 뒤늦게 알게 되었다.

하지만 우리 팀은 초기에 도메인 영역과 책임을 충분히 나누지 못한 상태에서 구조를 먼저 설계했다. 여기에 해당 아키텍처에 대한 경험 부족까지 겹치면서 모듈의 책임이 불분명해지거나, 의존성의 방향이 의도와 다르게 구성되는 등 여러 시행착오를 겪었다.

결국 새로운 아키텍처를 선택하는 것보다 더 중요한 것은, 해당 아키텍처가 해결하려는 문제가 무엇인지 이해하고 프로젝트의 도메인에 맞게 적용하는 것이라는 점을 배울 수 있었다.

구조 분석하기

adapter-in/web: HTTP 요청을 받는 곳
application: 도메인 모델과 핵심 업무 규칙, 유스케이스, Port를 정의하는 애플리케이션 코어
adapter-out/persistence: DB에 접근하는 곳
bootstrap: 각 모듈을 조립하고 애플리케이션을 실행하는 곳
common, logging: 공통 기능

우선 모듈 구조는 위와 같이 나누게 되었다. 이렇게 나눈 이유는 아래 사진처럼 헥사고날 구조를 가져가기 위함이였다.

헥사고날의 특징이라고 하면 핵심 비즈니스 로직을 데이터베이스, API, 사용자 인터페이스와 같은 외부 시스템과 분리하는 소프트웨어 설계 접근 방식이라고 할 수 있다. 이를 통해 유연하고 유지 관리가 용이하며 테스트가 간편한 애플리케이션을 구축할 수 있게 된다.

Nearby는 Google Maps 장소 검색, 카카오 인증, Solapi 문자 발송, S3 이미지 저장 및 JPA·Redis 영속성 처리를 어댑터로 분리했다. 이를 통해 동행 신청, 매칭, 일정 확정과 같은 핵심 비즈니스 규칙을 외부 기술의 변화와 분리하고, 실제 외부 시스템 없이도 유스케이스를 독립적으로 테스트할 수 있도록 했다.

→ 외부 시스템과의 상호작용을 Port 인터페이스로 추상화하여, 핵심 비즈니스 로직이 JPA, Redis, 외부 API와 같은 구체적인 기술 구현에 직접 의존하지 않도록 하는 것이 핵심!

최종 Gradle 모듈 구조

nearby
├── bootstrap
├── application
├── adapter-in
│   └── web
├── adapter-out
│   ├── persistence
│   └── security
├── common
└── logging

모듈별 구조

모듈	책임	판단 근거
bootstrap	Spring Boot 실행 진입점, 런타임 조립, 설정 로딩, Actuator, Spring Modulith 런타임 구성	실행 가능한 애플리케이션을 만드는 책임은 비즈니스 코드나 어댑터 구현과 분리되어야 한다. 이 모듈만 Spring Boot 애플리케이션 플러그인을 사용한다.
application	도메인 모델, 업무 규칙, Outbound Port	헥사고날 아키텍처의 중심은 외부 기술에 의존하지 않는 애플리케이션 코어다. 현재는 도메인 모델과 Port가 중심이며, 추후 Use Case Service가 생기면 이 모듈에 둔다.
adapter-in:web	HTTP Controller, Request·Response DTO, Validation, 웹 예외 처리, Swagger 설정	HTTP 요청은 애플리케이션 코어로 들어오는 Inbound Adapter다. Spring MVC와 OpenAPI 의존성은 이 모듈 안에 머무는 것이 적절하다.
adapter-out:persistence	JPA Entity, Spring Data Repository, Redis, Persistence Mapper, Outbound Port 구현	데이터 저장소는 애플리케이션 코어가 의존하면 안 되는 외부 기술이다. JPA와 Redis 의존성을 별도의 Outbound Adapter에 둔다.
adapter-out:security	Spring Security 기반 인증·인가 구현	보안 구현은 Persistence와는 다른 기술 영역이다. 인증 필터, Security Context, Token 처리 등의 책임이 커질 수 있으므로 별도 Outbound Adapter로 분리한다.
common	여러 모듈에서 공유할 수 있는 안정적인 예외와 Port 보조 타입	특정 Feature나 기술 구현에 종속되지 않는 계약만 둔다. 단순히 편리하다는 이유로 코드를 모아두는 장소로 사용하지 않는다.
logging	MDC, Request ID, 요청 로그 필터, 민감 정보 마스킹	로깅은 업무 규칙이 아닌 횡단 관심사이자 인프라 책임이다. Spring Web과 Servlet Filter에 의존하므로 common이 아닌 별도 모듈로 분리하는 것이 적절하다.

의존 방향

bootstrap -> adapter-in:web
bootstrap -> adapter-out:persistence
bootstrap -> adapter-out:security
bootstrap -> application
bootstrap -> common
bootstrap -> logging

adapter-in:web -> application
adapter-in:web -> common
adapter-in:web -> logging

adapter-out:persistence -> application
adapter-out:persistence -> common
adapter-out:persistence -> logging

adapter-out:security -> application
adapter-out:security -> common
adapter-out:security -> logging

application -> common
logging -> common
common -> none

핵심 규칙은 application 이 외부 기술을 모르는 것이다.
Spring Web, JPA, Redis, Security 의존성은 adapter 쪽에 있고, application은 port 인터페이스를 통해 필요한 기능만 표현한다

Appjam 전 간단한 프로젝트를 연습하려고 했었다...

dev_Hyeonjoon — Sun, 12 Jul 2026 22:20:30 +0900

사실... Appjam 합숙 전에 모든걸 다 끝내고 들어가려 했으나 못 했고 회고식아니면 나중에라도 더 구체화 시켜서 올려보려고 한다... 아래 있는 글들은 우선 먼저 적어놨던거라도 올리고자 이렇게 적게 되었다.

https://github.com/guswnsj0112/spring-auth-board

계기

이번 SOPT 38기 AppJam에서 운 좋게 Server로 참여 할 수 있게 되었다. 하지만 가장 큰 문제가 있었다. 바로 내가 백엔드를 올해 처음한다는 점이였다. 물론 파트장님께서는 세미나 때 친철하고 잘 알려주셨긴 했지만 학기 중 시간 관리를 못 했던 나에게는 아직 미숙한 부분이 많이 보였다. 그래서 Appjam 시작 전까지는 인증/인가, 엔터티 등 다양한걸 공부해서 가려고 한다.

구조

우선 서버 리드님과 상의했을 때 이번에 아키텍처를 모듈식 모놀리스로 가져가는게 어떻냐고 이야기 들었다. 나는 많은 걸 배우고 싶었기 때문에 좋다고 했고 그 후 계속 공부하면서 모듈식 아키텍처에 관해 배워가고 있다

학습 목표 설계

우선 GPT를 통해서 백엔드 프로젝트 목적을 세우게 되었다. 관련 레포는 여기서 확인 가능하다. 이걸 본 후 ERD를 먼저 설계 하였다.

ERD

User 1 : N Post
User 1 : N Comment
User 1 : N PostLike
User 1 : 1 RefreshToken
Post 1 : N Comment
Post 1 : N PostLike

리프레쉬 토큰은 한 유저 당 한개 씩으로 1:1 관계로 지정하였다

회원 가입 구현하기

User 엔티티

@Entity
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true)
    private String email;

    @Column(nullable = false)
    private String password;

    @Column(nullable = false)
    private String nickname;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private Role role;

    public User(String email, String nickname, String password) {
        this.email = email;
        this.nickname = nickname;
        this.password = password;
        this.role = Role.USER;
    }
}

User 엔터티에 있는 role 에 관해 어떻게 작성해야할지 고민이 되었다…
- Role이 Enum인데 어디에 넣어야 하는가? 에 대한 고민이 들었는데
- ⇒ User와 강하게 관련된 값임으로 Entity 패키지 안에 넣어두었다
어떤 방식으로 ENUM을 저장할 것 인지?
- 이 방법은 DB에 순서에 따른 숫자로 저장되기 때문에 나중에 Role 추가 된다면 다른 Role로 지정될 수 있다
때문에 아래와 같은 방식을 사용하였다
@Enumerated(EnumType.STRING)
@Enumerated(EnumType.ORDINAL) private Role role;
생성자에서 Role을 받으면 안된다..일반 회원가입은 무조건 User 임으로 User로 설정하자
- 회원가입할 때 사용자가 ADMIN 으로 가입하면 안되니까
public User(String email, String password, String nickname) { this.email = email; this.password = password; this.nickname = nickname; this.role = Role.USER; }
생성자 실수처음에 그냥 @NoArgsConstructor 면 public 기본 생성자가 생기게 된다 이렇게 되면 아래와 같은 게 가능해진다이러면 email, password, nickname이 없는 불안전한 User가 만들어질 수 있다
그래서 JPA용 기본 생성자는 열어두되, 외부에서는 막는 느낌으로 protected 를 많이 쓴다
User user = new User();
@NoArgsConstructor

암호화

핵심흐름

요청 들어옴
→ JwtAuthenticationFilter 실행
→ Authorization Header에서 Bearer Token 추출
→ JWT 검증
→ userId 추출
→ Authentication 객체 생성
→ SecurityContextHolder에 저장
→ Controller/Service에서 로그인 유저 사용

의존성

implementation 'org.springframework.security:spring-security-crypto'

auth/build.gradle

implementation 'org.springframework.boot:spring-boot-starter-security'

app/build.gradle

implementation 'io.jsonwebtoken:jjwt-api:0.12.6'
runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.12.6'
runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.12.6'

비밀번호 암호화만 auth에서 할 거면 spring-security-crypto를 auth에 둬도 되지만, SecurityConfig와 Filter는 app에서 관리하는 게 깔끔하다.

@Configuration // 스프링 설정 클래스
public class PasswordEncoderConfig {
    //   BCryptPasswordEncoder를 Spring Bean으로 등록
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

@Bean을 사용하여 BCryptPasswordEncoder를 스프링 빈으로 등록
이제 어디서든 DI(의존성 주입)를 통해 passwordEncoder를 사용할 수 있음
BCryptPasswordEncoder는 비밀번호를 안전하게 해시화하고 검증하는 역할을 함

→ 앞으로 PasswordEncoder가 필요하면 BCryptPasswordEncoder 객체를 주입해준다

그래서 아래와 같이 AuthService에서 사용할 수 있다

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class UserService {
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;

    //회원가입
    @Transactional
    public User register(SignupUserRequest request) {

        if (userRepository.existsByEmail(request.email())) {
            throw new IllegalArgumentException("이미 존재하는 이메일입니다.");
        }

        String hashedPassword = passwordEncoder.encode(request.password());

        User savedUser = userRepository.save(new User(
                request.email(),
                request.nickName(),
                hashedPassword
        ));

        return savedUser;
    }
}

공부 용임으로 User엔터티를 전체 반환했다

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
                .csrf(csrf -> csrf.disable())
                .headers(headers -> headers.frameOptions(frame -> frame.disable()))
                .authorizeHttpRequests(auth -> auth
                        .requestMatchers(
                                "/swagger-ui.html",
                                "/swagger-ui/**",
                                "/v3/api-docs/**",
                                "/api/auth/signup",
                                "/api/auth/login",
                                "/h2-console/**"
                        ).permitAll()
                        .anyRequest().permitAll()
                )
                .formLogin(form -> form.disable())
                .httpBasic(basic -> basic.disable())
                .build();
    }
}

app/src/main/java/org/sopt/appjam/global/config/SecurityConfig.java

모듈러 모놀리식 구조를 사용 중임으로 app 모듈 안에 있는 config에 설정해놨다.

추가로 공부 중이라서 anyRequest().permitAll() 으로 열었지만 나중에 JWT 필터를 붙일 때 .anyRequest().authenticated() 이렇게 할 것이다

JWT 토큰 적용하기

의존성 추가

// JWT
implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.5'
runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.11.5'

TokenProvider 추가

JWT 인증 시스템에서 토큰 생성, 검증, 정보 추출을 담당하는 클래스

openssl rand -base64 32

우선, 터미널에 위에처럼 입력한다

윈도우에서는 Git bash에 입력하면 됨
- 복사는 ctrl + insert
- 붙여넣기는 shift + insert

정말 합숙 기간 전에는 다 끝내려고 했는데.. 여행이나 뭐 핑계 대느라 안했던 것 같다... 그래서 현재 개발 중인 NearBy 서비스를 더 자세히 분석해서 올리고자 한다!

DDD(Domain-Driven Design)란? 핵심 개념과 계층형 아키텍처

dev_Hyeonjoon — Sat, 11 Jul 2026 22:19:34 +0900

DDD(Domain-Drvien Design, 도메인 주도 설계) 란?

도메인 모델을 기반으로 복잡한 소프트웨어 시스템을 설계하고 개발하는 방법론

도메인(Domain)

소프트웨어가 해결하고자 하는 문제 영역
→ 도메인이 무엇인지 보다는 도메인에 포함되는 것이 무엇인가 정의를 내리는게 더 중요!

예를 들어 여행 애플리케이션은 예약, 결제, 여행 일정, 회원 관리 등의 하위 도메인으로 나눌 수 있다. 예약 도메인 안에는 예약 요청, 확정, 취소와 같은 상태와 행위가 존재할 수 있다.

이처럼 여러 도메인들이 상호작용하며, 비즈니스 도메인별로 나누어 설계하는 것을 도메인 주도 설계라고 한다.

도메인과 객체의 차이점

객체(Object)
객체는 프로그램에서 특정 개념을 표현하기 위해 상태와 행동을 하나로 묶은 단위이다.

객체는 현실 세계의 대상을 그대로 복사한 것이 아니라, 소프트웨어가 해결하려는 문제에 필요한 특징만 선택하여 추상화한 결과이다.
예를 들어 여행 서비스의 사용자 객체는 실제 사람의 모든 정보를 표현하지 않는다. 여행 서비스에서 필요한 사용자 식별자, 닉네임, 여행 성향 등의 정보만 포함할 수 있다.

도메인(Domain)

소프트웨어가 해결하고자 하는 문제 영역을 의미

예를 들어 여행 애플리케이션에는 회원 관리, 여행 일정, 예약, 결제, 리뷰 등의 도메인이 존재할 수 있다.
도메인 모델은 이러한 문제 영역의 개념과 규칙을 객체로 표현한 모델이다. 따라서 객체는 도메인을 코드로 표현하기 위한 수단이고, 도메인은 객체가 표현하려는 문제 영역이라고 볼 수 있다.

정리하면 다음과 같다.
• 도메인: 소프트웨어가 해결하려는 문제 영역
• 도메인 모델: 문제 영역의 개념과 규칙을 추상화한 모델
• 객체: 도메인 모델을 코드로 표현하는 수단

DDD의 핵심 목표는 복잡한 비즈니스 규칙을 도메인 모델에 명확하게 표현하고, 바운디드 컨텍스트를 통해 모델의 경계를 구분하는 것이다. 이를 통해 각 영역의 응집도를 높이고 영역 간 결합도를 낮춰 변경과 확장에 유연한 소프트웨어를 설계할 수 있다.

DDD 핵심 개념

유비쿼터스 언어 (Ubiquitous Language)

정의: 도메인 전문가와 개발자가 동일한 용어와 개념을 사용하도록 합의하고, 이를 모델과 코드에 반영한다.

이점: 의사소통 오류를 감소시키고 모델에 반영된 용어가 코드에도 그래도 쓰여, 일관성을 유지한다. 또한 도메인에 대한 이해를 높이기도 한다.

바운디드 컨텍스트(Bounded Context)

정의: 도메인이 여러 하위 영역으로 나뉘어 있을 때, 각 영역을 경계(Context)로 구분하고 독립된 모델을 유지하는 개념

서로 다른 바운디드 컨텍스트 간의 상호작용은 명확한 인터페이스를 통해 이루어진다.

이점: 영역별 요구사항 충돌 최소한다. 컨텍스트 간 의존관계를 명확히 정의해, 복잡도를 관리한다.

도메인 모델

정의: 도메인 지식을 코드 형태로 체계화한 추상화 모델

엔티티(Entity), 값 객체(Value Object), 서비스(Service), 리포지터리(Repository) 등의 구성요소로 이루어짐

역할: 비즈니스 로직을 객체지향적으로 표현해, 문제 해결 로직을 직관적으로 이해하게 한다. 또 한 유지보수성과 확장성을 향상시킨다.

애그리거트 (Aggregate)

정의: 도메인 모델의 일관성을 유지하기 위해 엔터티와 값 객체를 그룹화한 객체 군으로, 내부 일관성을 책임지는 단위

루트 엔티티(Root Entity): 애그리거트의 대표자 역할을 한다. 외부에서 애그리거트에 접근할 때, 루트 엔터티를 통해서만 조작한다.

엔티티 (Entity) 와 값 객체 (Value Object)

엔티티: 고유한 식별자(ID)를 갖고, 라이프사이클 전반에 걸쳐 상태가 변할 수 있는 객체

값 객체: 식별자 없이 불변성을 띠며, 동일한 속성이면 같은 객체로 취급

도메인 서비스 (Domain Service)

정의: 모델 객체(Entity, Value Object)로 표현하기 어려운 도메인 규칙이나 로직을 담당

역할: 여러 애그리거트를 한꺼번에 조작하거나, 계산 로직 등 비즈니스 로직 을 캡슐화해 코드의 응집도를 높인다.

레포지터리(Repository)

정의: 엔터티나 애그리거트를 저장하고 검색하는 추상화 계층

역할: 영속성(persistence) 로직을 캡슐화하여, 도메인 로직과 데이터 접근 로직을 분리한다.

DDD의 계층구조(Layerd Architecture)

계층이 나뉘어져 있는 아키텍처

주된 목표는 각각의 layer는 하나의 관심사에만 집중할 수 있도록 한다.

일반적으로 3 계층 또는 4계층으로 나누어 사용

※ 3계층으로 나눌 때는 표현 계층(Presentation Layer) → 서비스 계층 (Business Layer) → 영속성 계층(Persistence Layer)으로 나누어 사용하곤 한다.

규칙

위의 계층에서 아래 계층에는 접근이 가능하지만 아래에서 위로는 불가능한 것을 기본으로 한다.
한 계층의 관심사와 관련된 어떤 것도 다른 계층에 배치되어서는 안된다.

계층별 설명

1. Presentation Layer (표현 계층) (Controller)

사용자 요청에 대해 해석하고 응답하는 일을 책임지는 계층

사용자에게 UI를 제공하거나 클라이언트에 응답을 다시 보내는 역할을 하는 모든 클래스가 포함
Client로부터 request를 받고 response를 return 하는 API 정의

2. Application Layer (응용 계층) (Service)

비즈니스 로직을 정의하고 정삭적으로 수행될 수 있도록 도메인 계층과 인프라스트럭쳐 계층을 연결해주는 역할을 하는 계층

이 계층은 많은 정보를 가지고 있지 않게 유지하는 것이 중요하다
실직적인 데이터의 상태 변화 등의 처리는 도메인 계층에서 진행할 수 있도록 위임하는 것이 중요

기능

트랜잭션의 단위
DTO 변환
엔터티 조회/저장
- 단순하게 말하면 Entity를 찾고 (Repository), 변경 내용을 저장하는 기능(Persistence)을 호출한다.
구현은 Infra Layer에서 한다
사용자 인증/인가
- 사용자가 특정 URL에 대해 권한이 있는지 정도의 인가는 presentation layer에서 하지만, URL만으로 판단이 어렵거나, DB내의 데이터와 대조해봐야 알 수 있는 경우 (데이터 존재 여부, 중복 여부 등)
파라미터 검증
- presentation layer에서도 수행할 수 있지만 주로 요청 방식에 따라 달라지는 ‘형식’에 대한 검증을 하고, application layer에서는 ‘논리적’인 오류를 검증한다.

3. Domain Layer (도메인 계층) (Model)

비즈니스 규칙, 정보에 대한 실질적인 도메인에 대한 정보를 가지고 있으며 이 모든 것을 책임지는 계층

Entity를 활용하여 도메인 로직이 실행되며, 업무 상황을 반영하여 상태를 제어하는 역할에 집중하는 계층

4. Infrastructure Layer (인프라 계층)

외부와의 통신(DB, 메시징 시스템 등)을 담당하는 계층

해당 계층에서 얻어온 정보를 응용 계층 또는 도메인 계층에 전달하는 것이 주 역할

각각의 도메인들을 위와 같은 Layer로 철저히 분리해서 만드는 것이 DDD(Domain-Driven Design)의 핵심 설계

Layered Architecture의 장단점

Layered Architecture 장점

각 레이어를 Loosely Coupling된 형태로 구축하면서, 각각 자신의 관심사에만 집중할 수 있다.
핵심 비즈니스 로직을 순수하게 유지함으로써 유지보수와 확장성 측면에서 이득을 얻을 수 있다.
각 레이어에 서로 다른 추상화 수준을 가진 상태와 행동을 위치시킴으로써 코드 재사용성을 높일 수 있다.

Layered Architecture 단점

서비스가 커질수록 복잡도가 증가하여 확장성이 떨어진다.
레이어로 분리된 관심사 외에 다른 관심사가 생길 경우 패키지 분리 및 코드 배치가 어렵다.

출처

https://limdae94.tistory.com/84

https://tech.kakaopay.com/post/backend-domain-driven-design/

https://wikidocs.net/275501

https://dev-coco.tistory.com/166

객체 간의 결합도(Coupling)와 응집도(Cohesion)의 관계

dev_Hyeonjoon — Fri, 10 Jul 2026 15:55:09 +0900

결합도와 응집도는 소프트웨어 구조 품질을 설명하는 가장 기본적인 두 축이다.

결합도 → 모듈 간 의존의 강도를 의미

응집도 → 하나의 모듈 내부에서 책임이 얼마나 잘 모여 있는지를 나타냄

모듈

소프트웨어를 각 기능별로 나누어진 소스 단위
모듈은 문맥에 따라 함수, 클래스, 패키지, Gradle 모듈처럼 서로 다른 크기의 소프트웨어 구성 단위를 의미할 수 있다. 결합도와 응집도는 이러한 여러 수준에서 모두 판단할 수 있다.

모듈화

문제가 복잡하고 큰 문제라면, 이 문제를 작은 부분으로 쪼개나가는 것

모듈의 효율성

결합도가 낮고 응집도가 높을 수록 모듈화의 효율성이 높다

객체지향 언어인지 절차지향 언어인지와 관계없이, 모듈 내부의 관련 기능은 함께 모으고 모듈 사이의 불필요한 의존은 줄이는 것이 좋은 설계의 기본 방향이다.

이 말을 다시 정리해보자면, 좋은 모듈화는 목적에 맞는 기능만으로 모듈을 나누게 되는데, 각각의 모듈은 주어진 기능만을 독립적으로 수행하기 때문에 재사용성이 높고 코드의 이해/수정이 용이하기 때문이다

결합도(Coupling)

모듈(클래스 파일)간의 상호 의존 정도 또는 연관된 관계의 끈끈함 정도를 의미
결합도를 의존도라고 부른다.

결합도가 높다는 것은 모듈들이 밀접하게 연결되어 있어 한 모듈의 변경 사항이 다른 모듈에 영향을 미칠 수 있다. 반대로 결합도 낮다는 것은 모듈들이 독립적이어서 한 모듈의 변경 사항이 다른 모듈에 미치는 영향이 미미하다.

결합도가 높다는 것을 예를 들어보면, 여행 플랫폼에서 회원 예매를 구축한다고 할 때 예매 로직에서 회원 가입 로직을 알고 있을 때 결합도가 높다고 할 수 있다. 예매 로직에서는 로그인한 회원의 정보만 알고 있으면 결합도를 낮출 수 있다.

기준

즉, 어떤 클래스가 다른 클래스에 대해 너무 자세히 알고 있다면 두 모듈은 높은 결합도를 가지게 되고, 반대로 어떤 클래스가 다른 클래스에 대해 꼭 필요한 지식만 가지고 있다면 두 모듈은 낮은 결합도를 가진다고 말할 수 있는 것

인터페이스를 사용하여 협력에 필요한 최소한의 계약에만 의존해야 한다.
- 이 경우에 인터페이스를 사용했더라도 호출자가 내부 영속성 구조인 UserJpaEntity 까지 알고 있다면 여전히 결합도가 높다

interface UserService {
    UserJpaEntity findUserEntityWithPasswordAndLoginHistory(Long userId);
}

- 반면, 아래와 같이 필요한 정보만 노출하면 결합도가 낮아질 수 있다
```
interface CurrentUserProvider {
    CurrentUser getCurrentUser();
}
```

→낮은 결합도는 변경의 영향을 줄여주며, OCP를 지키기 쉬운 구조를 만드는 데 도움을 준다.

확장에는 열려있고 변경에는 닫혀있는 클래스
다형성을 잘 지킨 클래스

응집도(Cohesion)

모듈 내 요소들이 하나의 명확한 목적을 달성하기 위해 얼마나 긴밀하게 협력하는 지를 나타내는 정도이다.

한 모듈이 하나의 기능(책임)을 갖고 있다면 응집도가 높은 것

한 모듈이 여러 기능을 갖고 있는 것은 응집도가 낮은 것이다.

응집도가 높은 모듈은 하나의 모듈 안에 함수나 데이터와 같은 구성 요소들이 하나의 기능을 구현하기 위해 필요한 것들만 배치되어 있고 긴밀하게 협력한다. 반대로 응집도가 낮은 모듈은 모듈 내부에 서로 관련 없는 함수나 데이터들이 존재하거나 관련성이 적은 여러 기능들이 서로 다른 목적을 추구하며 산재해 있다.

예를 들어, 여행 프로젝트에서 예매 처리를 담당하는 클래스에서 로그 아웃을 하는 메서드가 있다면, 이것은 응집도가 낮은 것이다. 따라서 클래스를 분리하는 게 응집도를 높일 수 있다.

응집도를 판단할 때는 메서드들이 같은 데이터를 사용하는지만 보는 것이 아니라, 같은 이유로 함께 변경되는지도 살펴봐야 한다.

결합도와 응집도

서론 관련된 책임을 하나의 모듈 안에 모으면 응집도가 높아지고, 관련 없는 책임을 다른 모듈로 분리하면 모듈 사이의 불필요한 의존도 줄어든다.

하지만 높은 응집도를 만들기 위해 무조건 클래스를 작게 나누는 것이 아니라, 함께 변경되고 함께 동작하는 책임은 모으고 서로 다른 이유로 변경되는 책임은 분리해야 한다.

코드를 판단하는 질문

응집도를 판단하는 질문

이 클래스의 메서드들을 한 문장으로 설명할 수 있는가?
메서드들이 동일한 상태나 데이터를 중심으로 동작하는가?
클래스 이름과 관계없는 메서드가 들어 있지는 않은가?
메서드들이 비슷한 이유로 함께 변경되는가?
클래스 이름에 Manager, Util, Helper처럼 책임이 모호한 단어가 붙어 있지는 않은가?

결합도를 판단하는 질문

다른 객체의 내부 구현 방식을 알고 있는가?
다른 객체의 필드나 DB Entity를 직접 사용하고 있는가?
한 클래스를 변경했을 때 여러 클래스가 함께 변경되는가?
구체 클래스 대신 필요한 역할이나 계약에 의존하고 있는가?
메서드의 매개변수로 정말 필요한 정보만 전달하고 있는가?
다른 모듈의 상태를 직접 변경하고 있지는 않은가?

참고자료

https://wikidocs.net/369737

https://inpa.tistory.com/entry/OOP- -객체의-결합도-응집도-의미와-단계-이해하기-쉽게-정리

https://www.geeksforgeeks.org/software-engineering/software-engineering-coupling-and-cohesion/

Nginx는 왜 등장했을까? Apache 구조의 한계와 이벤트 기반 웹 서버 이해하기

dev_Hyeonjoon — Fri, 26 Jun 2026 18:56:12 +0900

이번 프로젝트에서 Nginx를 쓰게 되었고 본격적인 프로젝트를 시작하기 전에 왜 Nginx를 사용하는지 정리해보려고 한다

"웹 서버는 대부분 Apache나 Nginx를 사용한다. 그 이유가 뭘까?"

Nginx 소개

Nginx는 고성능의 오픈 소스 웹 서버 소프트웨어로 많은 웹 서버와 리버스 프록시로 널리 사용

가볍고 확장 가능한 구조와 높은 처리량이 특징

가상 호스팅, 로드 밸런싱, SSL/TLS 암호화, URL 리다이렉션 등 다양한 기능을 제공

Nginx 란?

Nginx는 다목적 비동기 웹 서버 소프트웨어로, 많은 웹 서버와 리버스 프록시로 널리 사용된다. 주요 목적은 클라이언트 요청을 받아 정적 및 동적 콘텐츠를 처리하여 웹 서비스를 제공하는 것

이를 통해 웹 서버의 응답 시간과 처리량을 향상 시킬 수 있다.

웹서버의 역할뿐만 아니라 프록시 서버, 캐싱, 분산 처리, 미디어 스트리밍 등을 위한 다양한 기능을 제공하며 기능뿐만 아니라 성능면에서 기존의 웹서버들보다 뛰어나 현재 NGINX는 가장 널리 사용되고 있는 웹서버이다.

Nginx 탄생 이유

Apache 작동 방식

NCSA HTTPd의 불편함을 해결하기 위해 Apache Server라는 게 등장한다. Apache Server는 요청이 들어오는 경우 connection을 생성한다. 그래서 새로운 클라이언트의 요청이 올 때마다 새로운 process를 생성한다.

그런데 process를 생성하는 경우 시간이 오래걸린다. 이를 해결하기 위해 Apache에서는 PREFORK방식을 이용했다. 그래서 새로운 클라이언트의 요청이 오면 미리 만들어 놓은 프로세스를 할당했다.

만약 만들어 놓은 프로세스가 없는 경우 추가로 Process를 생성
요청마다 독립적인 메모리 공간을 사용하기 때문에 안정적
- 하지만 요청 수가 많아질수록 메모리에 부하가 발생하는 단점이 있음

이러한 구조 덕분에 개발자들은 다양한 모듈을 만들어 서버에 빠르게 기능을 추가할 수 있었다. 즉, 확장성이 높았고, Apache Server는 동적 컨텐츠를 처리할 수 있게 되었다. 확장성이 좋다는 장점은 결국 요청을 받고 응답을 처리하는 과정을 하나의 서버에서 해결하기 좋았다.

Apache 구조의 한계와 Nginx가 등장한 배경

이렇게 좋은 점만 있어보이는 Apache Server가 대체된 이유는 1999년 이후 컴퓨터가 많이 보급됨에 따라 요청이 많아져서 서버에 동시에 연결된 connection이 많을 때 더 이상 새로운 connection을 생성하지 못 하게 되었다.

이를 **C10K(connection 10000 problem)**문제라고 부른다. connection 10000개의 문제라는 뜻이며

Apache Server는 구조적으로 아래와 같은 문제점이 있다.

메모리 부족: connection이 연결될 때마다 프로세스를 생성
무거운 프로그램: 확장성이 좋다는건 곧 리소스가 않다는 걸 의미
CPU 부하 증가: 많은 connection 요청이 들어오면 context switching을 많이 하기에 CPU 부하가 증가

동시 접속이 급격히 증가하는 환경에서는 프로세스/스레드 기반 구조가 메모리 사용량과 context switching 측면에서 부담이 될 수 있었다. 이 문제를 해결하기 위해 이벤트 기반 구조를 가진 Nginx가 주목받기 시작했다.

초창기 Nginx는 Apache를 대체하기 위한 것이 아닌 보완 목적으로써 Apache Server가 지닌 구조적 문제점을 해결하기 위한 목적이였다.

사진에서 보는 것처럼 수많은 동시 connection을 Nginx가 유지하고, Nginx도 웹 서버이기에 정적 파일에 대한 요청은 스스로 처리하고, 클라이언트로부터 동적 파일의 요청을 받았을 때만 아파치 서버와 connection을 형성하여 아파치 서버의 부하를 줄였다.

Nginx 구조

master - worker 프로세스 모델을 사용한다.

master 프로세스는 설정 파일을 읽고, worker 프로세스를 생성하고 관리한다.

worker 프로세스는 실제로 클라이언트 요청을 처리하는 프로세스이다.

worker process가 만들어질 때 지정된 listen 소켓을 배정받는다.
그 후 그 소켓에 새로운 클라이언트 요청이 온다면 connection을 형성하고 처리한다.
connection은 정해진 Keep-Alive 시간만큼 유지됩니다. 하지만 connection이 형성되었다고 해서 worker process가 해당 connection 하나만 담당하지는 않습니다
형성된 connection으로부터 아무런 요청이 없다면 새로운 connection을 형성하거나 이미 만들어진 다른 connection 으로부터 들어온 요청을 처리한다.

Nginx에서는 이러한 connection 형성과 제거, 그리고 새로운 요청을 처리하는 것을 이벤트(event)라고한다.

이 이벤트들은 OS 커널이 Queue형식으로 worker process에 전달한다. 이 이벤트가 Queue에 있다면 비동기 상태로 유지가 된다. 그리고 worker process는 하나의 스레드로 이벤트를 꺼내서 처리해나간다. 이런 방식은 worker process가 쉬지 않고 일을 하기에, 요청이 없을 때 프로세스를 방치시키는 Apache Server보다 훨씬 효율적으로 자원을 사용할 수 있다.

위에 있는 이미지처럼 Apache 방식인 스레드 기반은 하나의 커넥션 당 하나의 스레드를 잡아먹지만 이벤트 기반 방식은 여러 개의 connection을 전부 Event Handler를 통해 비동기 방식으로 처리해 먼저 처리되는 것부터 로직이 진행되게끔 한다.

이러한 이벤트 구조가 바로 Nginx의 핵심

Nginx의 단점

동적 컨텐츠를 기본적으로 처리 할 수 없음
동적 콘텐츠에 대한 PHP 및 기타 요청을 처리하려면 NGINX가이를 실행하기 위해 외부 프로세서로 전달하고 렌더링 된 콘텐츠가 다시 전송 될 때까지 기다려야함(프로세스 속도 저하).
즉, 동적 웹 페이지 컨텐츠를 가진 모든 요청을 위해 외부 자원과 연계(php-fpm)

Nginx의 장점

이벤트 중심 접근 방식을 사용하여 클라이언트 요청 제공
제한된 하드웨어 리소스로도 여러 클라이언트 요청을 동시에 효율적으로 처리
단일 스레드를 통해 여러 연결을 처리 가능
최소한의 리소스로 웹 서버의 아키텍처를 개선하기 위해 독립형 HTTP 서버로 배치 가능

참고 자료

https://dev-wisdom.tistory.com/234

https://soonmin.tistory.com/88

https://dkswnkk.tistory.com/513

https://www.youtube.com/watch?v=6FAwAXXj5N0

[Spring, Docker] 모듈식 모놀리스에서 Docker 배포하기

dev_Hyeonjoon — Wed, 24 Jun 2026 16:01:10 +0900

우선 모듈식 모놀리스로 아키텍처를 가져갔다면 전통적인 모놀리식과 다르게 여러 개의 모듈이 있을 것이다. 하지만 모듈러식 모놀리스는 여러 모듈로 코드를 나누더라도, 최종적으로는 실행 모듈인 app에서 하나의 JAR 파일을 만들어 배포한다.

우선 app 모듈에서 배포를 할 예정이라 app → Tasks → bootJar 를 클릭해줬다.

app/build/libs 의 경로에 .jar로 끝나는 파일이 생성된다.

이제 Dockerfile을 성해준다. (확장자 x)

Dockerfile 생성하기

방법은 두 가지가 있다

1.jar 있는 곳에 Dockerfile 두기

.jar 파일이 있는 곳에 Dockerfile을 생성하는 방법

모듈식 모놀리스에서 생기는 단점

1. Dockerfile이 build/libs 안에 들어감
2. build 폴더는 보통 .gitignore 대상임
3. gradlew clean 하면 build/libs가 삭제됨
4. Dockerfile도 같이 사라질 수 있음
5. 프로젝트 구조 관리가 지저분해짐

2. 프로젝트 루트에 Dockerfile 두기

이 방법이 추천되는 방법이다

좋은 이유

1. Dockerfile이 프로젝트 루트에 있어서 관리하기 좋음
2. GitHub에 올리기 좋음
3. 모듈러식 모놀리스 구조가 더 명확함
4. 나중에 docker-compose.yml 추가하기 좋음
5. build/libs 안에 직접 들어가지 않아도 됨

Dockerfile 설정하기

FROM eclipse-temurin:17-jre-alpine

WORKDIR /app

COPY app/build/libs/*.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

FROM : Docker Base Image (기반이 되는 이미지, <이미지 이름>:<태그> 형식으로 설정, Java에 맞는 버전을 넣으면 된다)
WORKDIR :컨테이너 내부에서 작업할 디렉터리를 지정한다.
- 이후 실행되는 COPY, ENTRYPOINT 같은 명령어는 기본적으로 /app 경로를 기준으로 동작한다.
COPY : 로컬에 있는 JAR 파일을 컨테이너 내부로 복사한다.
- 현재 프로젝트는 모듈러식 모놀리스 구조이기 때문에 auth, board, common을 각각 실행하는 것이 아니라, 실행 모듈인 app에서 하나의 JAR 파일을 만든다.
EXPOSE : 컨테이너가 내부적으로 사용할 포트를 문서화한다.
- Spring Boot 애플리케이션은 기본적으로 8080 포트에서 실행되기 때문에 8080을 지정했다.
- 다만 EXPOSE만으로 실제 포트가 열리는 것은 아니다.
  실제로 내 컴퓨터에서 접속하려면 docker run 할 때 -p 옵션으로 포트 매핑을 해야 한다.
  - 예를 들어 -p 5000:8080은 내 PC의 5000번 포트로 들어온 요청을 컨테이너 내부의 8080번 포트로 전달한다.
ENTRYPOINT : 컨테이너가 시작될 때 실행할 명령어를 지정한다
- 여기서는 java -jar app.jar를 실행하여 Spring Boot 애플리케이션을 실행한다.

Java 17 실행 환경 준비
→ app/build/libs 안의 jar 복사
→ 컨테이너 안에서 app.jar로 이름 변경
→ 8080 포트 사용
→ java -jar app.jar 실행

DockerImage 만들기

터미널의 위치는 Dockerfile이 있는 곳 이여야 한다.

**docker build -t {이미지명} .**

**설명**
docker build      → Docker 이미지 만들기
-t 이미지명 → 이미지 이름 지정
.                 → 현재 폴더를 기준으로 Dockerfile 찾기

이렇게 확인할 수 있다.

Docker 컨테이너 실행하기

docker run --name 컨테이너명 -p 5000:8080 이미지명

--name appjam-auth-board-container → 생성할 컨테이너 이름
-p 5000:8080 → 내 PC의 5000번 포트를 컨테이너 내부 8080번 포트와 연결
appjam-auth-board → 실행할 Docker 이미지 이름

Docker Desktop

Docker Desktop을 사용하면 Containers와 images를 쉽게 확인할 수 있을 뿐만 아니라 삭제 및 Container 중지/실행 모두 가능하다

정리

모듈러식 모놀리스는 내부적으로 여러 모듈을 가지지만, 배포 관점에서는 하나의 애플리케이션으로 실행된다. 따라서 Docker 이미지도 auth, board, common을 각각 만드는 것이 아니라, 실행 모듈인 app에서 생성된 JAR 파일 하나를 기준으로 만든다.

참고자료

https://da2uns2.tistory.com/entry/Docker-도커에-Spring-Boot-구축하기

[Docker] Docker 입문: 이미지, 컨테이너, Registry, Docker Engine 정리

dev_Hyeonjoon — Tue, 23 Jun 2026 15:20:56 +0900

개발할 때는 잘 실행되던 애플리케이션이 서버에 배포하자마자 오류가 나는 경우가 있다.

운영체제, 라이브러리 버전, 실행 환경이 다르기 때문

⇒ Docker는 이런 환경 차이를 줄이기 위해 등장한 컨테이너 기반 플랫폼이다.

Docker란?

‘컨테이너화’를 사용하여 응용 프로그램의 배포, 확장 및 관리를 자동화할 수 있는 오픈 소스 플랫폼이다

코드, 실행 시간, 시스템 도구 및 라이브러리를 포함하여 응용 프로그램을 실행하는 데 필요한 모든 것을 가볍고 격리된 환경으로 포함한다.
응용 프로그램과 해당 종속성을 표준화된 단위로 패킺앟여 다양한 환경에서 일관되게 배포하고 실행하기 쉽게 만들어준다.

사용 이유

Docker를 사용하는 가장 큰 이유는 environment disparity(환경 격차)라는 문제를 해결하는 것이다.

내 컴퓨터에서는 되는데 서버에서는 안 되는 문제

기존에 내 컴퓨터가 Windows라고 하고, 실제 프로덕션 서버를 Linux라고 할 때 프로덕션 서버에 프로그램을 올리자 환경이 적절히 구성되어 있지 않으니 잘 안돌아간다

이 외에도 종속성, 라이브러리 버전, 운영 체제 구성의 차이로 인해 문제가 종종 발생을 하기도 하였다

Docker의 해결방식

Docker는 이런 문제를 런타임 환경을 표준화함으로써 이 문제를 해결하였다. 애플리케이션 코드와 특정 종속성을 단일 단위로 묶어 개발자 노트북, 테스트 서버 또는 클라우드 클러스터 등 어떤 환경에서든 소프트웨어가 동일하게 실행되도록 보장하였다.

휴대성: 로컬 컴퓨터, 클라우드, 온프레미스 서버 등 어디에서든 실행 가능
일관성: 개발, 테스트 및 운영 환경에서 동일한 동작
경량화: 앱별로 완전한 운영체제가 필요하지 않으며, 컨테이너는 호스트 커널을 공유
확장성: 마이크로서비스 및 Kubernetes, Docker Swarm과 같은 오케스트레이터에 이상적
효율성: 몇 초 만에 시작되며 시스템 리소스를 적게 사용

컨테이너화란?

응용 프로그램을 실행하는 데 필요한 모든 것을 포함한 가벼우며 격리된 환경을 제공
- 단, VM처럼 운영체제 전체를 포함하는 것이 아니라 호스트 OS의 커널을 공유하고, 필요한 실행 환경과 라이브러리만 이미지에 포함한다.
코드, 실행 시간, 시스템 도구 및 라이브러리 등을 포함하여 응용 프로그램과 해당 종속성을 표준화된 단위로 패키징하여 일관되게 배포하고 실행하는 것이 컨테이너화의 목적

즉, 어플리케이션을 개발 후 사용자가 실행할 때 필요한 환경들은 한번에 패키징하여 별 다른 설치 없이 한 번에 실행시켜주도록 하는 것

VM vs 컨테이너

비교 요소	가상 머신 (VM)	도커 (Docker)
구조	하드웨어 위에 호스트 OS와 게스트 OS로 구성	호스트 OS 위에서 동작하며 컨테이너화된 애플리케이션 실행
성능	하이퍼바이저로 인한 오버헤드로 약간의 성능 저하	컨테이너화로 인한 가벼운 성능 손실
시작 시간	VM을 시작하기 위해 시간이 필요	컨테이너는 몇 초 내에 시작 가능
자원 사용량	독립적인 자원을 사용하여 오버헤드 발생	호스트의 커널 및 자원을 공유하여 효율적인 자원 사용
확장성	가상 머신은 더 많은 하드웨어를 추가하여 확장 가능	도커는 컨테이너를 복제하여 수평으로 확장 가능
격리성	격리된 환경을 제공하여 보안을 강화	호스트와 컨테이너 간 격리가 상대적으로 약함
관리 용이성	VM은 완전한 운영 체제를 관리해야 함	도커는 이미지와 컨테이너를 사용하여 관리 용이

Docker 아키텍처 및 작동 방식

클라이언트 - 서버 아키텍처를 사용

Client

Docker 데몬과 통신하여 Docker 컨테이너를 빌드, 실행 및 배포하는 데 도움
데몬과 같은 시스템에서 실행되거나, Docker 클라이언트를 Docker 데몬에 원격으로 연결할 수 있음
Docker 클라이언트와 데몬은 유닉스 소켓이나 네트워크를 통한 REST API를 이용하여 서로 상호 작용한다
Docker 명령어를 사용하여 컨테이너를 실행, 관리, 모니터링하고, 이미지를 빌드하거나 다운로드할 수 있음
Docker 명령어를 통해 Docker Host와 상호작용 하는 역할

Docker Host

Docker Host는 Docker Engine이 설치되어 컨테이너를 실행하고 관리하는 환경이다. 물리 서버, 가상 머신, 클라우드 인스턴스 등이 Docker Host가 될 수 있다.
Docker 데몬을 실행하여 컨테이너를 생성, 시작, 중지 및 관리를 수행하는 역할을 수행
Client의 요청을 받아들이고 컨테이너를 생성, 시작, 중지, 제거하는 등의 작업을 수행
- 또한, 호스트 운영 체제의 리소를 사용하여 컨테이너를 실행하고 관리

Docker Registry

Docker 이미지를 저장 및 관리하는 중앙 집중 식 저장소
공식적인 도커 레지스트리로, 도커 허브(Docker Hub)를 통해서 Docker 이미지를 공유하고 검색할 수 있도록 함
- 또한, 개인이나 기업은 독립적인 도커 레지스트리를 구축하여 이미지를 안전하게 저장하고 관리할 수 있다

Docker 클라이언트, 도커 호스트, 도커 레지스트리 간 흐름

Client → Docker Host

클라이언트(Client)는 도커 명령어(Docker run, build, pull, …)를 사용하여 도커 호스트(Docker Host)에 요청

Docker Host

도커 호스트(Docker Host)는 클라이언트(Client)의 요청을 받아들이고 해당 요청에 따라 컨테이너를 생성, 중지, 제거하거나 이미지를 관리

Docker Host → Registry

만약 클라이언트(Client)가 이미지를 생성하거나 업로드하려면, 도커 호스트(Docker Host)는 해당 이미지를 도커 레지스트리(Registry)에 업로드

Registry

도커 레지스트리(Registry)는 이미지를 저장하고 관리하는 중앙 집중식 저장소입니다. 도커 호스트(Docker Host)에서는 도커 레지스트리(Registry)에 이미지를 업로드하거나 다운로드할 수 있다.

Docker Host → Client

컨테이너가 종료되면, 도커 호스트(Docker Host)는 해당 컨테이너의 상태와 결과를 클라이언트(Client)에게 반환
이러한 과정들을 통하여 클라이언트, 도커 호스트, 도커 레지스트리는 도커 환경에서 상호작용하며 이미지 업로드와 다운로드, 컨테이너의 생성과 관리 등의 작업을 수행

구성 요소

Docker의 주요 구성 요소 중 일부

Docker Engine: 컨테이너 생성 및 관리를 담당하는 핵심 부분인 Docker 데몬을 포함
Dockerfile: 이미지를 빠르게 생성하는 단계를 설명하는 파일
Docker 이미지: 애플리케이션 코드와 종속성을 포함하는 컨테이너를 생성하는 데 사용되는 읽기 전용 템플릿
Docker Hub: 컨테이너 이미지를 찾고 공유하는 데 사용되는 클라우드 기반 저장소
Docker Registry: Docker 이미지를 저장하는 분산 시스템으로, 이미지를 공개 모드와 비공개 모드 모두에 저장할 수 있다.

Docker Engine

Docker Engine이 없다면 Docker 이미지를 빌드하거나 컨테이너를 실행할 수 없다

클라이언트는 Docker 명령 (docker build, docker run 등)을 보낸다.
데몬은 이러한 명령어를 수신하고 컨테이너 작업을 수행
REST API는 이러한 통신을 가능하게 하는 인터페이스

즉, Docker Engine은 Docker 클라이언트와 데몬을 연결하여 컨테이너를 효율적으로 구축하고 관리함으로써 컨테이너화를 가능하게 하는 런타임

Dockerfile

DSL(도메인 특화 언어)을 사용하며 Docker 이미지를 생성하는 명령어를 포함

이미지를 빠르게 생성하기 위한 프로세스를 정의
애플리케이션을 개발할 때 Docker 데몬이 모든 명령어를 위에서부터 순서대로 실행하므로 Dockerfile을 순서대로 작성하는 것이 좋다

※Docker 이미지는 Dockerfile을 사용하여 생성된다

Docker 이미지

Docker 이미지는 컨테이너를 생성하기 위한 읽기 전용 템플릿이다.

애플리케이션 코드, 런타임, 라이브러리, 환경 변수, 실행 명령 등이 레이어 형태로 포함되어 있다.

애플리케이션 코드, 런타임, 라이브러리, 환경 변수 및 구성 등 애플리케이션 실행에 필요한 모든 것을 포함하는 실행 가능한 패키지 역할을 함

작동 방식

이 이미지는 컨테이너를 어떻게 생성해야 하는지를 정의한다.
어떤 소프트웨어 구성 요소가 실행될지, 그리고 어떻게 구성될지를 지정한다.
이미지가 실행되면 Docker 컨테이너가 된다.

컨테이너와의 관계

Docker 이미지 → Blueprint(정적, 읽기 전용).
Docker 컨테이너 → 해당 이미지의 실행 중인 인스턴스 (동적, 실행 가능)

Docker 컨테이너

Docker 이미지의 경량 실행 가능한 인스턴스

애플리케이션 코드와 모든 종속성을 함께 패키징하여 격리된 환경에서 실행한다. 컨테이너를 사용하면 개발자 노트북, 테스트 서버, 프로덕션 환경 등 다양한 환경에서 애플리케이션을 빠르고 안정적으로 실행할 수 있다.

Docker 이미지가 실행될 때 컨테이너가 생성된다.
호스트 시스템에서 독립적인 프로세스로 실행되지만 호스트 시스템의 운영 체제 커널을 공유한다.
여러 컨테이너가 서로 간섭하지 않고 동일한 시스템에서 실행할 수 있다.

이미지와의 관계:

Docker 이미지 → Blueprint(정적, 읽기 전용).
Docker 컨테이너 → 해당 이미지의 실행 중인 인스턴스 (동적, 실행 가능)

Docker Hub

저장소 서비스이며, 클라우드 기반 서비스로 사용자는 인터넷을 통해 언제 어디서든 Docker 컨테이너 이미지를 Docker Hub에 Push하거나 Docker 컨테이너 이미지를 가져올 수 있다

리포지토리 서비스: 사용자가 인터넷을 통해 어디에서든 컨테이너 이미지를 푸시 (업로드) 하거나 풀(다운로드) 할 수 있는 글로벌 스토리지 허브 역할을 한다.
이미지 관리: 누구나 접근할 수 있는 공개 레지스트리 또는 특정 사용자나 팀만 접근할 수 있는 비공개 레지스트리에 이미지를 호스팅할 수 있는 유연성을 제공한다.
협업: 표준화된 환경을 팀이 찾고, 재사용하고, 공유할 수 있도록 하여 DevOps 워크플로를 간소화한다.
접근성: 모든 주요 운영 체제와 호환되는 오픈 소스 무료 도구이다.
리소스 라이브러리: Nginx, Python, Ubuntu와 같은 인기 소프트웨어의 수백만 개의 “공식 이미지”를 호스팅하여 프로젝트를 위한 검증된 시작점을 제공한다.

Registry와 Hub의 차이

Docker Registry는 Docker 이미지를 저장하고 배포하는 저장소이다.
Docker Hub는 Docker에서 공식적으로 제공하는 대표적인 공개 Registry 서비스이다.

Docker 명령어

Docker는 컨테이너 관리 프로세스를 간소화하는 강력한 소프트웨어로 자리매김했습니다. Docker는 원활한 개발 및 배포 워크플로우를 보장하는 데 도움이 됩니다. 다음은 일반적으로 사용되는 몇 가지 Docker 명령어입니다.

Docker Run: 이미지에서 컨테이너를 실행하는 데 사용되며, 런타임 옵션과 명령어를 지정
Docker Pull: Docker Hub와 같은 컨테이너 레지스트리에서 컨테이너 이미지를 로컬 컴퓨터로 가져옴
Docker ps: 명령어는 실행 중인 컨테이너와 컨테이너 ID, 사용 이미지, 상태 등의 중요한 정보를 표시하는 데 도움 됨
Docker Stop: 실행 중인 컨테이너를 안전하게 종료하고 컨테이너 내부의 프로세스를 종료하는 데 도움이 된다.
Docker Start: 중지된 컨테이너를 다시 시작하여 이전 상태에서 작업을 재개하는 데 도움이 된다.
Docker 로그인: Docker 레지스트리에 로그인하여 비공개 저장소에 접근할 수 있도록 도와준다.

정리

결국 Docker는 “내 컴퓨터에서는 됐는데 서버에서는 안 돼요”라는 문제를 줄이기 위해 애플리케이션과 실행 환경을 하나의 컨테이너 단위로 패키징하는 기술이다. Docker를 사용하면 개발, 테스트, 운영 환경을 더 일관성 있게 유지할 수 있고, 컨테이너 기반 배포와 확장도 훨씬 쉬워진다.

참고 자료

https://adjh54.tistory.com/352

https://velog.io/@seokbin/신입을-위한-도커-기본-사용법

https://www.geeksforgeeks.org/devops/introduction-to-docker/

SpringDoc Swagger에서 PathVariable Parameters가 비어 있을 때: Gradle -parameters 옵션 문제 해결기

dev_Hyeonjoon — Mon, 22 Jun 2026 16:13:07 +0900

문제 상황

모듈식 모놀리스로 전환 후 Swagger API를 사용하여 API 명세를 손쉽게 하려고 세팅했었다. 하지만 Parameters 를 인식하지 못 하는 상황이 발생하게 되었다

코드 뜯어보기

우선 코드를 살펴보자면 저자는 Controller와 인터페이스를 사용한 Swagger API를 명확히 나눴다

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/posts")
public class PostController implements PostAPI {
    private final PostService postService;

    @PostMapping
    public Long createPost(
            @Valid @RequestBody PostCreateRequest request
    ){
        return postService.createPost(request);
    }

    @GetMapping
    public List<PostResponse> findPosts(){
        return postService.getAllPosts();
    }

    @GetMapping("/{postId}")
    public PostResponse findPostById(
            @PathVariable Long postId
    ){
        return postService.findPostById(postId);
    }

    @PatchMapping("/{postId}")
    public PostResponse updatePost(
            @Valid @RequestBody PostUpdateRequest request,
            @PathVariable Long postId
    ){
        Long post = postService.updatePost(postId, request);
        return postService.findPostById(post);
    }

    @DeleteMapping("/{postId}")
    public void deletePost(
            @PathVariable Long postId
    ){
        postService.deletePost(postId);
    }
}

@Tag(name = "Post", description = "게시글 API")
public interface PostAPI {
    @Operation(summary = "게시글 생성", description = "게시글을 생성합니다.")
    Long createPost(
            @RequestBody PostCreateRequest request
    );

    @Operation(summary = "게시글 리스트 조회", description = "게시글 리스트를 조회합니다.")
    List<PostResponse> findPosts(
    );

    @Operation(summary = "게시글 상세 조회", description = "게시글 상세 조회합니다.")
    PostResponse findPostById(
            @PathVariable Long postId
    );
    @Operation(summary = "게시글 삭제", description = "게시글을 삭제합니다.")
    void deletePost(
            @PathVariable Long postId
    );
}

문제 원인

PostAPI 구조 때문이 아니라, board 모듈 컴파일 결과에 파라미터 이름 메타데이터가 없어서

원인을 Codex로 해결 할 수 있었다

RuntimeVisibleParameterAnnotations:
  parameter 0:
    org.springframework.web.bind.annotation.PathVariable

javap 결과에 LocalVariableTable에는 postId가 보이지만, Java reflection이 읽는 MethodParameters가 없던 문제였다

쉽게 말하자면

소스코드에는 Long postId가 있음
컴파일된 클래스에는 @PathVariable은 있음
하지만 런타임 reflection 기준으로 "이 파라미터 이름이 postId다" 정보가 없음

때문이였다. 이런 일이 왜 발생했냐면

plugins {
    id 'java-library'
}

모듈식 모놀리스로 나누는 과정에서 board/build.gradle 에서 java-library만 사용했기 때문이다.

또한 Spring Boot Gradle 플러그인도 app에만 있던 상황인지라 board 컴파일에 -parameters 옵션이 안 붙어있던 상태였던 것. 루트 build.gradle를 살펴보면 현재 인코딩만 설정하고 있었다

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
}

그래서 SpringDoc이 @PathVariable Long postId를 봐도 이름을 못 얻었던 것. 결과적으로 /api/posts/{postId} 의 {postId}와 메서드 파라미터를 연결하지 못해서 parameters: [] 가 된다.

요약

board 모듈이 -parameters 없이 컴파일됨
+ @PathVariable에 명시 이름이 없음
= springdoc이 postId 이름을 못 알아냄
= Swagger Parameters가 비어 있음

해결 방법

1. 루트 gradle 설정하기

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
    options.compilerArgs += ['-parameters']
}

options.compilerArgs += ['-parameters'] 을 추가해주면 된다

이걸 루트 build.gradle의 subprojects 안에 넣으면 board, auth, app 전부 파라미터 이름이 보존된다

2. 각 @PathVariable에 이름을 명시 해주기

@PathVariable("postId") Long postId

“왜 안 되냐”의 진짜 이유는 board 모듈 class 파일에 postId라는 파라미터 이름이 reflection metadata로 안 남아있기 때문

[LeetCode] 1. Two Sum (JAVA)

dev_Hyeonjoon — Sun, 21 Jun 2026 22:48:02 +0900

문제

문제 링크

고민 했던 상황

배열 안에서 어떻게 해야 짝을 찾을 수 있을까? i,j 를 써서 j는 난수 인덱스로 지정해서 target 에 맞춰야하나? 라고 생각했었다

나의 코드

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int sum = 0;

        int[] result = new int[2];

        for(int i = 0; i < nums.length; i++){
            for(int j = i+1; j < nums.length; j++){
                sum = nums[i] + nums[j];

                if(sum == target){
                    result[0] = i;
                    result[1] = j;

                    return result; //반복문 조기 종료를 위해서
                }
            }
        }
        return result;
    }
}

최선의 경우: O(1)
예: nums[0] + nums[1]이 바로 target인 경우

최악의 경우: O(n²)
예: 정답이 맨 마지막 조합에 있거나, 거의 끝까지 탐색해야 하는 경우

평균적으로도: O(n²)

다른 사람들의 코드와 비교했을 때 딱히 좋은 성능은 아니였다.

다른 사람들의 코드는 HashMap을 사용해서 구현했기 때문이다

다른 코드

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();

        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                return new int[]{map.get(nums[i]), i};
            }

            map.put(target - nums[i], i);
        }

        return new int[]{-1, -1};
    }
}

핵심 아이디어

현재 숫자를 봤을 때, 이 숫자를 필요로 했던 이전 숫자가 있었는지 확인한다.

예를 들어 target = 9이고 현재 숫자가 2라면, 2와 더해서 9가 되려면 7이 필요하다.

target - nums[i]

즉, 9-2 = 7 이므로 7이 나중에 나오면 현재 숫자 2와 짝이 될 수 있다.

그래서 HashMap에는 현재 숫자 자체를 저장하는 것이 아니라, 앞으로 필요한 숫자를 key로 저장한다.

map.put(target - nums[i], i);

여기서 의미는 다음과 같다.

key   : 앞으로 필요한 숫자
value : 그 숫자를 필요로 하는 현재 인덱스

모듈러 모놀리스(modular monolith) 아키텍처가 뭘까?

dev_Hyeonjoon — Fri, 19 Jun 2026 22:06:14 +0900

탄생 배경

MSA의 장점을 가지고 다른 기업에서 적용시키다 보니 아래와 같은 문제들이 나타나게 되었다.

MSA의 부작용

네트워크 통신/ 장애 포인트 증가
분산 트랜잭션으로 묶기가 힘들어짐
모니터링, 배포 운영의 복잡도 증가

특히, 팀이 작을 수록 아래와 같은 문제점이 발생함

팀이 작을 때

쓸데 없이 나눈 서비스 수가 오히려 불편함만 가져옴
- 즉, 서비스 수 > 감당 가능한 팀 수
조직이 도메인 경계를 구분하지 않는 소규모 팀이라고 할 때 서비스는 나뉘어지는 이상한 구조가 나올 수 있다
- Conway’s Law - 조직이 아키텍쳐를 결정
복잡성이 증가할 수 록 소규모 팀에서는 발목이 잡히는 경우 발생

모듈러 모놀리스

모놀리식과 모듈식 설계 패러다임의 측면을 결합한 아키텍처 접근

단일 배포 단위를 유지하면서 내부를 도메인 경계로 명확히 분리한 구조
모듈은 일반적으로 비즈니스 역량 또는 도메인 주도 설계 (DDD) 원칙을 중심으로 조직된다.

특징

모듈성:
- 모듈러 모놀리식은 더 작고 독립적인 모듈로 구조화되며, 각 모듈은 특정 기능이나 비즈니스 도메인을 담당
- 모듈은 명확한 경계와 책임을 기준으로 조직되어 관심사의 분리와 유지보수성을 촉진한다
긴밀한 통합
- 모듈 구조를 가지지만 모든 모듈은 하나의 코드베이스와 런타임 환경 안에서 긴밀히 통합된다.
- 모듈 간 별도의 배포나 통신 메커니즘이 필요 xx
공유 코드베이스와 데이터:
- 모든 모듈이 동일한 코드베이스, 라이브러리, 데이터 저장소를 공유
- 이는 분산 시스템에 비해 개발과 배포를 단순화하면서도, 코드 조직과 관심사 분리 같은 모듈성의 이점을 유지하게 된다.
확장성 및 유지보수성:
- 전통적 모놀리식 대비 확장성과 유지보수성에서 이점을 제공
- 애플리케이션을 모듈로 분해함으로써 복잡성을 더 효과적으로 관리하고, 개별 컴포넌트를 독립적으로 확장할 수 있다
유연성
- 단일 코드베이스임에도 개발과 배포 측면에서 유연
- 전체 시스템에 영향을 주지 않고도 요구 사항 변경에 맞춰 모듈을 쉽게 추가, 제거, 수정 가능
배포 용이성:
- 배포 아티팩트가 하나뿐이므로 분산 시스템에 비해 배포가 더 간단하다.
- 배포와 운영의 복잡성이 줄어들어 애플리케이션 라이프사이클 관리가 쉬워짐

⇒ 모듈성과 모놀리식 아키텍처의 단순함을 결합함으로써, 모듈러 모놀리식은 유연성, 확장성, 유지보수성 간 균형을 이루어 중간 정도의 복잡성과 확장성 요구를 가진 애플리케이션에 적합

원칙

모듈성
- 애플리케이션을 더 작고 독립적인 모듈로 분해하고, 각 모듈은 특정 기능이나 비즈니스 도메인을 책임져야한다.
- 모듈은 명확한 경계와 잘 정의된 인터페이스를 가져야 하며, 이는 관심사의 분리와 유지보수의 용이성을 높임
높은 응집도, 낮은 결합도
- 각 모듈은 정확하고 집중된 목적을 가져야 하며 애플리케이션의 특정 측면을 책임져야 한다.(높은 응집도)
- 동시에 모듈 간 의존은 느슨해야 하며 서로에 과도하게 의존해서는 안된다.(낮은 결합도)
명확한 경계
- 모듈 간 경계를 명확히 정의하여 의존성을 최소화하고, 독립적인 개발과 테스트를 용이하게 한다.
- 모듈을 뒤섞거나 강한 결합을 도입하면 복잡성이 증가하고 변경이 어려워진다.
단일 책임 원칙(SRP)
- 각 모듈은 변경의 이유가 하나만 있어야 한다는 단일 책임 원칙을 따른다
- 이는 모듈 내부의 명확성과 단순성을 유지하고, 한 모듈의 변경이 시스템의 관련 없는 부분에 영향을 주지 않도록 한다.

패턴

레이어드 아키텍처
- 애플리케이션을 여러 레이어로 나누어 각 레이어가 특정 기능을 담당한다.
- 일반적으로 표현/UI 레이어, 비즈니스 로직 레이저, 데이터 접근 레이어가 포함된다.
- 관심사의 분리를 촉진하고 확장성과 유지보수성을 높임
모듈러 모놀로식
- 애플리케이션을 더 작고 독립적인 모듈로 분해하며, 각 모듈은 특정 기능이나 비즈니스 도메인을 담당한다
- 단일 코드베이스이지만 모듈 간 결합은 느슨하며, 모듈을 독립적으로 개발, 배포, 유지관리할 수 있다.
- 모놀리식의 단순함과 모듈식의 모듈성을 결합함
컴포넌트 기반 아키텍처
- 애플리케이션을 재사용 가능한 독립 컴포넌트로 조직하며, 각 컴포넌트는 관련 집합을 캡슐화한다.
- 컴포넌트를 조립, 구성하여 더 큰 애플리케이션을 구축함으로써 코드 재사용과 유지 보수성을 높인다

단점

복잡성 관리: 애플리케이션의 규모와 복잡성이 커질수록 모듈 간 상호작용을 관리하고 코드베이스 전반의 일관성을 보장하는 일이 어려워질 수 있다.
- 때문에 불필요한 복잡성을 피하려면 모듈 경계와 의존성을 신중히 설계해야함!
의존성 관리: 모듈 간 상호 의존성이 있거나 한 모듈의 변경이 다른 모듈에 영향을 줄 수 있을 때, 의존성 관리가 어려울 수 있다.
- 충돌이나 브레이킹 체인지를 피하려면 의존성과 버전 관리를 신중히 해야 합니다.
배포 복잡성: 전통적 모놀리식보다 모듈러 모놀리식은 여러 모듈을 함께 배포해야 하므로 더 복잡할 수 있다.
- 특히 분산 환경에서 배포를 조율하고 모듈 간 일관성을 확보하는 일이 도전적
테스트 오버헤드: 모듈 간 상호작용과 개별 모듈 자체를 모두 테스트해야 하므로, 전통적 모놀리식보다 테스트가 더 어렵고 시간이 소요될 수 있다.
- 포괄적인 테스트 스위트를 마련하고 모듈 전반의 충분한 커버리지를 확보해야 한다.

3가지 아키텍처 비교

모놀리스 방식

경계 x

단일 배포
모든 구성 요소가 강한 결합
- 애플리케이션 전체가 하나의 분리 불가능한 유닛으로 구축됨
유지보수 어려움

모듈러 모놀리스

도메인 경계 강제

단일 배포
모듈 간 결합을 느슨하게 설계하여 개발, 테스트, 유지보수를 쉽다.
- 애플리케이션을 더 작고 관리 가능한 모듈 또는 컴포넌트로 분해하며, 각 모듈은 특정 기능 집합을 담당한다.
도메인 분리 유지
- 내부적으로 도메인 경계를 강제함으로써 팀이 분리되고 서비스가 커지면 MSA로 자연스럽게 분리 및 확장이 가능하게 한다

MSA

독립 배포 단위

서비스별 독립 배포
높은 운영 복잡도
개별 확장 가능

전환 전략

모놀리스 → 모듈러 → MSA

모놀리스를 처음으로 하는 이유는 도메인 경계를 정확히 식별하기 위함이다. 댓글을 찾아보던 중 정확하게 식별을 하지 않는다면 모듈러 모놀리스의 구조는 이상하게 간다고 한다…

모듈러 모놀리스는 MSA의 예행연습이라고 한다. 경계를 코드로 강제해두면, 필요할 때 쪼개기가 훨씬 수월하여 MSA 전환이 가능하다는 점이다

참고자료

https://www.youtube.com/watch?v=3UJhhMultL4

https://rosettalens.com/s/ko/what-is-a-modular-monolith

멀티모듈 환경에서 공통 모듈을 설계하는 방법: 유스케이스 분리와 인프라 설정 제어 with Spring Boot

dev_Hyeonjoon — Thu, 18 Jun 2026 15:49:51 +0900

도메인 로직과 유스케이스

핵심 비즈니스 로직

현실 세계의 비즈니스 규칙 그 자체

유스케이스

사용자가 시스템을 통해 어떤 목적을 달성하는 흐름

예시

도메인 로직:
- 게시글 제목은 비어 있을 수 없다.
- 삭제된 게시글에는 댓글을 달 수 없다.
- 작성자만 게시글을 수정할 수 있다.

유스케이스:
- 게시글 작성하기
- 게시글 수정하기
- 게시글 삭제하기
- 게시글 목록 조회하기

즉, 유스케이스는 도메인 로직을 사용해서 하나의 기능 흐름을 완성하는 계층이다.

유스케이스는 공통모듈에 담지 않는 것이 좋다

유스케이스를 공통 코드로 뺀다면, 사이드 이펙트가 발생하기 쉬울 뿐만 아니라 예외 케이스를 위한 분기 처리도 들어가게 되면서 많은 문제가 발생한다
또한 유스케이스는 서비스마다 요구 사항이 다르기 쉽기 때문이다

예를 들어 게시글 작성 이라는 이름은 같아도,

board-service:
- 게시글 저장
- 작성자 검증
- 카테고리 검증

community-service:
- 게시글 저장
- 알림 발송
- 포인트 지급
- 신고 제한 검증

이렇게 흐름이 달라질 수 있다

이걸 공통 모듈에 넣으면 결국 아래와 같은 코드가 생기기 쉽게 된다

if (serviceType==BOARD) {
    ...
}else if (serviceType==COMMUNITY) {
    ...
}

그러면 공통 모듈이 오히려 더러워지고, 한 서비스 수정이 다른 서비스에 영향을 주는 사이드 이펙트가 생김.

그래서 정리하면:

공통 모듈에 넣어도 되는 것:
- 공통 예외
- 공통 응답 형식
- 공통 유틸
- 공통 인증 객체
- 공통 타입
- 정말 안정적인 shared kernel

공통 모듈에 넣으면 위험한 것:
- 유스케이스
- 서비스별 비즈니스 흐름
- 특정 서비스의 Repository
- 특정 서비스의 Entity
- 특정 서비스의 Application Service

자동 빈 등록 방식을 피해야한다

공통 인프라 설정 모듈에서는 컴포넌트 스캔에 의존한 자동 등록을 피하고, 각 서비스가 필요한 설정만 명시적으로 선택하도록 하는 것이 좋다.

주의점

모든 @Component, @Service, @Repository를 쓰지 말라는 뜻이 아니다

일반적인 서비스 내부에서는 여전히 이렇게 써도 됨

@Service
publicclassCreateBoardUseCase {
    ...
}

@Repository
publicinterfaceBoardRepositoryextendsJpaRepository<Board,Long> {
}

다만 문제는 공통 모듈에 있는 인프라 설정 클래스

컴포넌트 스캔 기반의 자동 등록 방식을 사용해서는 인프라 구성을 제어할 수 없다.
또한 해당 방식은 어떤 인프라 구성들이 존재하는지, 무엇이 현재 모듈에 적용되는지 명시적으로 파악하기가 어렵다

예를 들어 공통 모듈에 이런 설정이 있다고 해보자

@Configuration
@EnableJpaRepositories(...)
public class JpaConfig {
}

이게 컴포넌트 스캔으로 자동 등록된다면, 어떤 서비스에서는 JPA가 필요없는데도 JPA 설정이 들어올 수 있다.

또는 어떤 서비스는 Redis만 필요한데, JPA, Async, Jasypt까지 딸려올 수도 있다

따라서 우리는 인프라 구성에 대한 제어권을 획득할 수 있는 방법을 사용하는 것이 좋은데, 이 때 Spring 프레임워크에서 제공하는 ImportSelector를 이용하여 이를 구현해보도록 하자

인터페이스를 구성하자

각 서비스가 필요한 인프라 설정만 선택해서 사용한다.

먼저, 인프라 구성 타입을 추상화한 인터페이스를 생성해야한다.

해당 인터페이스를 구현한 클래스는 다른 모듈에서 적용될 수 있음을 나타낸다

public interface BoardInfraConfig {
}

모든 인프라 구성들은 해당 인터페이스를 구현한다. 구성 클래스들에는 자동 빈 스캔 방식에 의해 등록되지 않도록 @Component 를 포함한 하위 어노테이션들이 존재하지 않는다.

설정 클래스의 의미 붙이기

@Configuration(proxyBeanMethods = false)
@EnableAsync
public class AsyncConfig implements BoardInfraConfig {

    ...

}

@Configuration(proxyBeanMethods = false)
@EnableTransactionManagement
@EntityScan("com.mangkyu.appstore")
@EnableJpaRepositories("com.mangkyu.appstore")
public class JpaConfig implements BoardInfraConfig {

    ...

}

@Configuration(proxyBeanMethods = false) 를 붙이는 게 의도를 명확히 드러내기에 안전하다

하지만 이렇게 하면 @Configuration도 결국 내부적으로는 @Component 계열이라서 컴포넌트 스캔 대상이 될 수 있다.

그래서 자동 등록을 피하려면 아래와 같다

1. 해당 설정 클래스를 컴포넌트 스캔 범위 밖에 두거나
2. 메인 애플리케이션의 scanBasePackages에 포함되지 않게 하거나
3. @Import / ImportSelector로만 가져오도록 구조를 잡아야 함

즉 ,@Configuration 을 붙이면 무조건 문제가 아니라, 스캔으로 자동 등록되지 않게 패키지 구조를 잘 잡는 게 중요하다

이제 구성 클래스들을 모아둔 enum 클래스를 하나 생성한다.

이를 통해 인프라 구성들이 존재하는지, 무엇을 적용할지 손쉽게 파악할 수 있다.

@Getter
@RequiredArgsConstructor
public enum BoardConfig{

	ASYNC(AsyncConfig.class),
	JASYPT(JasyptConfig.class),
	JPA(JpaConfig.class),
	;

	private final Class<? extends BoardConfig> configClass;
	
}

여기까지 했다면 적용할 인프라 구성을 명시할 @Enable 어노테이션과 어노테이션에 존재하는 인프라 구성을 적용시켜 줄 ImportSelector를 구현한다. ImportSelector는 애플리케이션이 실행되는 시점에 해당 어노테이션에 붙은 Enum 값들을 기반으로 동적으로 구성 파일들을 불러온다.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(BoardConfigImportSelector.class)
public @interface EnableBoardConfig {

    BoardConfigGroup[] value();

}

ImportSelector를 구현할 때는 ImportSelector의 하위 인터페이스인 DeferredImportSelector를 사용하면 된다.

DeferredImportSelector는 모든 @Configuration 빈들이 처리된 후에 동작하는 ImportSelector이다. 선택된 설정들이 @Conditional 조건을 갖고 있는 경에 유용하다.

이를 처리하기 위해 EnableBoardConfig의 value에 할당된 Enum 값들을 모두 불러온 후에 configClass 값을 가져와야한다. 이러한 역할을 담당하는 ImportSelector 구현체는 다음과 같이 만들어줄 수 있다.

public class BoardConfigImportSelector implements DeferredImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata metadata) {
        return Arrays.stream(getValues(metadata))
                .map(value -> value.getConfigClass().getName())
                .toArray(String[]::new);
    }

    private BoardConfigGroup[] getValues(AnnotationMetadata metadata) {
        Map<String, Object> attributes =
                metadata.getAnnotationAttributes(EnableBoardConfig.class.getName());

        if (attributes == null) {
            return new BoardConfigGroup[]{};
        }

        return (BoardConfigGroup[]) attributes.getOrDefault(
                "value",
                new BoardConfigGroup[]{}
        );
    }
}

그러면 이제 다음과 같이 개별 모듈들에서 적용할 인프라 구성을 동적으로 그리고 명시적으로 선택할 수 있다. 이를 통해 인프라 구성에 대한 제어권을 획득할 수 있게 된 것이다.

@Configuration(proxyBeanMethods = false)
@EnableAppStoreConfig({
    BoardConfigGroup.ASYNC,
    BoardConfigGroup.JASYPT,
    BoardConfigGroup.JPA,
})

class InfraConfig {

}

하지만 이렇게 하더라도 엄격하게 공통 모듈을 관리해야할 수도 있다 아래 링크에 자세히 나와있다

https://mangkyu.tistory.com/304

결론

공통 모듈은 최대한 작고 안정적으로 유지한다.
유스케이스는 각 서비스 내부에 둔다.
인프라 설정은 필요한 서비스가 명시적으로 선택하게 한다.
컴포넌트 스캔으로 의도치 않은 Bean이 등록되지 않게 한다.

참고자료

https://mangkyu.tistory.com/304

GitHub Issue / PR 템플릿으로 일관성있게 작업하기

dev_Hyeonjoon — Thu, 18 Jun 2026 06:43:40 +0900

GitHub에서 Issue와 Pull Request를 작성하다 보면 매번 내용을 새로 작성해야 해서 생각보다 번거로운 경우가 많습니다.

특히 협업을 할 때는 사람마다 Issue나 PR을 작성하는 방식이 달라서, 어떤 Issue에는 작업 내용이 빠져 있고 어떤 PR에는 리뷰어가 확인해야 할 내용이 부족한 상황이 생기기도 합니다.

물론 팀에서 미리 형식을 정해둘 수도 있지만, 매번 직접 작성하다 보면 실수로 특정 항목을 빼먹는 경우가 생길 수 있습니다.

그래서 이번에는 GitHub에서 Issue와 PR 템플릿을 만들어, 협업 시 작성 형식을 조금 더 일관성 있게 관리하는 방법을 정리해보려고 합니다.

템플릿을 미리 만들어두면 Issue나 PR을 생성할 때 정해진 양식이 자동으로 표시되기 때문에, 작성 시간을 줄이고 협업 과정에서도 필요한 정보를 빠뜨리지 않도록 도와줄 수 있습니다.

Issue 템플릿 생성하기

먼저 프로젝트 루트 경로에 .github 폴더를 만들고, 그 안에 ISSUE_TEMPLATE 폴더를 생성합니다.

구조는 다음과 같습니다.

이후 issue-template.md 파일 안에 원하는 Issue 템플릿을 작성하면 됩니다.

---
name: "\bIssue 생성 템플릿"
about: 이슈 생성을 위한 템플릿입니다.
title: ''
labels: ''
assignees: ''

---

## 어떤 기능인가요?
> 추가하려는 기능에 대해 간결하게 설명해주세요

##   작업 상세 내용
- [ ] 구현 내용
- [ ] 
- [ ] 

##   참고 자료 (선택)

위와 같이 작성해두면 새로운 Issue를 생성할 때 해당 템플릿을 선택해서 사용할 수 있습니다.

이를 통해 기능 설명, 작업 상세 내용, 참고 자료 등을 일정한 형식으로 작성할 수 있어 협업 과정에서 Issue 관리가 훨씬 쉬워집니다.

PR 템플릿

Pull Request 템플릿도 비슷한 방식으로 만들 수 있습니다.

프로젝트 루트 경로에 .github 폴더를 만들고, 그 안에 pull_request_template.md 파일을 생성합니다.

구조는 다음과 같습니다.

이후 pull_request_template.md 파일 안에 원하는 PR 템플릿을 작성하면 됩니다.

## #️⃣연관된 이슈

> ex) #이슈번호, #이슈번호

##  작업 내용

> 이번 PR에서 작업한 내용을 간략히 설명해주세요(이미지 첨부 가능)

### 스크린샷 (선택)

##  리뷰 요구사항(선택)

> 리뷰어가 특별히 봐주었으면 하는 부분이 있다면 작성해주세요
>
> ex) 메서드 XXX의 이름을 더 잘 짓고 싶은데 혹시 좋은 명칭이 있을까요?

PR 템플릿을 만들어두면 Pull Request를 생성할 때 본문에 위 양식이 자동으로 들어갑니다.

덕분에 작업 내용, 관련 Issue, 리뷰 요청 사항 등을 빠뜨리지 않고 작성할 수 있으며, 리뷰어 입장에서도 변경 사항을 더 쉽게 파악할 수 있습니다.

이슈 올리기

마무리

Issue와 PR 템플릿은 설정 자체는 간단하지만, 협업할 때는 꽤 큰 도움이 됩니다.

매번 같은 내용을 반복해서 작성하지 않아도 되고, 팀원마다 다른 방식으로 작성하던 Issue와 PR을 일정한 형식으로 맞출 수 있기 때문입니다.

작은 설정이지만 협업의 흐름을 깔끔하게 만들어주는 기능이기 때문에, 팀 프로젝트를 진행한다면 초기에 설정해두는 것을 추천합니다.

[Spring] Business Layer와 Presentation Layer 분리의 중요성

dev_Hyeonjoon — Tue, 16 Jun 2026 17:39:50 +0900

결론

Request/Response DTO는 API 입출력 형식에 가깝고, API 요구사항은 FE 화면 구성이나 기획 변경에 따라 자주 바뀐다. 그래서 Service가 DTO를 직접 반환하면 비즈니스 로직이 프레젠테이션 계층의 변화에 끌려다닐 수 있다. 이번 프로젝트에서는 Service는 Entity, VO, primitive, Map 같은 비즈니스에 가까운 값을 반환하고, Controller에서 Response DTO로 변환하는 방식을 사용했다.

1. 문제 발생 상황

이번 SOPT에서 합동 세미나를 진행했고 아래와 같은 일이 있었다.

내가 원래 배웠던 구조는 차트 API, 좋아요 토글 API, 아티스트 곡 목록 API를 구현하면서 Service가 바로 Response DTO를 반환할 수 있었다.

하지만 리드님께서는 Business Layer와 Presentation Layer 를 확실히 원했고 합동 세미나 그라운드 룰에 규칙을 적으셨다.

합동 세미나 그라운드 룰을 만들면서 ”귀찮게 왜 분리시키는거지? 한 번에 해결하면 쉽고 파일양도 줄일 수 있어서 이득 아닌가..?” 라는 생각에 사로 잡혀있었다.

하지만 이렇게 하면 Service가 API 응답 형태를 알게 되어버리는 문제가 있었다.

2. 합동 세미나 그라운드 룰

비즈니스 로직: 서버가 책임지는 규칙
- 예: 유저 검증, 권한 확인, 좋아요 여부 판단, 좋아요 수 증가/감소, 정렬 기준에 따른 곡 조회
프레젠테이션 로직: API 응답을 어떻게 보여줄지 조립하는 영역
- 예: FE가 필요한 형태로 songId, title, artist, albumImageUrl을 묶어서 내려주기
  - 즉, 우리는 프론트엔드가 뭘 하지 않고 딱 보여주는 형태로 보내주쟈!

⇒ Service는 최대한 얇게, Controller에서는 조립 시키기!

3. 합동세미나 예시

문제 발생 상황

public record ChartSongInfo(
				 Long songId,
        String title,
        Long artistId,
        String artistName,
        String albumImageUrl
) {

}

맨 처음에는 Vo객체는 관심사를 모으는 걸로 이해해서 곡과 아티스트를 한꺼번에 모으면 되겠네 하고 Vo패키지에 적용시켰다

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class ChartService {

    private final SongDetailRepository songDetailRepository;

    public ChartResponse findChartByFilter(final ChartFilterType chartFilterType) {
        List<ChartSongInfo> chartSongs = switch (chartFilterType) {
            case TOP100 -> songDetailRepository.findTop100Chart();
            case HOT100 -> songDetailRepository.findHot100Chart();
            case ABROAD_2006, SWEET -> songDetailRepository.readChart();
        };

        return ChartResponse.of(chartSongs);
    }
}

그 후 Service에서는 dto/reponse/에 있는 ChartResponse를 바로 반환하는 실수를 했었다
- 그라운드 룰에 의해 Service에서는 dto를 반환하면 안됨

해결 방법

vo 객체가 필요없다고 판단이 들어서 삭제 시켰다

ChartResponse에서 아래와 같이 반환하게 되면 join도 필요없이 반환할 수 있다는 장점에서 삭제

public record ChartResponse(
        @Schema(description = "차트 곡 목록")
        List<SongInfo> songs
) {

    public static ChartResponse of(List<Song> songs, Map<Long, List<Artist>> artistsMap) {
        return new ChartResponse(
                songs.stream()
                        .map(song -> SongInfo.of(
                                song,
                                artistsMap.getOrDefault(song.getId(), List.of())
                        ))
                        .toList()
        );
    }

    public record SongInfo(
            @Schema(description = "곡 ID", example = "1")
            Long songId,

            String albumImageUrl

    ) {

        public static SongInfo of(Song song, List<Artist> artists) {
            Artist artist = artists.getFirst();

            return new SongInfo(
                    song.getId(),
                    song.getTitle(),
                    new ArtistInfo(artist),
                    song.getAlbum().getImageUrl()
            );
        }
    }

    public record ArtistInfo(
            String name
    ) {

        public ArtistInfo(Artist artist) {
            this(artist.getId(), artist.getName());
        }
    }
}

Service는 Entity, VO, primitive, Map 같은 비즈니스에 가까운 값을 반환하기
- Mapper를 사용한 아티스트 곡 목록 조회 Service

package org.sopt.collaboration.melon.domain.song.service;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.sopt.collaboration.melon.domain.artist.entity.Artist;
import org.sopt.collaboration.melon.domain.song.entity.Song;
import org.sopt.collaboration.melon.domain.song.entity.SongArtist;
import org.sopt.collaboration.melon.domain.song.repository.SongArtistRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class SongArtistService {

    private final SongArtistRepository songArtistRepository;

    public List<Artist> findAllArtistsBySongId(Long songId) {
        return songArtistRepository.findAllBySongId(songId)
                .stream()
                .map(SongArtist::getArtist)
                .toList();
    }

    public Map<Long, List<Artist>> findArtistAsMap(List<Song> songs) {
        List<Long> songIds = songs.stream()
                .map(Song::getId)
                .toList();

        return songArtistRepository.findAllBySongIdIn(songIds).stream()
                .collect(Collectors.groupingBy(
                        SongArtist::getSongId,
                        Collectors.mapping(SongArtist::getArtist, Collectors.toList())
                ));
    }

    public List<Song> findArtistSongBySort(Long artistId, List<Song> sortedSong) {
        List<Long> artistSongIds = songArtistRepository.findSongIdsByArtistId(artistId);
        return sortedSong.stream()
                .filter(song -> artistSongIds.contains(song.getId()))
                .toList();
    }

}

3. Controller는 조립해서 Dto로

@RestController
@RequestMapping("/v1/chart")
@RequiredArgsConstructor
public class ChartController implements ChartApi {

    private final ChartService chartService;
    private final SongArtistService songArtistService;

    @GetMapping
    public CommonResponse<ChartResponse> getChartByFilter(
            @RequestParam(defaultValue = "TOP100") String chartFilter
    ) {

        List<Song> chartSongsByFilter = chartService.findChartSongByFilter(ChartFilterType.from(chartFilter));

        Map<Long, List<Artist>> artistsMap = songArtistService.findArtistAsMap(chartSongsByFilter);

        ChartResponse response = ChartResponse.of(chartSongsByFilter, artistsMap);

        return CommonResponse.success(ChartSuccessCode.GET_CHART, response);
    }

}

정리

개념을 알기 전에는 Business Layer와 Presentation Layer 분리하는 게 너무 귀찮고 실수도 많았었다.

하지만 합동 세미나를 진행하면서 많은 API이 삭제되거나 추가되거나 수정되는 일이 많이 발생하였다. 이 때마다 Service에서 dto를 반환하지 않아서 간편하게 Controller와 dto만 신경 쓰면 되었다.

가장 크게 느낀 부분은 차트 API였다. 필터 정렬 순서를 어떻게 처리할지 팀 내에서 여러 번 논의가 오갔고, 요구사항도 계속 바뀌었는데, 정렬과 계산 로직을 Service 쪽에서 집중적으로 관리할 수 있어서 수정 부담이 줄었다.

또한 차트 API와 아티스트 곡 목록 조회 API에서 계산 로직이 겹치는 필터가 있었는데, 공통 로직을 재사용하고 필터명만 다르게 처리할 수 있도록 구현하면서 코드량도 줄일 수 있었다.

참고자료

Command 읽어봤던 자료

https://lets-do-the-odessey.tistory.com/47

[TIL] Java 함수형 프로그래밍 입문: 람다, 스트림, Predicate·Consumer·Function 이해하기

dev_Hyeonjoon — Sun, 22 Feb 2026 01:00:13 +0900

함수형 프로그래밍이란

일급 객체로 취급하여 프로그램을 작성하는 프로그래밍 패러다임

일급 객체는

여기서 일급은 사용할 때 다른 요소들과 아무런 차별이 없다는 것을 뜻합니다!

변수에 저장할 수 있다
함수의 매개변수로 전달할 수 있다
함수의 반환값으로 사용할 수 있다
런타임에 생성할 수 있다

자바에서 함수 프로그래밍이 필요한 이유

Java 8버전 부터 함수형 프로그래밍을 지원하기 위해 람다(lambda)와 스트림(stream)이 도입되었는데 이 때, 람다와 스트림을 사용하면 가독성이 좋아지기 때문입니다.

병렬 처리 용이 (parallelStream)
부작용 감소
선언형 프로그래밍 가능
내부 반복 (Internal Iteration)

람다(lambda)

람다(lambda)는 익명 함수(anonymous function)를 의미

아래에서는 람다와 일반적인 코드를 비교하면서 왜 람다가 도움이 되는지 적어보겠습니다

일반 코드

List<Integer> numbers = List.of(4, 6, 8, 13, 3, 15);
int sum = 0;
for (int number : numbers) {sum += number; }
        
System.out.println(sum);

람다식을 사용하지 않고 배열의 합계를 구하기 위해 for 반복문을 활용해 복잡하게 구현했어야 했습니다.
하지만 람다식을 사용한다면 가독성을 올릴 수 있게 됩니다.

람다를 적용한 코드

int sum = numbers.stream().reduce(
                0, 
                (number1, number2) -> number1 + number2);

기존 코드에서 복잡했던 것들은 람다 표현식을 통해 가독성이 매우 좋아진 걸 확인할 수 있습니다.

차이점

함수형 프로그래밍에서는 변수 변이를 피합니다.
- 일반 코드에서 sum 변수는 초기 값이 0이었지만 숫자를 반복해서 더할 때마다 총합이 계속 증가하는데 이를 변수 변이라고 합니다.
함수형 프로그래밍은 뭘 할지에 중점을 둡니다.
- 모든 숫자 쌍을 더 할지만 관심이 있지 어떻게 하는가에는 신경 쓰지는 않습니다.
- 반면, 구조적 프로그래밍에서는 뭘 할지와 어떻게 할지를 알려줘야 합니다
  - for문에서 합을 어떻게 할지 정확하게 표현해줬어야 합니다
    - 0으로 초기화하고, 숫자를 루프한 다음 숫자 하나를 대입하고, 그 값을 리턴하라는 것

람다 표현식 작성하는 방법

람다 표현식에 보이는 stream() 은 “자주 사용하는 대표 사례”입니다

stream은 ‘흐름’이라는 뜻으로써, 데이터가 물결처럼 흘러가면서 필터링 과정을 통해 여러 번 변경되어 반환되기 때문에 이러한 이름을 갖게 되었습니다. 이러한 stream은 배열의 요소들을 전개해줍니다

(매개변수) -> { 실행문 }

람다 표현식의 구성 요소는 3가지 입니다.

(매개변수) : 입력 값
> : 람다 연산자 (parameter와 body를 구분)
{ 실행문 } : 실행할 코드 (함수 몸체)

작성 규칙

매개 변수가 없을 때

() -> System.out.println("Hello");

매개변수가 하나일 때 (괄호 생략 가능)

x ->System.out.println(x);

(x) ->System.out.println(x);// 둘 다 가능

매개변수가 여러 개 일때

(a,b) ->a+b

실행문이 한 줄이면 {} 생략 가능

(a,b) ->a+b

여러 줄이면 반드시 {} 필요

(a,b) -> {
intresult=a+b;
returnresult;
}

반환값 규칙

한 줄 표현식 → return 생략
블록 {} 사용 시 → return 반드시 명시

// return 생략 가능
(a,b) ->a+b

// return 필요
(a,b) -> {
returna+b;
}

람다 표현식은 “코드를 줄이기 위한 문법”이 아니라, 동작 자체를 값처럼 전달하기 위한 방식이라는 점이 핵심!

람다 예제

람다 예제 전, Stream에는 두 가지 연산이 있습니다 중간 연산과 종단 연산

public static void main(String[] args) {
        List.of(23,43,34,45,36,48).stream()
                .filter(n -> n%2 == 0)
                .forEach(e -> System.out.println(e));
    }

중간 연산

Sort

모든 숫자를 받아 정렬하고 출력되게 forEach로 보냅니다

Distinct

중복을 제거합니다
리스트에 존재하는 순서대로 출력됩니다

numbers.stream().distinct().sorted().forEach(e->System.out.println(e));

Sort와 Distinct는 중간 연산에 해당합니다
중간 연산은 메소드 갯수 제한이 없습니다

Map

numbers.stream().distinct().map(e -> e*e).forEach(e->System.out.println(e));

리스트에서 요소를 받아 중복 제외된 값을 찾고 그 숫자의 제곱을 출력한다고 할 때
- 즉, 숫자를 그대로 출력하는 게 아니라, 그 제곱값을 출력할 때 유용합니다
Map 또한 중간 연산에 포함됩니다

종단 연산

스트림을 종료시키는 연산이며 더 이상 스트림 연산을 이어갈 수 없습니다

IntStream.range(1,11).reduce( 0, (n1, n2) -> n1 + n2)

reduce의 역할을 생각해보면 숫자 스트림을 하나의 결괏값으로 반환하며 더 이상 스트림 연산을 이어갈 수 없습니
- 즉, 종단 연산

Max

종단 연산에 해당하며 비교자가 필요합니다

List.of(23,12,34,53).stream().max((n1,n2) -> Integer.compare(n1,n2))
//Optional[53]

기본적으로 반환값은 Optional로 반환되는데 그 이유는 최대 값이 있을지 없을지 모르기 때문입니다

List.of(23,12,34,53).stream().max((n1,n2) -> Integer.compare(n1,n2)).get()
//53

뒤에 .get()을 통해 최대 값만 가져올 수 있습니다

Min

종단 연산이며 마찬가지로 비교 연산자가 필요합니다

List.of(23,12,34,53).stream().min((n1,n2) -> Integer.compare(n1,n2)).get()

함수형 인터페이스 이면의 원리

람다 표현식은 Functional Interface에 기반을 두어 실행됩니다

Predicate In 구현

public static void main(String[] args) {
        List.of(23,43,34,45,36,48).stream()
                .filter(n -> n%2 == 0)
                .forEach(e -> System.out.println(e));
    }

여기 리스트 원소들이 어떻게 filter 메소드에 전송되는 걸까요?

filter메소드를 보면 Predicate를 사용한다고 나와있습니다 Predicate에 대해 더 자세히 보자면

FunctionalInterface를 사용하며 Predicate 인터페이스며 그 인터페이스 안에는 test라는 메소드를 가지고 있습니다

test 메소드는 사실 실행되지 않는 유일한 메소드입니다. 그럼에도 Predicate 인터페이스와 일치하게 매핑되는 이유는 만약 인터페이스를 허용하는 메소드들를 가지고 있다면, 그 인터페이스에 대해서만 그 인터페이스의 실행에 대한 대상만 파라미터로써 실행이 가능합니다.

package functionalprogramming;

import java.util.List;
import java.util.function.Predicate;

class EvenNumberPredicate implements Predicate<Integer>{
    @Override
    public boolean test(Integer number) {
        return number %2 == 0;
    }
}
public class LambdaBehindTheScreensRunner {
    public static void main(String[] args) {
        List.of(23,43,34,45,36,48).stream()
                .filter(n -> n%2 == 0)
                .forEach(e -> System.out.println(e));

        
        List.of(23,43,34,45,36,48).stream()
                .filter(new EvenNumberPredicate())
                .forEach(e -> System.out.println(e));
    }
}

같은 값을 출력하는 걸 볼 수 있는데 그 이유는 로직을 이용하고 여기에 filter 메소드를 사용하면 화면 뒤에서는 아래와 같이 행동합니다

자바 컴파일러가 함수형 인터페이스를 실행합니다
- 함수형 인터페이스에서 가장 중요한 것은, Predicate처럼 딱 한 개의 메소드만 정의 되지 않는다는 것 인데 기본적으로 람다형을 생성할 때에는 특정 메소드를 실행해주는 작업을 합니다
여기에서 test메소드를 이 부분이 실행되도록 하는 것입니다
필터링 후 메소드에 값을 집어넣는 것
- 이 특정한 인터페이스를 Predicate라고 부르는데, 그 이유는 이게 하는 적업이 평가를 진행한 후에 참인지 거짓인지를 판단하여 그 값을 반환하기 때문입니다

Consumer Int 구현

ForEach에서는 이렇게 Consumer 인터페이스를 사용합니다

Consumer 인터페이스에는 accept 메소드를 사용합니다

accept 메소드

아무것도 반환하지 않습니다
- 이는 Consumer (소비자) 라고 불리는 이유입니다.
- 예시로 forEach에서는 e → System.out.print(e) 구문을 자주 쓰는데
- 우리는 요소를 받자마자 바로 써버리기 때문에 반환할 필요가 없는 것입니다
  - forEach에는 Consumer 인터페이스가 존재한다

package functionalprogramming;

import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

class EvenNumberPredicate implements Predicate<Integer>{
    @Override
    public boolean test(Integer number) {
        return number %2 == 0;
    }
}

class SystemOutConsumer implements Consumer<Integer> {

    @Override
    public void accept(Integer number) {
        System.out.println(number);
    }
}

public class LambdaBehindTheScreensRunner {
    public static void main(String[] args) {
        List.of(23,43,34,45,36,48).stream()
                .filter(n -> n%2 == 0)
                .forEach(e -> System.out.println(e));

        List.of(23,43,34,45,36,48).stream()
                .filter(new EvenNumberPredicate())
                .forEach(new SystemOutConsumer());
    }
}

이 또한 결과가 일치합니다

Function Int 구현

List.of(23, 43, 34, 45, 36, 48).stream()
                .filter(n -> n % 2 == 0)
                .map(n -> n * n)
                .forEach(e -> System.out.println(e));

map을 사용할 때는 Function 인터페이스를 사용합니다

어떤 값을 넣어주면 다른 값을 반환해줍니다

위 코드에서 map을 보면 Stream을 반환해줬음을 알 수 있습니다
여기 함수에서는 한 객체를 입력 값으로 받고, 다른 객체를 출력 값으로 보냅니다
- 위 코드에서는 입력 값이 n, 출력 값이 n*n이 되는 것입니다

package functionalprogramming;

import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

class EvenNumberPredicate implements Predicate<Integer>{
    @Override
    public boolean test(Integer number) {
        return number %2 == 0;
    }
}

class SystemOutConsumer implements Consumer<Integer> {

    @Override
    public void accept(Integer number) {
        System.out.println(number);
    }
}

class NumberSquareMapper implements Function<Integer, Integer> {

    @Override
    public Integer apply(Integer number) {
        return number * number;
    }
}

public class LambdaBehindTheScreensRunner {
    public static void main(String[] args) {
        List.of(23, 43, 34, 45, 36, 48).stream()
                .filter(n -> n % 2 == 0)
                .map(n -> n * n)
                .forEach(e -> System.out.println(e));

        List.of(23, 43, 34, 45, 36, 48).stream()
                .filter(new EvenNumberPredicate())
                .map(new NumberSquareMapper())
                .forEach(new SystemOutConsumer());
    }
}

똑같이 출력됩니다

정리

Function은 함수형 인터페이스 중 하나로, 입력값을 얻고 어떤 값을 출력해내는 인터페이스를 뜻합니다
Predicate는 입력값을 보고 참인지 거짓인지를 판단
Consumer는 사용자가 어떤 값을 입력해주고 그에 대한 소비를 진행
- 그러므로 어떤 값도 반환 x

References

Udemy, Best Java Programming Course
- https://www.udemy.com/course/best-java-programming/
점프 투 자바
- https://wikidocs.net/157858
Inpa Dev
- https://inpa.tistory.com/entry/CS- ‍ -일급-객체first-class-object

[TIL] - Java Map 구조 이해하기 — HashMap, LinkedHashMap, TreeMap 언제 사용할까?

dev_Hyeonjoon — Fri, 13 Feb 2026 20:47:22 +0900

Map Interface

key-value 방식을 사용합니다

https://techvidvan.com/tutorials/java-collection-framework/

Map 인터페이스는 사진에서 보는 것과 같이 Collection 인터페이스를 연장하지 않습니다
- 하지만 keySet(), values(), entrySet()을 통해 Collection 형태로 데이터를 다룰 수 있습니다.
Map은 키-값을 저장하는데 쓰입니다
Map 에서도 Collection과 같이 다양한 구현들이 있습니다
고유한 Key를 통해 빠른 데이터 검색, 추가, 삭제, 수정이 가능
- Key는 고유해야 함
- Value는 고유 xx
요소의 저장 순서를 유지하지 않습니다.

HashMap

Map<Character, Integer> occurances = new HashMap<>();

HashMap을 이루는 데이터 구조는 HashTable입니다
- 하지만 충돌이 발생하면 LinkedList 또는 Red-Black Tree 형태로 데이터를 저장합니다(Java 8 이상).
분류되지 않고 순서도 없습니다

HashTable과 차이점

HashTable, HashMap 모두 해싱 기법을 데이터 구조에 사용합니다
⇒ 연산과 관련해서는 아무 차이 ❌

하지만 HashTable은 Vector와 유사하게 모든 메소드가 동기화되어 있습니다

스레드가 HashMap에 비해 더 안전

- Hashtable은 모든 메서드가 synchronized 되어 있어 멀티스레드 환경에서 안전하지만
  성능 오버헤드가 크기 때문에 현재는 거의 사용되지 않는다.
- 대신 ConcurrentHashMap 사용이 권장된다.

HashMap은 Key를 null값으로 저장할 수 있습니다
- 하지만 HashTable 에서는 ❌

LinkedHashMap

삽입 순서가 유지됩니다

Map<Character, Integer> linkedHashMap = new LinkedHashMap<>();

정렬되어 있지 않고 삽입 순서이기 때문에 HashMap에 비해 삽입과 제거는 조금 느립니다
- 하지만 요소 간에 연결되어 있어 요소를 도는 이터레이션은 훨씬 빠릅니다

TreeMap

정렬된 순서로 데이터 저장

Map<Character, Integer> treeMap = new TreeMap<>();

TreeMap은 Red-Black Tree 기반으로 동작하며, 정렬된 데이터를 탐색하기 위해 NavigableMap 인터페이스를 구현합니다
- TreeMap의 경우 Navigable

Map Interface의 기초 연산

of()로 Map 생성

 Map<String, Integer> map = Map.of("A", 3, "B", 5, "Z", 10);

Map을 작성할 때는 Key-Value 값의 타입을 각각 설정해줘야 합니다
또한 위 코드는 of 함수를 사용했기에 수정이 불가능합니다

Value 갖고 오기

map.get("Z"); //키로 값을 불러올 수 있다 
//10

만약 존재하지 않는 값을 찾으려고 할 때 null을 반환

다양한 메소드

map.size(); //맵의 크기를 검색
map.isEmpty(); //비어있는지 검색
map.containsKey("A"); //"A"라는 열쇠를 포함하고 있는지
map.containsValue(3); // 3이라는 값을 포함하고 있는지

map.keySet(); //데이터 구조와 열쇠들의 Collection만 가져온다
map.values(); // 값만 반환

Map 에 Key-Value 추가하기

Map<String, Integer> hashmap = new HashMap<>(map);
hashmap.put("F",5);
hashmap.put("Z",11); //기존에 있던 Z=10 이 Z=11로 변경

TreeMap NavigableMap의 메소드 - floorKey, higherKey, firstEntry

treemap.higherKey("B"); //B 초과 키를 반환한다
treemap.ceilingKey("B"); // B 이상 키를 반환

treemap.lowerKey("B"); // B 미만 키를 반환
treemap.floorKey("B"); // B 이하 키를 반환

treemap.firstEntry(); //  첫 번째  키-값을 반환
treemap.lastEntry(); // 마지막 키-값을 반환

treemap.submap("C", "Y"); //하위 맵 생성 (C이상 Y 미만의 모든 키와 값을 반환) 
treemap.submap("C",true, "Y", true); //하위 맵 생성 (C이상 Y 이하의 모든 키와 값을 반환)
treemap.submap("C",false, "Y", false); //하위 맵 생성 (C초과 Y 미만의 모든 키와 값을 반환)

※ TreeMap은 정렬 기준(Comparable 또는 Comparator)에 따라 위 결과가 결정

언제 어떤 Map을 써야 할까?

빠른 조회만 필요 → HashMap
입력 순서 유지 필요 → LinkedHashMap
정렬 및 범위 탐색 필요 → TreeMap
멀티스레드 환경 → ConcurrentHashMap

References

Udemy, Best Java Programming Course
- https://www.udemy.com/course/best-java-programming/

함께 보면 좋은 글
- Java Collection Framework 과 List
- Set 과 Queue

[TIL]HashSet vs TreeSet vs LinkedHashSet 차이점과 PriorityQueue 이해

dev_Hyeonjoon — Fri, 13 Feb 2026 00:18:53 +0900

Set 소개

Java Collection 인터페이스를 연장 받습니다.
- 하지만 많은 메소드를 제공 받지 않습니다
유일한 값만 가질 수 있고 순서가 없습니다
- 만약 두 개의 값이 같다면, 그 중 하나만 Set에 들어갈 수 있습니다
- 순서가 없기에 위치와 순서를 상관하지 않습니다

데이터 구조에 따른 Set

package collection;

import java.util.*;

public class SetRunner {

    public static void main(String[] args) {
        List<Character> characters = List.of('A', 'Z', 'A', 'B', 'Z', 'F');

        //정렬 순서 - TreeSet
        Set<Character> treeSet = new TreeSet<> (characters);
        System.out.println("treeSet" + treeSet);

        //삽입 순서 - LinkedHashSet
        Set<Character> linkedSet = new LinkedHashSet<>(characters);
        System.out.println("linkedSet" + linkedSet);

        //상관없다면 - hashSet
        Set<Character> hashSet = new HashSet<>(characters);
        System.out.println("hashSet" + hashSet);
    }
}

HashSet

geeksforgeeks

HashSet은 해시 테이블을 기반으로 구현되었습니다
데이터 추가, 삭제, 검색이 평균의 시간 복잡도가 평균 - O(1), 최악 - O(n) 으로 매우 빠르며, 유일한 데이터 집합을 관리하거나 중복을 제거할 때 주로 사용됩니다

LinkedHashSet

HashSet에 연결 리스트(LinkedList)를 결합하여 요소가 삽입된 순서를 보장하는 자료구조
삽입한 순서대로 저장됩니다
- 하지만 순서를 정렬할 수는 없습니다
해시 테이블을 사용하여 검색 성능이 뛰어나며, 데이터를 추가한 순서대로 유지해야 하는 캐시(Cache)나 순서 보장형 집합에 적합합니다.

TreeSet

https://coding-factory.tistory.com/555

중복을 허용하지 않으며 요소들이 자동으로 오름차순 정렬됩니다.
Red-Black Tree (균형 이진 탐색 트리)를 사용하여 검색과 정렬에 높은 성능을 제공하며, 대량의 데이터를 정렬된 상태로 유지해야 할 때 유용합니다.

TreeSet의 NavigableSet

HashSet과 LinkedHashSet 와는 다르게 TreeSet 에서는 Collection 프레임워크 뿐만 아니라 Navigable의 메소드도 지원합니다

NavigableSet<Integer> numbers = new TreeSet<>(Set.of(65,54,34,12,99));
// numbers ==> [12, 34, 54, 65, 99]

TreeSet.floor(34); //이하 

numbers.lower(34); //미만

numbers.ceiling(34); //이상

numbers.higher(34); //초과 

numbers.subSet(20,80) // 20 이상  80 미만 사이에 있는 숫자 찾기 
numbers.subSet(20,true,80,true) // 20이상 80이하 사이에 있는 숫자 찾기
numbers.subSet(20,false,80,false) // 20초과 80미만 사이에 있는 숫자 찾기

numbers.headSet(50); // 50까지의 모든 숫자들을 출력
numbers.tailSet(50); // 50 이후의 모든 숫자들을 출력

Set 정리

구현체	중복	순서	정렬	시간복잡도
HashSet	X	없음	X	O(1)
LinkedHashSet	X	삽입순	X	O(1)
TreeSet	X	정렬순	O	O(log n)

Queue 소개

먼저 들어온 데이터가 먼저 나가는 선입선출(FIFO, First-In-First-Out) 구조의 선형 자료구조

순서에 맞는 원소를 처리합니다
- 예를 들어, 투두리스트
Collection의 연장선이라 Collection의 주요 메소드를 지원합니다
- 그 외에도 Queue는 add, offer, remove, poll, peek 라는 메서드도 지원합니다
인덱스를 통한 요소에 직접 접근은 거부됩니다

PriorityQueue - 기본 메소드와 사용자 정의 우선 순위

일반 Queue → First In First Out
PriorityQueue → FIFO
- 우선 순위 기반

Queue<String> queue = new PriorityQueue<>(); //Queue 선언 

queue.poll(); //queue에서 요소를 꺼냄 

queue.offer("Apple"); //queue에 요소를 넣음

queue.addAll(List.of("Zebra", "Monkey", "Cat")); // queue에 모든 요소들을 넣음 
//이때 결과값으로는 [Apple, Cat, Monkey, Zebra] 이 나오는데 queue에서 자동으로 알파벳
//로 설정해주기 때문

jshell> queue.poll()
$6 ==> "Apple"

jshell> queue
queue ==> [Cat, Zebra, Monkey]

Queue는 전시화나 영화관에서 웨이팅 하는 것 처럼 동작합니다
- 가장 먼저 들어온 사람이 가장 먼저 들어가는 거죠
Queue에서는 요소의 우선순위를 지정할 수 있다

package collection;

import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;

public class QueueRunner {
    public static void main(String[] args) {
        Queue<String> queue = new PriorityQueue<>();
        queue.addAll(List.of("Zebra", "Monkey", "Cat"));
        System.out.println(queue.poll()); //Cat
        System.out.println(queue.poll()); //Monkey
        System.out.println(queue.poll()); //Zebra
        System.out.println(queue.poll()); //null

    }
}

Queue에서 사용자 지정 순서 정하기

comparator 인터페이스로 간단하게 가능합니다

package collection;

import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;

class StringLengthComparator implements Comparator<String> {
    //오름차순 정렬
    @Override
    public int compare(String value1, String value2) {
        return Integer.compare(value1.length(), value2.length());
    }
}
public class QueueRunner {
    public static void main(String[] args) {
        Queue<String> queue = new PriorityQueue<>(new StringLengthComparator());

        queue.addAll(List.of("Zebra", "Monkey", "Cat"));
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());

    }
}

/* 
출력값
Cat
Zebra
Monkey
null
*/

참고 자료

Coding Factory,
[Java TreeSet 정리]
https://coding-factory.tistory.com/555
GeeksforGeeks,
Queue Interface in Java
https://www.geeksforgeeks.org/java/queue-interface-java/
Udemy,
Java Programming 강의

https://www.udemy.com/course/best-java-programming/

[TIL]자바 컬렉션 프레임워크 구조 분석 — List 내부 동작과 정렬 원리 파헤치기

dev_Hyeonjoon — Thu, 12 Feb 2026 17:55:34 +0900

자바 컬렉션

데이터를 저장하는 자료 구조와 데이터를 처리하는 알고리즘을 구조화하여 클래스로 구현해 놓을 것

https://techvidvan.com/tutorials/java-collection-framework/

컬렉션 프레임워크의 장점

인터페이스와 다형성을 이용한 객체지향적 설계를 통해 표준화되어 있기 때문에, 사용법을 익히기도 편하고 재사용성이 높다
데이터 구조 및 알고리즘의 고성능 구현을 제공하여 프로그램의 성능과 품질을 향상 시킨다
관련 없는 API간의 상호 운용성을 제공한다.
- 상위 인터페이스 타입으로 업캐스팅하여 사용
이미 구현되어 있는 API를 사용하기에, 새로운 API를 익히고 설계하는 시간이 줄어든다
소프트웨어 재사용을 촉진하다. 만일 자바에서 지원하지 않는 새로운 자료구조가 필요하다면, 컬렉션들을 재활용하고 조합하여 새로운 알고리즘을 만들어낼 수 있다

List 분석하기

자바9 이후에서 리스트 선언

List<String> words = List.of("Apple", "Bat", "Cat");

여기서 of는 List 인터페이스 안에 존재하는 정적 메소드입니다.
만약 of 함수를 사용한다면 크기는 고정되어 어떤 데이터 타입에서도 크기를 바꿀 수 없습니다
그리고 이것을 불변성 이라고 부릅니다

불변성

List<String> words = List.of("Apple", "Bat", "Cat");
words.add("Dog"); //error

of 함수를 사용해 만든 것들은 불변성을 가지기에 에러가 납니다

가변

List<String> words = List.of("Apple", "Bat", "Cat");
List<String> wordsArrayList = new ArrayList<String>(words);
List<String> wordsLinkedList = new LinkedList<String>(words);
List<String> wordsVector = new Vector<String>(words);

이러한 객체들은 모두 추가하는게 허용됩니다

public static void main(String[] args) {

        //ArrayList 추가할 때
        wordsArrayList.add("Dog");
        System.out.println(wordsArrayList);

        //LinkedList 추가할 때
        wordsLinkedList.add("Dog");
        System.out.println(wordsLinkedList);

        //Vector 추가할 때
        wordsVector.add("Dog");
        System.out.println(wordsVector);
    }

Vector, Stack, Hashtable, Properties 와 같은 클래스들은 컬렉션 프레임워크가 만들어지기 이전부터 존재하던 것이기 때문에 컬렉션 프레임워크의 명명법을 따르지 않는다. 또한 Vector 나 Hashtable 과 같은 기존의 컬렉션 클래스들은 호환을 위해 남겨진 것이므로 가급적 사용하지 않는 것이 좋다.

출처: [<https://inpa.tistory.com/entry/JCF- -Collections-Framework-종류-총정리>](<https://inpa.tistory.com/entry/JCF-%F0%9F%A7%B1-Collections-Framework-%EC%A2%85%EB%A5%98-%EC%B4%9D%EC%A0%95%EB%A6%AC>) [Inpa Dev  ‍ :티스토리]

배열 메소드

words.size();

배열은 length 필드를 사용했지만 컬렉션은size() 메서드를 사용합니다.
컬렉션은 인터페이스 기반 구조이기 때문에 메서드 형태로 크기를 제공합니다

배열이 비어있는지 확인하기특정 요소 가져오기

words.get();

배열이 포함하고 있나?

words.contains("Dog");

가변 리스트 종류별 맞게 쓰는 시기

배열의 경우 ArrayList와 Vector에서 값을 불러올 때 빠르게 불러올 수 있습니다
하지만 값을 삽입하거나 제거하는 것은 매우 시간이 걸립니다
그 이유는 아래 이미지에 있습니다.

어떤 요소를 지우거나 삽입하고 싶다면 어떤 걸 먼저 찾고 모든 요소들의 위치를 변경시켜줘야 하기 때문입니다

LinkedList

LinkedList의 경우 전방과 후방을 연결하는 요소들로 양면 연결되어 있습니다
- 따라서 한 요소에서 다른 요소로의 참조가 들어 있으므로 요소들 접근하는 것은 매우 느립니다
- 하지만 만약 어떤 걸 삽입 또는 삭제한다고 했을 때 Array 보다는 쉽습니다

Vector

Vector는 잘 쓰이지 않는데 그 이유는 이 글을 참고해주세요.

Vector는 많은 메소드들이 동기화되어 있습니다
한 클래스 안에 25개의 동기화된 메소드들이 있다고 할 때, 이 동기화된 메소드들 안에서는 한 순간에 오직 하나의 스레드만 코드를 실행시킬 수 있습니다
프로그램은 스레드 하나가 사용하든 15개의 스레드를 사용하든 행동방식이 바뀌면 안되니까 synchronized 가 그 역할을 하는 것입니다

메소드

더하기, 빼기, 원소 변경을 위한 메소드

리스트는 중복을 허용합니다

wordsArrayList.add(2, "Ball");

인덱스를 사용해 원하는 위치에 추가가 가능합니다
리스트 끼리 합치기

List<String> newList = List.of("Yak", "Zebra");

wordsArrayList.addAll(newList);
wordsArrayList.addAll(2, newList); //인덱스 위치 선정도 가능

값 변경하기

wordsArrayList.set(6, "Fish");

값 삭제

wordsArrayList.remove(2); //인덱스 제거 
wordsArrayList.remove("Dog"); //선택한 값 제거

여기에서는 우리에게 선택한 요소를 되돌려주고, ArrayList에서 그 요소를 제거하는 것

ArrayList - 원소들의 반복

public class studyCollections {
   static List<String> words = List.of("Apple", "Bat", "Cat");

    public static void main(String[] args) {
        for (int i = 0; i < words.size(); i++){
          System.out.println(i);
        }

        for (String word : words){
            System.out.println(word);
        }
    }
}

기존에는 이런 방식의 반목문을 사용했었습니다 하지만 리스트에서는 반복문을 사용할 수 있는게 하나 더 있습니다

Iterator wordsIterator = words.iterator();

Iterator 인터페이스를 사용하면 조금 더 간편하게 반복문을 돌릴 수 있게됩니다
접근법에서는 while루프를 사용하면 됩니다

import java.util.Iterator;
import java.util.List;

public class studyCollections {
   static List<String> words = List.of("Apple", "Bat", "Cat");

    public static void main(String[] args) {
        Iterator wordsIterator = words.iterator();

        while (wordsIterator.hasNext()) {
            System.out.println(wordsIterator.next());
        }

    }
}

반복할 요소가 존재하고 wordsIterator가 next를 가지는 한 계속 반복하게 된다
Vector 와 LinkedList에서도 가능

반복문이 여러 개 인 이유

반복문이 3가지가 존재하는 이유는 특정 작업 동안에는 특정 루프를 사용해야 하기 때문입니다
만약 at 로 끝나는 원소만 출력하고 싶다면

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

public class studyCollections {
   static List<String> words = List.of("Apple", "Bat", "Cat");
   static List<String> wordsAl = new ArrayList<>(words);

   public static void main(String[] args) {
        for(String word: words){
            if(word.endsWith("at")){
                System.out.println(word);
            }
        }

    }
}

하지만 만약에 at로 끝나는 단어를 지우려고 하면

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

public class studyCollections {
   static List<String> words = List.of("Apple", "Bat", "Cat");
   static List<String> wordsAl = new ArrayList<>(words);

   public static void main(String[] args) {
        for(String word: wordsAl){
            if(word.endsWith("at")){
                wordsAl.remove(word);
            }
        }
        System.out.println(wordsAl);
    }
}

//결과 : [Apple, Cat]

At로 끝나는 모든 것을 지우려고 했지만 Cat은 삭제되지 않았습니다
- 그 이유는 , 개선된 for 루프를 사용할 때 루프의 중간에서 변경점을 만드는 것은 추천하지 않는 방식 입니다.
  - 왜냐하면 단어를 제거함으로써 반복이 어떻게 진행되느냐가 바뀔 수 있기 때문입니다
  - 이런 상황에서는 iterator 인터페이스를 가지고 하는 것이 추천된다
그래서 만약 특정 단어를 리스트에서 제거하고 싶다면, 반복자가 가장 좋을 것이다

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

public class studyCollections {
   static List<String> words = List.of("Apple", "Bat", "Cat");
   static List<String> wordsAl = new ArrayList<>(words);
   static Iterator<String> iterator = wordsAl.iterator();
    
    
   public static void main(String[] args) {
       while (iterator.hasNext()) {
           if (iterator.next().endsWith("at")) {
               iterator.remove();
           }
       }
       System.out.println(wordsAl);
    }
}

//결과: [Apple]

그냥 루프만 한다고하면 개선된 for 문이 최고이지만 제거한다고 할 때는 iterator 인터페이스가 제일 좋다

리스트 타입 안정성

import java.util.List;

public class studyCollections {
    static List value = List.of("A", 'A', 1, 1.0);

    public static void main(String[] args) {
        System.out.println(value.get(2));
        System.out.println(value.get(2) instanceof Integer);
    }
}

// 1
// true

이 경우 리스트 타입이 뒤죽박죽 섞여있습니다
value.get(2)에서 생성된 것은 정수가 아닌데 True가 나온 이유는 리스트 안에는 기초 요소들을 보관할 수 없기 때문입니다
- true 가 나온 이유는 오토복싱 때문
- 리스트를 만드려 할 때 일어나는 일은 이것들이 다 오토복싱되어 래퍼 클래스가 생성되는 것입니다
- value.get(2)의 경우 오토복싱의 래퍼 클래스가 정수
- 다른 요소들 모두 다 오토복싱되어 자기만의 래퍼 클래스를 갖게 됨
오토복싱을 허용하지 않고 리스트에서 특정한 종류의 값만 갖게 하고 싶다면 일반화가 사용됩니다

일반화

  static List<String> value = List.of("A","Banana");

위의 코드는 리스트에 스트링만 저장되게 설정했습니다
스트링에 정수나 더블을 넣으면 에러가 나게 됩니다

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

public class studyCollections {
    static List<Integer> numbers = List.of(101, 102, 103, 104, 105);
    static List<Integer> numberAl = new ArrayList<>(numbers);

    public static void main(String[] args) {
        System.out.println(numberAl.indexOf(101)); // 존재하지 않으니 0을 반환
        System.out.println(numberAl.remove(101));
    }
}

이렇게 하면 IndexOutOfBoundsException 에러가 나게 됩니다
그 이유는 indexOf() 메소드에서는 오버로드된 메소드가 indexOf()를 위해선 없다는 것
- 객체를 받아들이는 단 한가지 메소드가 있을 뿐
- 무엇이 일어나고 있냐면, 이 101은 정수로 오토복싱되었고 나는 정수를 검색
- 하지만 우리가 remove() 메소드를 보게 되면 두 가지가 있는 데 하나는 객체를 받아들이고, 다른 것은 인덱스를 받아들임
- 그래서 101이라 했을 때 어떤 일이 벌어지냐면 이 메소드를 사용하고 101을 정수로 오토복싱하는 대신에 무엇을 하냐면, 인덱스를 사용하는 remove 메소드로 변경시켜버린 것

배열 정렬 시키기

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

public class studyCollections {
    static List<Integer> numbers = List.of(123, 12, 3, 45);
    static List<Integer> numbersAl = new ArrayList<>(numbers);
    public static void main(String[] args) {
        numbersAl.sort();
    }
}

java: method sort in interface java.util.List<E> cannot be applied to given types;
  required: java.util.Comparator<? super java.lang.Integer>
  found:    no arguments
  reason: actual and formal argument lists differ in length

기존 배열과는 다르게 비교자가 필요하다고 에러가 뜹니다
기본적으로, 리스트 인터페이스 안의 정렬 메소드를 사용하고 싶다면 비교자를 사용해야 합니다
저희는 이걸 쉽게 하는 Collections.sort 메소드를 사용할 것 입니다 -

Collections.sort

Collections.sort(numbersAl);

sort는 Collections안에 존재하는 정적 메소드입니다
여기서 어떤 값이 큰 값인지 정해 줘야 합니다
- 그 정렬은 Comparable 인터페이스를 사용

package collection;

public class Student implements Comparable<Student> {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public String toString() {
        return id + " " + name;
    }

    @Override
    public int compareTo(Student that) {
        return Integer.compare(this.id, that.id);
    }
}

//여기서 this는 현재 객체를 가르키며 that는 외부에서 갖고온 객체를 의미한다

package collection;

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

public class StudentCollectionRunner {
    static List<Student> students = List.of(new Student(1, "Ranga"),
            new Student(100, "Adam"),
            new Student(2, "Eve")
    );

    static List<Student> studentsAl = new ArrayList<>(students);
    public static void main(String[] args) {
        System.out.println(students);

        Collections.sort(studentsAl);
        System.out.println(studentsAl);

    }
}
// [1 Ranga, 100 Adam, 2 Eve]
// [1 Ranga, 2 Eve, 100 Adam]

이렇게 간단하게 정렬이 되는데 만약 뒤집고 싶다면 this와 that 부분만 바꿔주면 됩니다

@Override
public int compareTo(Student that) {
        return Integer.compare(that.id, this.id);
    }
    
// 결과값 
// [1 Ranga, 100 Adam, 2 Eve]
// [100 Adam, 2 Eve, 1 Ranga]

정렬 - C구현을 통해 유연성을 제공

만약 상황에 따라 다르게 구현하고 싶다면 ?

⇒ 비교자를 통해 구현

package collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class AscendingStudentComparator implements Comparator<Student> {

    @Override
    public int compare(Student student1, Student student2) {
        return Integer.compare(student1.getId(), student2.getId());
    }

}

public class StudentCollectionRunner {
    static List<Student> students = List.of(new Student(1, "Ranga"),
            new Student(100, "Adam"),
            new Student(2, "Eve")
    );

    static List<Student> studentsAl = new ArrayList<>(students);

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

        Collections.sort(studentsAl);
        System.out.println("Desc" + studentsAl);

        Collections.sort(studentsAl, new AscendingStudentComparator());
        System.out.println("AscendingStudentComparator " + studentsAl);

    }
}

/* 
출력결과 

[1 Ranga, 100 Adam, 2 Eve]
ASC[100 Adam, 2 Eve, 1 Ranga]
DescendingStudentComparator [1 Ranga, 2 Eve, 100 Adam]

*/

기본형을 이용할 때 아무 인수를 넣지 않았다면 Student 클래스 안에 있는 논리를 쓸 것이고 이렇게 오름차순과 내림차순이 출력 됩니다
사실 Comparator 인터페이스를 여러 번 구현할 수 있습니다
즉, 10가지의 다른 구현을 생성하고 10가지 다른 알고리즘을 통해 학생들을 분류할 수 있게 되는 것
- 이름을 기준으로 정렬, id를 기준으로 정렬 혹은 이름과 id의 결합으로 정렬이 가능합니다
  - 어떠한 결합으로 정렬할지 스스로 정할 수 있고

리스트 요약

컬렉션 인터페이스를 연장한다
- 즉, 이것은 컬렉션 인터페이스에 있는 모든 것을 구현하고 거기에 더해서, 객체의 위치에 상관하는 메서드를 제공한다
- 그래서, 리스트의 끝이나 중간, 어디든지 요소를 삽입할 수 있다

References

Inpa Dev ‍ , JAVA ☕ Wrapper Class - Boxing & UnBoxing
https://inpa.tistory.com/entry/JAVA-%E2%98%95-wrapper-class-Boxing-UnBoxing
TechVidvan, Java Collection Framework Tutorial
https://techvidvan.com/tutorials/java-collection-framework/
Udemy, Best Java Programming Course
https://www.udemy.com/course/best-java-programming/

Java Collection 팁들

중복된 요소들의 리스트를 저장할 수 있는 List
중복을 허용하지 않는 Set
순서가 정해지고 모든 요소가 한번만 처리되는 Queue
키-값 쌍을 저장하는데 쓰이는 Map
Hash
- Collection의 이름에서 Hash를 본다면 순서도 없고 정렬도 되어 있지 않다는 걸 기억!
- 즉, 기본적으로 해시테이블 기반 Collection은 언제나 순서도 정렬도 없다
  - 삽입 순서, 정렬 순서 xxx
Linked
- 요소들이 서로 연결되어 있다는 것
  - 전 요소들과 후 요소들이 연결되어 있음
- 순서는 확실히 유지됨
  - 데이터 정렬 방식을 저장하지 않지만 삽입 순서대로 데이터를 저장
Tree
- 구조에 정렬된 상태로 저장
- 즉, 언제든지 Tree라는 키워드가 보이면 데이터가 정렬된 순서로 저장
- Tree는 기본적으로 데이터가 저장되어 있기 때문에 NavigableSet이나 NavigableMap 구현이 있을 것이다
- 즉, TreeSet은 NavigableSet을 구현하고 TreeMap은 NavigableMap을 구현하는 것
- 트리셋과 트리맵은 하위 셋을 Collection의 종류에 따라 키나 값을 이용해 하위 Set을 만들 수 있는 추가적인 작업들도 있다

[TIL] 인터페이스

dev_Hyeonjoon — Fri, 6 Feb 2026 00:43:26 +0900

인터페이스란

인터페이스는 “이 기능을 제공하겠다”는 약속(계약)

클래스가 구현해야 하는 메서드의 집합(명세)을 정의하는 일종의 추상 자료형입니다.

100% 추상 메서드와 상수만을 포함(Java 8이후로 부터 default 와 static 포함)하며, 다중 구현을 통해 다형성을 극대화하고 클래스 간의 결합도를 낮추는 핵심적인 설계 도구입니다.

인터페이스 구현

public interface GamingConsole {
    public void up();
    public void down();
    public void left();
    public void right();   
}

interface 만 붙이면 됩니다.
인터페이스 안에서는 추상 클래스와 유사하게 그냥 메서드만 선언하고 구현 부분은 비워두면 됩니다
추상 클래스와 유사하게 인터페이스도 그 자체로는 인스턴스를 생성할 수 없으며, 추상 클래스가 상속을 통해 완성되는 것 처럼 인터페이스도 구현부를 만들어주는 클래스에 상속되어야 합니다

public class MarioGame implements GamingConsole {

    @Override
    public void up() {
        System.out.println("Jump");
    }

    @Override
    public void down() {
        System.out.println("Goes into a hole");
    }

    @Override
    public void left() {
        System.out.println("left");
    }

    @Override
    public void right() {
        System.out.println("right");
    }
}

그 후 인터페이스를 상속받는 클래스에서 메소드를 정의하면 됩니다

public class GameRunner {
    public static void main(String[] args) {
        GamingConsole game = new MarioGame();
        game.up();
        game.down();
        game.left();
        game.right();
    }
}

인터페이스의 장점

다중 구현이 가능
클래스 상속과 인터페이스 구현이 동시에 가능

현재 게임 콘솔에 마리오만 있습니다.
- 하지만 현실에서는 게임 콘솔에 한 개의 게임만 있는 경우는 매우 적습니다
- 게임 콘솔에는 보통 여러 개의 게임들이 있는데 이와 유사하게 인터페이스를 사용하려면 여러 개의 게임을 추가할 수 있습니다
- 아래 코드는 체스 게임을 추가 시켰습니다.

public class ChessGame implements GamingConsole{
    @Override
    public void up() {
        System.out.println("Move piece up");
    }

    @Override
    public void down() {
        System.out.println("Move piece down");
    }

    @Override
    public void left() {
        System.out.println("Move piece left");
    }

    @Override
    public void right() {
        System.out.println("Move piece right");
    }
}

public class GameRunner {
    public static void main(String[] args) {
        //GamingConsole game = new MarioGame();

        GamingConsole game = new ChessGame();
        game.up();
        game.down();
        game.left();
        game.right();
    }
}

같은 코드인데 결과만 달라지는걸 확인할 수 있습니다
- 단지 MarioGame() 을 ChessGame()으로 바꿔주기만 했습니다
- 이것을 바로 다형성이라고 부릅니다

또한 클래스 상속과 인터페이스 구현이 동시에 가능한데 아래와 같이 사용할 수 있습니다.

public class ChessGame extends boardGame implements GamingConsole{}

외부에서 정의된 API [인터페이스 활용]

public interface ComplexAlgorithm {
    int complexAlgorithm(int number1, int number2);
}

public class DummyAlgorithm implements ComplexAlgorithm{
    public int complexAlgorithm(int number1, int number2) {
        return number1 + number2;
    }
}

public class Project {
    public static void main(String[] args) {
        ComplexAlgorithm algorithm = new DummyAlgorithm();
        System.out.println(algorithm.complexAlgorithm(10, 20));
    }
}

이 코드가 오류 없이 작동하는 이유는 두 시스템 사이의 통신을 정의하는 ComplexAlgorithm 이라는 인터페이스가 있기 때문입니다.

타입과 구현체가 다른 이유

나중에 ~.complexAlgorithm(10, 20)을 호출하면, 어떤 클래스가 실제로 구현했는지에 따라 동작이 달라지기 때문에 같은 타입(ComplexAlgorithm)으로 묶어서 관리하면서, 실제 동작은 구현체에 따라 바뀌도록 만드는 거죠.

새로운 알고리듬 추가 시키기

public class RealAlgorithm implements ComplexAlgorithm{
    public int complexAlgorithm(int number1, int number2) {
        return number1 * number2;
    }
}

public class Project {
    public static void main(String[] args) {

        ComplexAlgorithm algorithm = new RealAlgorithm();
        System.out.println(algorithm.complexAlgorithm(10, 20));
    }
}

인터페이스끼리의 확장

인터페이스 끼리 확장하는 건 extends를 통해 인터페이스를 상속 시키면 됩니다.
클래스는 Interface2만 구현해도 가능
- 단, Interface2가 상속한 모든 인터페이스의 메서드까지 전부 구현해야 합니다

만약 클래스에 인터페이스를 사용한다면 이렇게 인터페이스에 해당하는 메소드들을 적어줘야합니다
- 만일 부족할 시 에러
만약 많은 메소들 중 골라 쓰고 싶다면? 추상 클래스를 사용하면 됩니다.

추상 클래스를 사용한 인터페이스

추상 클래스는 인터페이스에 정의되어 있는 메소드들의 일부만 구현하는걸 허용합니다
하지만 아무 클래스, 추상 클래스를 연장하는 구상 클래스는 당연히 모든 것을 구현해야 합니다

상수만 가지는 인터페이스

인터페이스는 항상 상수를 가집니다.
여기서 public static final 은 생략해도 상관없습니다.
- 인터페이스에 정의된 모든 멤버에 적용되는 사항이기 때문에 생략 가능하게 지원해주고 컴파일 시 컴파일러가 자동으로 추가해줍니다

default 키워드

인터페이스에 정의된 모든 메서드는 상속받는 클래스에서 구현해줘야한다고 했습니다
하지만 자바 8 이후로는 default를 넣으면 꼭 그렇게 안해도 됩니다

public class Project {
    public static void main(String[] args) {

        interface Test{
            void nothing();
            default void nothing1() {}
        }

        class Class1 implements Test{

            @Override
            public void nothing() {}
        }
        class Class2 implements Test{

            @Override
            public void nothing() {}
        }

    }
}

nothing1 은 어느 클래스에서도 구현하고 있지 않습니다
하지만 컴파일 오류 없이 잘 굴러갑니다
이것이 특히나 유용한 상황은 만약 내가 인터페이스를 제공하지만 또 다른 제 3자가 인터페이스의 구현을 제공할 때입니다.
이런 상황에서는 특히나 기본적 메소드를 가지는 것이 매우 유용한데
- 왜냐면 내가 제 3자의 코드를 망치지 않을 수 있기 때문

인터페이스 vs 추상 클래스

인터페이스 사용시기

두 시스템 사이에서 소통하길 원할 때
두 클래스 아니면 두 부속이 서로 소통하길 바랄 때
그들 사이에 우리가 소통 방식을 정하고 싶을 때
메소드를 정의하고 이 두 개는 앞으로 이렇게 소통할 것이라고 하고 한 쪽에서는 구현을 제공하고 다른 쪽에서는 인터페이스를 소비한다

추상 클래스 사용 시점

높은 단계의 구조를 제공하고 싶어 할 때
구현의 세세한 부분들은 하위 클래스에 맡기고 싶을 때
모든 하위 클래스들이 상위 클래스 구조와 합치하게 만들고 싶을 때
추상 클래스를 사용하려면 무조건 상속을 해야함으로 하위 클래스들과 추상 클래스인 상위 클래스 사이에서 관계가 성립
하지만 이런 관계의 인터페이스는 존재하지 않는다

가장 큰 차이점

인터페이스 안에서는 어떤 것을 폐쇄형으로 선언할 수 없다는 것.
- 어떤 메소드를 폐쇄형이라고 부를 수 없는데 왜냐하면 인터페이스 안에서 모든 것은 개방형이기 때문
- 반면, 추상적 메소드 안에는 아까와 달리 폐쇄형 메소드를 넣을 수 있다
인터페이스 안에는 변수가 안된다
- ↔ 추상 클래스에서는 일반 클래스와 마찬가지로 모든 변수를 가질 수 있다
- 왜냐하면 추상 클래스는 그저 클래스 이기 때문
- 단지 추상 클래스의 메소드 중 일부는 구상적 구현이 없을 수 있을 뿐이다
클래스는 여러 인터페이스를 구현할 수 있다
- 한 클래스는 여러 인터페이스를 구현할 수 있지만 여러 추상적 클래스들을 연장할 수 없다
  - 결국에는 두 다른 클래스에서 상속받을 수 없다는 것으로 요약된다

참고자료

https://zero-zae.tistory.com/219#개요 -1

https://inpa.tistory.com/entry/JAVA-☕-인터페이스Interface의-정석-탄탄하게-개념-정리#자바의_인터페이스

[TIL] 추상 클래스란? 개념, 사용 이유, 예제로 이해하기

dev_Hyeonjoon — Thu, 5 Feb 2026 18:07:46 +0900

추상 클래스

추상 클래스 덕분에 기본 알고리즘 정의가 가능

추상화란?

알고는 있지만 정확하게 표현하기 힘든 것들을 중요한 부분이나 특징점을 잡아 설명하는 것

즉, 클래스들의 중요하고 공통된 성질들을 추출하여 부모(슈퍼) 클래스를 선정하는 개념과 이벤트 발생의 정확한 절차나 방법을 정의하지 않고 대표할 수 있는 표현으로 대체하는 것을 말합니다.
- 객체 지향 프로그래밍의 추상화는 크게 두 가지로 나뉩니다.
  1. 데이터 추상화
    - 객체의 관련 속성만 표시
  2. 제어 추상화
    - 불필요한 세부 정보는 숨김

출처 & 더 자세히 알아보기 : [Inpa Dev ‍ :티스토리]

추상 클래스 사용 이유

자바에서 추상 클래스(Abstract Class)는 공통된 필드와 메서드를 추출하여 상위 클래스에서 정의하고, 하위 클래스에서 이를 상속받아 구체적으로 구현하도록 강제하여 코드의 재사용성, 일관성, 그리고 유지보수성을 높이기 위해 사용합니다. 인스턴스화를 막아 설계도 역할을 하며, 템플릿 메서드 패턴을 통해 구조적이고 유연한 시스템을 구축할 수 있게 합니다.

추상 클래스 문법

추상 클래스는 단순히 abstract 를 붙임으로써 자바 컴파일러에게 추상 클래스라는 것을 알려줍니다

public abstract class AbstractRecipe {
    public void execute(){
        getReady();
        doTheDish();
        cleanup();
    }
    abstract void getReady();
    abstract void doTheDish();
    abstract void cleanup();
}

추상 메소드에서는 메소소드 선언만 작성하고 구현 부분은 작성하지 않습니다.
- 즉, 빈껍데기 상태

추상 메서드를 비워두는 이유

자식 클래스에 따라 어떤 행동을 할지 모르기 때문입니다.
- 즉, 주제만 추상 클래스에서 작성하고 실제 행동은 상속받는 클래스에서 작성하면 되는거죠

추상 클래스 상속 받기

public class Recipe1 extends AbstractRecipe{
}

단순히 extends 키워드를 사용하면 쉽게 상속 받을 수 있습니다

추상 메소드 구현하기

public abstract class AbstractRecipe {
    public String recipeName; //인스턴스 필드
    public void execute(){ //인스턴스 메소드
        getReady();
        doTheDish();
        cleanup();
    }
    //추상 메소드
    abstract void getReady();
    abstract void doTheDish();
    abstract void cleanup();
}

class Recipe1 extends AbstractRecipe{
    @Override
    void getReady(){
        System.out.println("Get the raw materials");
        System.out.println("Get the utensils");
    };

    @Override
    void doTheDish(){
        System.out.println("prepare the dish");
    }

    @Override
    void cleanup(){
        System.out.println("Cleanup the utensils");
    }

    public static void main(String[] args) {
        Recipe1 recipe1 = new Recipe1();
        recipe1.execute();
    }
}

@Overide 는 물론 생략이 가능합니다.
추상 클래스는 일반 클래스와 거의 동일하지만, 인스턴스 생성 불가 + 추상 메서드 강제 구현이라는 설계 제약이 핵심 차이
추상 클래스에도 생성자가 있으며 독립적인 인스턴스 멤버 변수와 메서드도 가질 수 있기 때문입니다.

추상적 클래스는 인스턴스를 만들 수 없다.

AbstractRecipe recipe = new AbstractRecipe();

이렇게 작성을하면 에러가 납니다.
그 이유는 추상 클래스는 상속 구조에서 부모 클래스를 나타내는 역할로만 이용되기 때문입니다.
추상 메소드는 정의도 없고 형태도 없는 메소드를 의미
따라서 구상 클래스가 추상 클래스를 연장하려면 모든 추상 메소드에 대해 구현해야 합니다

추상 클래스 끼리 확장 시키기

abstract class Recipe1 extends AbstractRecipe{
	...
}

추상 클래스끼리 확장하는 방법도 물론 가능합니다
하지만 나중에 자식 클래스가 구상 클래스라면 모든 추상 클래스의 메소드를 구현해야합니다.

추상 클래스는 상태(필드)를 가질 수 있고, 인터페이스는 행동 규약에 집중한다

참고 자료

추상 클래스 -inpa

[TIL] 자바 객체 설계부터 상속까지 (+ toString이 자동 호출되는 이유)

dev_Hyeonjoon — Tue, 3 Feb 2026 20:43:11 +0900

클래스 및 객체 구성 설계

상속하기 전 ‘설계’ 단계는 매우 중요합니다

객체 구성 관계

클래스를 먼저 결정하고 그다음에는 각 클래스가 어떻게 구성될지 계획해야 한다

객체는 멤버 변수의 값으로 정의되는 ‘상태’라는 개념을 가지고 있습니다.
- 해당 객체의 인스턴스를 통해 노출되는 ‘행동’ 이라는 개념 또한 가지고 있습니다.
객체 구성 관계 (객체 컴포지션)

public class Customer {
    private String name;
    private Address address;
}

public class Address {
    private String line1;
    private String city;
    private String zip;
}

두 개의 코드들을 보면 Customer 안에 Address 클래스가 있다는걸 확인하 수 있습니다.
- 이게 바로 객체 구성 관계인데요
- Customer 클래스는 주소 클래스의 인스턴스에 대해 참조 역할을 하는 것
- 그래서 클래스를 디자인할 때 중요한 것 중 하나가 다른 객체의 관계를 살펴보는 것입니다
- 생성자에는 필수적인 것을 넣고 필수적이지 않다면 setter에서 추가 시켜주면 됩니다

클래스를 설계할 때 고려해야 할 세 가지

1. 상태가 어떠한지

현재 시점에서 어떤 변숫값을 가질지 고려

public class MotorBike {
	//상태
	private int speed; //멤버 변수
}

예제에서는 속도 라는 상태밖에 없지만 나중에 색깔이나 브랜드 등 여러가지가 올 수 있습니다

2. 어떤 생성자를 가지는지

어떤 클래스가 되길 원하는지 고려

예제를 보면, 누군가 MotorBike 인스턴스를 직접 만든다고 하면 속도를 5로 지정할 수 있지만 초깃값을 미리 설정해 둘 수 있는 것
생성자에는 꼭 필요한 상태만 올 수 있어야 합니다

public class Fan {
    //상태 (필수O)
    private String make;
    private double radius;
    private String color;

    //상태 (필수X)
    private boolean isOn;
    private byte speed;

    //생성자
    public Fan(String make, double radius, String color){
        this.make = make;
        this.radius = radius;
        this.color = color;
    }
}

3. 행동

객체를 통해 실행하고자 하는 메소드가 어떤게 있을지 고려

public class Fan {
    //상태 (필수O)
    private String make;
    private double radius;
    private String color;

    //상태 (필수X)
    private boolean isOn;
    private byte speed;

    //생성자
    public Fan(String make, double radius, String color){
        this.make = make;
        this.radius = radius;
        this.color = color;
    }

		//메서드
    public String toString(){
       return String.format("make - %s , radius - %f , color - %s , isOn - %b , speed - %d", make, radius, color, isOn, speed);
    }
}

객체를 스트링으로 변환 시키는 메서드
System.out.println 으로 출력 시 구문만 잘 매칭시킨다면 자동으로 출력해줄 것 입니다.

toString이 자동 호출되는 이유 ⁉️

1️⃣Object 타입을 받는 println 오버로드 메서드가 있기 때문에.

public void println(Object x) {
	String s = String.valueOf(x);
    print(s);
}

그리고 여기서 핵심이 String.valueOf(x)

2️⃣ String.valueOf(Object)가 하는 역할

public static StringvalueOf(Object obj) {
		return (obj == null) ? "null" : obj.toString();
}

객체가 null이면 "null"
null 아니면 → obj.toString() 호출

이 시점에서 만든 Fan의 toString()이 실행되는 것

3️⃣ 왜 Fan의 toString이 실행될까?

자바의 핵심 개념 하나:

Fan fan = new Fan(...);

변수 타입: Fan
실제 객체 타입: Fan

println은 Object 기준으로 호출하지만 Fan에서 오버라이딩한 toString()이 실행됨

fan.toString();

이게 암묵적으로 일어나는 거야.

4️⃣ 만약 toString을 안 만들었다면?

클래스명@해시코드

이건 Object 클래스의 기본 toString() 결과

5️⃣ 흐름을 한 줄로 정리하면

System.out.println(fan)
        ↓
println(Object)
        ↓
String.valueOf(fan)
        ↓
fan.toString()
        ↓
Fan 클래스의 toString 실행

6️⃣ 그래서 중요한 포인트 정리

println(fan)이 toString을 직접 부른 건 아님
하지만 Object를 출력할 때 자바가 자동으로 toString 호출
이건 자바 언어 차원의 규칙
그래서 디버깅, 로그, 출력에서 toString()이 엄청 중요함

상태를 변화 시키는 메서드

public class Fan {
    //상태 (필수O)
    private String make;
    private double radius;
    private String color;

    //상태 (필수X)
    private boolean isOn;
    private byte speed;

    //생성자
    public Fan(String make, double radius, String color){
        this.make = make;
        this.radius = radius;
        this.color = color;
    }

    //isOn
    public void isOn(boolean isOn){
        this.isOn = isOn;
    }

    //상태 출력하기
    public String toString(){
       return String.format("make - %s , radius - %f , color - %s , isOn - %b , speed - %d", make, radius, color, isOn, speed);
    }
}

public class FanRunner {
    public static void main(String[] args) {
        Fan fan = new Fan("Manufacturer 1", 0.34567, "GREEN");
        fan.isOn(true);

        System.out.println(fan);
    }
}

이렇게 하면 상태를 변화시킬 수 있습니다.
하지만 사용자 친화적이지는 않으니 다르게 코드를 작성해보면
- 그 이유는 사용자가 팬을 키려고 속도를 입력하지 않을테니까요

public class Fan {
    //상태 (필수O)
    private String make;
    private double radius;
    private String color;

    //상태 (필수X)
    private boolean isOn;
    private byte speed;

    //생성자
    public Fan(String make, double radius, String color){
        this.make = make;
        this.radius = radius;
        this.color = color;
    }

    //isOn
    public void isOn(boolean isOn){
        this.isOn = isOn;
    }

    public void switchOn(){
        this.isOn = true;
    }

    public void switchOff() {
        this.isOn = false;
    }
    //상태 출력하기
    public String toString(){
       return String.format("make - %s , radius - %f , color - %s , isOn - %b , speed - %d", make, radius, color, isOn, speed);
    }
}

public class FanRunner {
    public static void main(String[] args) {
        Fan fan = new Fan("Manufacturer 1", 0.34567, "GREEN");
        fan.switchOn();
        System.out.println(fan);
        fan.switchOff();
        System.out.println(fan);
    }
}

더 사용자 친화적이게 됐습니다
계속 고민해야할 것 중 하나는 이렇게 언제나 사용자 입장에서 고민해야 한다는 점

전형적으로 객체에 대해 연관 지어 생각하는 부분은 getter와 setter인데 그렇게 연관 짓는 것은 좋지 않다 항상 사용자가 객체에 대해 어떤 생각할지, 어떤 메소드가 나의 객체를 사용하기 쉽게 할지 생각해야한다

상속

상속을 하는 이유

중복을 피하기 위해서

public class Person {
    private String name;
    private String email;
    private String phoneNumber;

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
}

public class Student {
    public class Person {
        private String name;
        private String email;
        private String phoneNumber;

        private String college;
        private int year;

        public String getEmail() {
            return email;
        }

        public void setEmail(String email) {
            this.email = email;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getPhoneNumber() {
            return phoneNumber;
        }

        public void setPhoneNumber(String phoneNumber) {
            this.phoneNumber = phoneNumber;
        }

        public String getCollege() {
            return college;
        }

        public void setCollege(String college) {
            this.college = college;
        }

        public int getYear() {
            return year;
        }

        public void setYear(int year) {
            this.year = year;
        }
    }

}

이렇게 ‘Person’ 과 ‘Student’ 클래스가 각각 있을 때 서로 중복되는 코드가 매우 많습니다
- 이렇게 할 때 생길 수 있는 문제는 나중에 이메일을 바꾼다고 했을 때 클래스 두 개를 각각 업데이트 해야한다는 단점
⇒ 이를 상속을 통한 해결!

우리가 무의식으로 상속하고 있던 것.

형광펜 칠해진 사진을 보면 우리가 메소드를 정의한 적이 없는데 사용할 수 있는 메서들을 확인할 수 있습니다
이는 Java의 기능으로써 아무것도 확장하지 않았을 경우 모든 클래스가 Object 클래스를 확장하였기 때문입니다.

public class Person extends Object
//자바는 암묵적으로 Obejct클래스를 확장!

Object 객체는 사진에서 맛보기로 확인할 수 있습니다.
이 객체가 클래스 체계의 근본이며 “**모든 다른 클래스가 다른 객체나 클래스로부터 상속을 해야만 한다”**는 말이 적혀 있습니다
- 배열을 포함한 모든 객체는 클래스의 메소드를 적용

오버라이딩

모든 클래스는 Object 클래스의 하위 클래스
하위 클래스에서 상위 클래스에서 제공하는 메서드를 덮어씌울 수 있다

public class StudentRunner {
    public static void main(String[] args) {
        Person person = new Person();
        String value = person.toString();
        
        System.out.println(value);
        System.out.println(person);

    }
}

현재의 toString의 출력값은 사진과 같이 나오는데 그 이유는 Object 클래스 떄문

저는 toString이 이렇게 '@' 대신 '#' 으로 출력되길 원합니다
- 똑같은 메소드 이름으로 덮어씌우는 걸 메소드 오버라이딩이라고 합니다

public class Person extends Object{
    private String name;
    private String email;
    private String phoneNumber;

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    public String toString() {
        return getClass().getName() + "#" + Integer.toHexString(hashCode());
    }
}

@ → # 으로 바뀐 걸 확인할 수 있습니다
- 왜냐하면 Person 클래스에서 Object 클래스에 의해 제공되는 적용을 덮어씌운 것이기 때문

상속의 작동 순서

하위 클래스에서 생성자를 만들 때마다 첫번째 줄에서는 자동으로 상위 생성자가 발동

import java.math.BigDecimal;

public class EmployeeRunner {
    public static void main(String[] args) {
        Employee employee = new Employee();
        //상속 설정
        employee.setEmail("guswnsj0112@naver.com");
        employee.setPhoneNumber("013-38929890230");

        //하위 클래스
        employee.setEmploy("jonny");
        employee.setEmployeeGrade("A");
        employee.setTitle("FAANG!!");

        System.out.println(employee);
    }
}

public class Employee extends Person{
    private String title;
    private String employ;
    private String employeeGrade;
    private BigDecimal salary;

    public Employee() {
		    //super() 함축적으로 포함됨
        System.out.println("Employee Constructor");
    }
   
   //중략
}

Employee 생성자를 호출 → Employee 생성자를 부름
Employee 생성자는 함축적으로 super를 호출하게 됨
자바컴파일러는 자동으로 상위 클래스인 Person을 호출

상위 클래스에 데이터 넘겨주기

public Person(String name) {
        System.out.println("Person Constructor");
        this.name = name;
 }

만약 상위 클래스에 이름이 필요하다고 생성자에 적는다면 하위 클래스에서도 당연히 이름이 필요할 것입니다
- 이는 간단히 super안에 인수를 넣어줌으로써 해결 가능합니다

public Employee(String name, String title) {
        super(name);
        System.out.println("Employee Constructor");
        this.title = title;
    }

Employee employee = new Employee("Ranga", "Programmer Analyst");

상속을 확인하는 instanceof

instanceof는 다형성 설계가 잘못됐을 때의 냄새(code smell) 일 수 있다

이렇게 boolean 값으로 반환 됩니다
현재 객체가 특정 클래스의 인스턴스인지 알 수 있게 해줍니디

[TIL] JAVA 배열에 관해서

dev_Hyeonjoon — Fri, 30 Jan 2026 09:52:53 +0900

배열이 필요한 이유

int mark1 = 100;
int mark2 = 75;
int mark3 = 60;
int sum = mark1 + mark2 + mark3;

만약 위에 있는 코드처럼 과목 점수를 일일이 적는다면 매우 귀찮을 것입니다.
- 심지어 과목이 추가 된다면 또 다시 변수를 선언하고 sum변수를 수정해야한다는 단점이 있습니다.

→ 이 경우 배열을 사용한다면 매우 편해질 것 입니다.

배열에 관해서

배열은 같은 타입의 여러 값을 저장할 수 있습니다.
배열을 통해 같은 타입의 요소들을 묶을 수 있다 !

예를 들어 아래와 같이 코드를 작성한다면

int [] marks = {75, 60, 56};
//세 가지 요소를 가지는 배열 마크를 생성했음

세 가지의 숫자를 한 번에 저장할 수 있게 됩니다.
이 배열은 점수 배열이며 대괄호 뒤로 마크 값이 들어오게 됩니다.

배열 반복문

배열을 정의하고 그 안에 요소를 구성했다면 구성 요소를 차례대로 반복할 수 있는 반복문을 설정할 수 있습니다.

향상된 for 문 (Enhanced For Loop)

또는 for-each라고도 불리우는

public class Main {
    public static void main(String[] args) {
        int [] marks = { 75, 60, 65} ;
        int sum = 0;
        for (int mark:marks){
            sum = sum + mark;
        }
    }
}

mark는 배열 요소를 하나씩 복사한 지역 변수
mark 값을 바꿔도 marks 배열 자체는 바뀌지 않음 ❗
이 코드가 편한 이유 중 하나는 구성 요소가 얼마나 있는지 상관없이 코드를 사용할 수 있기 때문입니다.

배열 선언

int [] 배열이름 = new int[요소 개수];

int [] mark = new int[5];

→ 5개의 값을 가지는 정수 배열을 선언

왼쪽은 배열 타입을 설정하고 오른쪽은 배열의 크기를 설정합니다

⚠️배열의 값을 설정하지 않으면 정수일 때 디폴트 값은 항상 0

❗int[] marks = new int[];

와 같이 배열의 규모를 알 수 없는 코드를 작성 시 오류를 일으킨다
배열 사이즈는 항상 오른쪽에 작성해야 함 !

❗배열은 항상 명시된 타입만 가질 수 있다

int를 작성해 놓고 float라고 적을 시 오류를 일으킴

배열 간단하게 적는 방법

int[] marks = {97, 98, 100};
Student student = new Student("Ranga", marks);

지금까지 써왔던 이런 방식 말고 더 간단하게 줄이고 싶다면 아래와 같이 적으면 됩니다.

Student student = new Student("Ranga", new int[] {97,98,100});

좋긴 한데 API로 치면 좋은 건 아닙니다.
- 그 이유는 이걸 사용하고자 하는 사람들이 똑같이 따라 쳐야만 사용할 수 있기 때문

배열 값 추출하기

배열의 인덱스를 사용

❗배열의 인덱스는 항상 0으로 시작

배열[인덱스번호]

mark[0]

mark 배열의 인덱스 0인 값을 추출

배열 값 변경하기

배열[인덱스번호] = 변경할값
amrk[0] = 10;

배열 길이

배열.length

배열 초기값

int[] marks = new int[5];
double[] values = new double[5];
boolean[] test = new boolean[5];

모든 정수 타입의 배열은 초기 값 0
모든 double타입의 초기 값 0.0
모든 boolean타입의 초기 값 false

객체 요소로 하는 배열

class Person {}
Person[] person = new Person[5]

객체 배열을 만들 경우 초기 값 null

배열 전체를 출력하는 법

System.out.println(배열);

⚠️배열의 요소가 아닌 저장 경로가 출력 됩니다.

저희가 원하는 건 요소이기 때문에 다른 방법을 사용해서 출력해야 합니다

정적 메소드를 사용하여 출력하기

System.out.println(Arrays.toString(배열));

배열 초기 값 설정하기

정적 메소드를 사용

Arrays.fill(배열,초기값)

배열이 값이 동등한지

정적 메소드를 사용

Arrays.equals(배열1, 배열2);

boolean 값으로 출력됩니다.
배열의 길이가 다르거나 매칭되는 요소가 없을 때 false
길이가 같고 AND 각 요소가 모두 매칭될 때 true

배열 정렬하기

Arrays.sort(배열);

가변 매개 변수

가변 매개 변수가 필요한 이유

가변 매개 변수는 아래와 같이 얼마나 인수가 들어올지 모르기 때문에 사용됩니다.

Student student = new Student("Ranga", 97,98,100);
Student student1 = new Student("Adam", 97,98);
Student student2 = new Student("Eve", 97,98,90,98);

정해진 매개 변수 없이 사용자의 입력을 받고 싶다면?
⇒ 가변 매개 변수 사용

가변 매개 변수 사용법

public class Student {
    private String name;
    private int[] marks; //배열 유지해도 상관없다

    public Student (String name, int... marks){
        this.name = name;
        this.marks = marks;
    } 
  }

가변적 매개변수는 매개변수 앞 …만 붙여주면 됩니다
여기에 넣는 모든 값이 리스트가 됩니다
- 그리고 이러한 리스트들은 배열이 됩니다
  - [리스트와 배열의 차이](https://velog.io/@enamu/배열Array과-리스트List#:~:text=배열과 리스트의 차이점,-메모리 할당: 배열&text=크기: 배열은 크기가,삽입과 삭제가 빠르다.)
❗주의!
- 가변 매개변수는 항상 마지막이여야 합니다
```
void print (int... value, String name){} //에러
```

배열 추가 및 삭제

ArrayList를 사용하지 않는 방법은 다소 까다로울 수 있습니다

배열 추가

배열이 한번 생성되고 나면 사이즈가 크기가 정해지기 때문에 기존 배열에서 추가될 수 없습니다
따라서 유일한 방법은 배열 자체를 복사 후 새로 만들어야 하는 것
- 이런식으로 배열의 사이즈를 늘린 후 요소 자리에 위에 있는 값을 복사해 오고 배열의 마지막 값만 넣어주면 됩니다
  - 이게 유일하게 배열에 요소를 추가하는 방식
int[] marks = {12,34, 45}; int [] newMarks = new int[marks.length + 1];

배열 삭제

배열 추가하는 방법과 마찬가지로 크기를 수정해줘야 합니다

int [] newMarksWithOneDeleted = new int[marks.length - 1];

이렇게 한 후 똑같이 배열 요소를 넣어주면 끝

ArrayList를 활용해 더 쉽게 추가 및 삭제하기

ArrayList : 배열을 추가, 삭제하기 편해지는 컬렉션 프레임워크

ArrayList arrayList = new ArrayList();
arrayList.add("Apple");
arrayList.add("Cat");
System.out.println(arrayList);

arrayList.remove("Cat");
System.out.println(arrayList);

추가 및 삭제가 매우 간편해짐
그리고 원본 배열을 수정할 수 있다는 장점이 있습니다.
하지만 위에 있는 코드에서는 타입을 설정하지 않았기 때문에 문자와 숫자가 섞여버릴 수 도 있습니다.

ArrayList arrayList = new ArrayList();
arrayList.add("Apple");
arrayList.add(1);
System.out.println(arrayList);
//에러 x

따라서 타입을 명시해주는게 좋습니다.
- 제네릭 기능을 사용해 타입을 지정

ArrayList<String> items = new ArrayList<String>();

// Java 7 이상부터는 다이아몬드 연산자 사용 가능
ArrayList<String> items = new ArrayList<>();

[TIL] Wrapper클래스

dev_Hyeonjoon — Wed, 28 Jan 2026 22:51:29 +0900

Wrapper클래스

값들을 싸고 있는 것과 같다고 하여 Wrapper Class 라고 부릅니다.

기본타입(primitive type) 래퍼클래스(wrapper class)

byte	Byte
char	Character
int	Integer
float	Float
double	Double
boolean	Boolean
long	Long
short	Short

char, int의 래퍼 클래스는 각각 Integer와 Character이고 나머지는 대문자로 시작된다는 점 외 이름은 동일

Wrapper 클래스가 필요한 이유

기본 값이 있는데도 불구하고 래퍼 클래스가 필요한 이유는 아래 있는 두 가지의 이유와 같습니다

래퍼 클래스는 추가적인 옵션을 다양하게 제공해주기 때문
- 예를 들어
```
Integer hundred = Integer.valueOf("100");
Boolean value = Boolean.valueOf("True");

//valueOf = 객체를 “클래스에 따라 변환”하는 데 사용되는 함수입니다
```
- 스트링에서 boolean 값 또는 integer 값을 출력할 경우 래퍼 클래스를 이용해 실행할 수 있습니다
래퍼 클래스는 유틸리티 메소드를 제공
- float가 있고 이 특정 float의 정숫값을 출력하려고 할 때 intValue 메서드를 사용할 수 있습니다
- 추가로, 만약 2진법으로 이루어진 스트링을 전환하고 싶을 때,
  - 다시, 2진법 형태의 스트링이 정수를 나타내도록 전환시키고 싶은 경우, 래퍼 클래스에는 이런 것들을 실행할 수 있는 많은 유틸리티 메소드가 있다
- 또 래퍼 클래스의 추가적인 기능으로는 기본 값들을 컬렉션에 저장시킬 수 있습니다
  - 컬렉션에 저장하려면 추가 대상이 꼭 객체여야하고 래퍼 클래스는 이 기본값에 객체를 제공하는 역할을 해야합니다
//Conversion Float floatWrapper = Float.valueOf(57.0f); int floatToInt = floatWrapper.intValue(); // 57 Integer seven = Integer.valueOf("111", 2); Integer.toString(seven,2);

래퍼 클래스의 생성자로 정수 생성하기

Integer integer = new Integer(5);
Integer integer1 = new Integer(5);

//Integer(int) 생성자는 Java 9부터 deprecated 되었으며, 사용이 권장되지 않는다.

래퍼 클래스의 정적 메서드로 정수 생성하기

Integer integer = Integer.valueOf(5);
Integer integer1 = Integer.valueOf(5);

각각의 래퍼 클래스는 모두 정적 메소드를 갖고 있는데

Integer integer = Integer.valueOf("54654");

이런식으로 값으로 스트링을 넣을 수 있습니다

둘 중 어떤 것이 좋을까?

Integer i1 = new Integer(5);
Integer i2 = new Integer(5);
Integer i3 = Integer.valueOf(5);
Integer i4 = Integer.valueOf(5);

i1== i2
//false ❗ (캐시 범위 밖)

i3 == i4 // true ✅ (캐시 범위 안)

//Integer.valueOf()는 -128~127 범위의 값에 대해 동일한 객체를 재사용하므로, 이 범위 내에서는 == 비교 시 true가 나올 수 있다.

integer 참조 타입
i1 참조하는 값
참조 변수에 대해 {==}는 값을 비교하지 않습니다
- 값의 메모리 주소를 비교
스트링 클래스와 동일하게 모든 래퍼 클래스 또한 불변성을 갖습니다
- 그 말은 값이 지정된 이후에는 변경될 수 없다는 말
여기 보면 i1에 대해 새로운 정수 변수가 생성되었고, i2에 대해 또 다른 정수 변수가 생성이 됐는데 값은 같은 숫자를 가지고 있는 것
Integer.valueOf()의 기능은 존재하는 객체 중 같은 값을 가지는 게 있는지 체크한 후 있다면 재사용합니다.
- 만약 다른 객체에서 동일한 값을 찾는다면, 그 값을 다시 사용하고 동일한 결과를 출력
- 해당 객체의 값이 변하는 것이 아니기 때문에 괜찮다
- 정수 → 불변성 따라서 괜찮
그렇기 때문에 두 개의 다른 참조 값이 하나의 객체를 가리키고 있다고 해도 전혀 문제가 되지 않습니다.

[TIL] String 클래스

dev_Hyeonjoon — Wed, 28 Jan 2026 22:02:33 +0900

스트링이라고 불리는 클래스 인스턴스

"test"

여기서 test는 인스턴스입니다. 그렇다면 어떤 클래스의 인스턴스일까요
- 자바에서 글씨는 모두 String Class에 의해 출력됩니다.
  - 이 때 큰 따옴표(””)와 함께 사용됩니다.
만약 저장을 하고 싶다면

String str = "test"

와 같이 사용할 수 있습니다.
→ test에 대한 인스턴스를 생성하고 래퍼런스를 str에 저장

String 리터럴은 Heap 영역 내부의 String Constant Pool에 저장된다. 같은 문자열 리터럴은 하나의 객체를 공유한다.

String a = "test";
String b = "test";

a == b // true

String a = new String("test");
String b = new String("test");

a == b // false

스트링 인스턴스가 특별한 이유

BigDecimal bd = new BigDecimal("1.0") 이와 같이 다른 객체들은 생성자(constructor)가 있어야 만들 수 있었습니다
그러나 str은 생성자가 없어도 만들 수 있고 생성자를 사용해 만들 수도 있다

생성자로 스트링 만드는법

String str = new String("Test")

우리는 test를 스트링 리터럴 이라고 부릅니다.

스트링의 인덱스

⚠️스트링은 무조건 0부터 시작합니다!

charAt (한 문자 자르기)

만약 어떤 하나의 문자를 출력하고 싶다면 charAt을 사용

String str = "Test"
str.charAt(0) // T
str.charAt(2) // s

substring (여러 문자 잘라내기)

String biggerString = "This is a lot of text"

서브 스트링
- 문자열에서 특정 부분을 잘라내어 새로운 문자열을 생성하는 메서드
- 서브 스트링 메서드는 이 문자의 인덱스를 받는다
- 해야될 것은 문자의 인덱스 번호를 넣으면 된다

biggerString.substring(5)
// "is a lot of text"

시작과 끝도 설정하기

biggerString.substring(5, 13)
// "is a lot"

중요한 건 시작은 포함이고 끝은 포함하지 않는다는 것
- 즉, 범위는 5 ~ 12까지

lastIndexOf (마지막에 있는 단어 찾기)

string.lastIndexOf('i');

contains (글자가 있는지 확인하기)

string.contains("text")

text 라는 단어가 존재하는지 찾고자 할 때 ‘text’를 값으로 입력하면 된다

startWith (특정 단어로 시작하는지 확인하기)

string.startsWith("This")

// true or false

endsWith (특정 단어로 끝나는지 확인하기)

string.endsWith("text")

// true or false

isEmpty (비어 있는지 확인하기)

string.isEmpty()

// true or false

equals(글자가 똑같은지 확인하기)

"true".equals("true")

// true

대소문자가 다르게 인식됨

equalsIgnoreCase (대소문자 상관없이 글자가 똑같은지 확인하기)

"true".equalsIgnoreCase("TRUE") // true

// true

스트링 수정

스트링은 불변의 객체로 값을 수정할 수 없습니다

사진과 같이 문자를 합쳤음에도 str에서는 반영되지 않았습니다
그냥 다른 스트링 값을 준 것!

이런식으로 변수가 달라져야 저장
- 즉, 우리가 스트링을 변경하려고 할 때 우리가 하는 것은 특정 스트링을 변경하는 것이 아닙니다
- string.concat을 사용하면 새로운 스트링이 만들어지며 원래의 스트링은 영향을 받지 않고 그대로 남아 있게 됩니다.
⇒ 이런 스트링의 특징을 불변성이라고 부릅니다
스트링 클래스가 특정 값으로 한 번 생성된 이후에는 그 특정 값은 절대 바꿀 수 없습니다
- 스트링에 메서드를 실행 시 새로운 스트링이 만들어지는 것.

toUpperCase (대문자로)

string.toUpperCase()

toLowerCase (소문자로)

string.toLowerCase()

trim (앞 뒤 간격 제거)

string.trim()

스트링과 숫자

1 + 2 // 3
"1" + "2" //"12"
"1" + 2 // "12"
"1" + 23 // "123"

1 + 2+ "3" // "33"
"1" + 2 + 3 // "123"

이런 결과가 나오는 이유는 자바는 문자열 + 숫자는 = 문자열이 됩니다
1 + 2+ “3” 과 “1” + 2 + 3의 차이점은 자바는 왼 → 오 으로 해석하기 때문
- 1+2 = 3 이 되고 3 + “3” = “33”이 된다

예제

Sytem.out.println("Value is " + 20)
Sytem.out.println("Value is " + 20 + 20)
Sytem.out.println("Value is " + (20+20))

// Value is 20
// Value is 2020
// Value is 40

괄호가 가장 먼저 연산되기 때문에 마지막은 40이 된다

join (문자 합치기)

String.join(",", "2", "3", "4")

// "2,3,4"

String.join(",", "A", "B", "4")

첫 번째 문자는 어떤 문자를 합칠 것인지, 그리고 나머지는 뒤로 덧붙이고 싶은 숫자들이나 문자들

replace (문자열 대체하기)

"abcd".replace('a', 'z');

//zbcd

String 대체

StringBuffer

자바에서 스트링을 생성할 수 있는 또 다른 클래스
수정이 가능하다

StringBuffer sb = new StringBuffer("TEst");

수정이 되고 결합이 많은 경우 String보단 StringBuffer가 더 유용

StringBuilder

StringBuffer와 유사하지만 동기화를 제공하지 않아 단일 스레드 환경에서 더 빠르다.

스트링 버퍼는 동기화된 클래스인데
- 이 말은, 멀티 스레딩이 가능한 클래스라는 말
  - 멀티 스레딩이 가능하다는 것은 그것으로 인한 패널티 또한 있다는 뜻
- 싱글 스레드 시나리오의 경우 멀티 스레딩을 할 때 가지는 복잡한 사항들이 없는데 스트링 버퍼의 경우 속도가 매우 느려질 수 있고 그럴 때 사용하는 게 바로 스트링 빌더

[TIL]자바 프로그래밍의 참조 자료형

dev_Hyeonjoon — Wed, 28 Jan 2026 16:23:07 +0900

참조 타입이란

자바에서 class로 정의된 타입과 배열 타입은 모두 참조 타입이며, new 연산자를 통해 생성된 객체는 Heap 영역에 저장된다.

참조 변수

class Planet {
}
Planet jupiter = new Planet();

위에서 본 것 처럼 Planet이라는 인스턴스를 사용해 jupiter에 저장할 때 jupiter는 참조변수가 됩니다

참조 변수 메모리의 저장방식

class Animal {
	int id;
	Animal(int id) {
		this.id = id;
	}
}

Animal dog = new Animal(12);
Animal cat = new Animal(15);

새로운 객체가 생성될 때마다 이들은 모두 Heap이라고 하는 곳에 저장됩니다
자바 프로그램이 실행될 때 두 가지 종류의 메모리가 있는데 그 중 하나는 ‘Stack’이고 다른 하나는 ‘Heap’
- 모든 새로운 객체는 Heap에 저장되는데, 이것은 자바 프로그램에서 공유되는 가장 기본적인 저장소
즉, 모든 객체는 heap에 저장
- Heap도 여러개의 저장소로 나눠짐
→ Animal(12)는 이곳에 저장됨
기본 변수, 메소드에 로컬 변수를 생성하면 Stack에 저장

dog는 Animal12라는 값을 갖고 있는데 Animal12는 Heap에서 1A에 위치 따라서 Stack에서는 value에 1A를 갖게 되는 것
그래서 이처럼 ‘dog’에 대한 값은 객체가 저장된 경로의 참조 정보로 Stack에 저장되는 것
이게 가장 중요한 개념이고 그렇기 때문에 이걸 참조 변수라고 부름
- Dog는 1A라고 하는 참조 경로를 가지고 있기 때문에 참조 변수라고 부르는 것

cat도 마찬가지

만약 null이라면

아무것도 생성한 것이 없기 때문에 값은 null이 됩니다.
- 간단하게 설명하면 저장 경로가 없다는 뜻

엑셀에서 이와 같이 표현할 수 있습니다
null은 참조 타입 변수이지만, 어떤 객체도 참조하지 않는 상태 를 의미
하지만 만약

=> 이와 같이 입력한다면 1c로 연결

Quiz. 아래처럼 작성했을 때 결과값은❓

nothing.id = 10

cat.id

⇒ 10

nothing → 1C를 의미 → 글로벌의 1C에 있는 객체의 값이 변경

마찬가지로 cat이라는 이름을 가진 변수도 같은 것을 의미하고 있기 때문에 값이 10으로 바뀌게 됩니다
만약 nothing = dog라고 적는다면 1C의 값이 기존 1A가 있던 곳에 올 것

기본 변수와의 차이점

int j = i; 라고 한다면

이렇게 독립적인 값을 갖습니다
그리고 만약에 j의 값을 변경한다고 해도 변경되는 건 오직 j의 값

하지만 참조 변수의 경우 저장하는 것이 값이 아닌 경로이기 때문에 참조 변수를 복사할 때에는 실제 객체가 저장된 경로가 복사됩니다

이렇게 참조가 된다고 했을 때

cat == dog
//false

cat == ref
//true

dog == dog2
//false

출력 값이 false인 이유는 같은 값을 가지고 있지만, 그것과는 무관하게 어떤 걸 참조로 갖는지가 중요
- 여기서 이 두 개가 나타내는 객체가 다르므로 dog와 dog2가 일치하지 않는다고 본다
- Heap에서 나타내는 객체가 다르다
- 보면 12로 같은 값을 갖지만, Heap에 있는 저장 경로가 1A와 1E로 다르다
- Heap에는 다른 객체로 저장되어 있는 것
- 중요한 개념은 연산자 {==}를 통해 참조 변수를 비교할 때
  - ⇒ 비교하는 것은 값이 아니라 객체이다
  - 나타내는 객체가 다르다면 값이 같아도 같은걸로 인식하지 않는다
- 이와 달리 {==} 연산에 대해 기본 변수일 경우
  - 값을 비교한다

[전역 후] 그동안 내가 군 생활에서 이뤘던 것과 못 이뤘던 것들

dev_Hyeonjoon — Tue, 13 Jan 2026 10:26:56 +0900

쉬어갑니다 종료.

2025년11월08일에 잠시 쉬어갑니다....를 올린 후 엄청 일들을 처리하느라 제대로 공부도 못 하고 깃허브 잔디도 신경을 못 썼습니다. 하지만 막상 논건 아니고 그냥 꾸준히 다른 공부를 하며 지냈습니다.

군 생활에 세웠던 목표

1. 개인 프로젝트 만들어서 배포
2. 운동으로 체중 감량
3. 창업 대회 나가기
4. 토플 성적 90+ 이상
5. 군e러닝 1,2학기 A+ 받기
6. 해외파병 경험하기
7. 특급전사 달성하기
8. 컴활 1급 자격 따기
9. 1달에 1번 책 읽기
10. SQLD 자격증 따기

이룬 것들 ✅

개인 프로젝트 만들어서 배포
- 물론 현재는 거의다 까먹었기도 하고 GPT와 Gemini 힘이 많이 들어가서 만족하지는 않습니다..
군e러닝 1,2학기 A+받기
- 덕분에 학점이 올라갔습니다
- 1학기는 전역 전에 시험봤고 2학기에는 전역 후 기말고사
운동으로 체중 감량
- 전역 후 다시 살이 쪄서.. 얘먜..
컴활 1급 자격 따기 (50%)
- 필기는 전역 전에 합격했으나 실기는 내일인 26.01.14에 봅니다
- (합격 후기로 돌아왔으면 좋겠네요..)
1달에 1번 책 읽기
- 원래 사회에서 잘 안읽던 책인데 군대에서 습관을 들여놔서 사회에서도 조금씩 읽어나가고 있습니다
SQLD 자격증 따기

못 이룬 것들

창업 대회 나가기
- 전역 하는 시기가 대회 중으로써 나가기 힘들다고 판단해서 못 나가게 됐습니다…
해외파병 경험하기
- 한 번에 기회가 찾아왔는데 전역일이 1달 빨라서 탈락..
토플 성적 90+ 이상
- 프로젝트 만드랴 컴활 따랴 KCU공부 하랴 해서 공부 실패..
특급전사 달성
- 체력도 있었지만 도중에 부상을 당해버려서... (모두 군 생활 중 조심하세요!)

리뷰

1년 6개월
- 길다고 하면 길고 짧다고 하면 짧은 기간 동안 나태해지기 싫어서 스스로 갈아넣으면서 열심히 살았던 것 같습니다. 남들 놀 때 맨날 사지방에서 공부하고 연등 신청해서 책 읽고 .. 모두가 열심히 산다고 했었지만 지금와서 보면 약간의 ‘하는 척’이 섞여있던 것 같습니다. 1달 정도 공부를 쉬니 코딩 공부도 거의 까먹고 전역 후 군대에서 공부했던 습관은 다시 리셋되어 놀고 있는 저를 스스로 다그친적이 한 두번이 아닙니다. 하지만 군대에서 있었던 일들은 제게 너무 소중합니다. 남들과는 달리 저는 군대에서 배운 게 너무 많습니다. 후임과 선임을 대하는 방법이나 저의 한계를 알고 그 끝까지 해보는 능력 등… 저는 대학교 1학년을 마치고 5월 달에 입대했습니다. 하지만 "이것보다 빨리 군대에 갔었더라면 저는 정신을 빨리 차리고 더 열심히 모든 걸 해봤지 않을까..?" 그리고 "겁 먹더라도 조금은 더 열심히 해보자!" 라는 마인드가 생겼을 것 같아서 그게 가장 아쉬웠습니다…
저는 이제 컴활 시험이 끝난 후 자바와 리액트 복습으로 다시 공부할 예정입니다
- 전과가 만약 성공한다면 더욱 더 전공지식을 블로그에 올릴게요 :3

잠시 쉬어갑니다....

dev_Hyeonjoon — Sat, 8 Nov 2025 23:46:29 +0900

Java TIL을 쉬는 이유

현재 2025년 11월 8일 기준으로 전역까지 약 19일 남은 말년 병장입니다.
요즘은 컴퓨터활용능력 1급(컴활 1급) 필기 시험 준비에 집중하고 있습니다.
원래는 자바 공부와 병행했지만, 11월 10일 시험을 앞두고 부담이 커지면서 잠시 코딩을 쉬기로 했습니다.
말년 휴가도 겸사겸사 조금은 쉬어가려구요.
(금방 돌아오겠습니다!)

시간을 잘 나누면 되지 않나?

그럴 수도 있었겠지만, 지금은 우선순위가 확실합니다.

1순위: 어깨 및 허리 재활 운동
2순위: 군e러닝(KCU)
3순위: 컴활 1급 필기
4순위: 운전면허 시험 (말출 활용 예정)

이 세 가지를 병행하기엔 하루 24시간이 너무 짧네요

추가) Java를 공부하는 이유

저는 명지대학교 경영정보학과 2학년 군 휴학생입니다.
2023년, IT 창업 동아리에서 직접 서비스를 만들어보며 프론트엔드 개발에 흥미를 느꼈고
그 즐거움이 이어져 군대에서도 꾸준히 코딩을 이어져왔습니다

하지만 2025년 중반쯤, CSS 스트레스가 너무 심해져 방향을 바꾸기로 했습니다
“응용소프트웨어학과로 전과할 예정이니 자바를 배우자.”
이 선택이 결국 제 커리어의 중요한 전환점이 되리라 믿어요.
자바는 백엔드, 안드로이드 등 확장성도 크니까요

지금은 잠시 쉬지만,
이 휴식이 곧 더 단단한 성장으로 이어질 겁니다.

[WIL] 자바 반복문 그리고 아쉬운 부분

dev_Hyeonjoon — Sun, 2 Nov 2025 20:09:42 +0900

1. 이번 주 학습 주제

이번 주에는 반복문 수강

2. 배운 점 요약

Do While과 While의 차이점

반복문을 써야 할 때

Continue 와 Break

3. 삽질(실수) & 해결 과정

어렵지 않아서 딱히 없었다

4. 깨달음 / 느낀 점

반복문을 사용할 때는 먼저 어떤 상황인지 생각을 해야한다

5. 아쉬운 부분

컴활 시험이 오늘 기준으로 8일 밖에 안남아서 컴활 필기에 집중하여 얼마 못 한게 매우 아쉽다…

6. 다음 주 계획

컴활 시험이 얼마 남지 않아서 복습 위주로 갈 거 같다
추가적으로 전역도 얼마남지 않아서 전역 전까지는 TIL과 WIL은 매우 뜸해질 것 같다..

[TIL] While, Do While, Break, Continue 차이 정리

dev_Hyeonjoon — Sun, 2 Nov 2025 20:04:41 +0900

반복문

제어문(control statement)의 일종으로, 프로그래밍 언어에서 특정 부분의 코드를 반복적으로 실행하는 문법입니다
자바에서는 반복문으로 For, While, Do While 이 있습니다
- for는 전 글에서 이미 다뤘으므로 자세한 건 패스하겠습니다

While

조건이 참일 때만 반복을 수행합니다.
조건이 처음부터 거짓이라면 한 번도 실행되지 않습니다.

사용법

int i = 0;
while (i < 5) {
	System.out.println(i);
	i++;
}

출력결과

i가 5보다 작을 동안 반복됩니다.
i가 5 이상이 되면 조건이 false가 되어 반복이 종료됩니다.

조건이 처음부터 맞지 않다면

int i = 6;
while (i< 5){
	System.out.println(i);
	i++;
}

⚠️주의: 실행이 아예 안되기 때문에 항상 조건에 주의하며 작성해야합니다

Do While

조건이 거짓이더라도 한 번은 실행됩니다.
먼저 실행 → 나중에 조건 확인 구조입니다.
Do While은 While 반복문과 상당히 비슷한 구문을 이루고 있습니다

사용법

int i = 0;
do {
	System.out.println(i + " ");
	i++;
} while (i < 5)
// 1 2 3 4

While 반복문과 비슷하지 않나요??
While문은 먼저 조건을 적는 반면 Do While은 뒤에 조건문을 적으며 문을 마칩니다.
따라서 아래와 같은 효과를 일으키게 됩니다.

조건이 처음부터 맞지 않다면

int i = 10;
do {
	System.out.println(i + " ");
	i++;
} while (i < 5)
// 10

우선 do에 있는 문들이 실행 후 조건을 확인하게 됩니다.
따라서 무조건 1번은 실행한다고 볼 수 있습니다

✅ 핵심 요약

구분	실행 순서	최소 실행 횟수
While	조건 → 실행	0회
Do While	실행 → 조건	1회 이상

Break과 Continue

Break

반복문을 즉시 멈춥니다

for (i=1; i<=10; i++) {
	if(i ==5)
		break;
	System.out.print(i + " ");
}
// 1 2 3 4

Continue

현재 반복문을 건너뛰고 다음 반복으로 이동합니다.

for (i=1; i<=10; i++) {
	if(i %2 ==0)
		continue;
	System.out.print(i + " ");
}

// 출력: 1 3 5 7 9

반복문 선택 가이드

반복 횟수를 정확히 알 수 있다면 → for
반복 횟수를 모른다면 → while
최소 한 번은 실행해야 한다면 → do while

결국 중요한 것은 ‘가독성’입니다.

세 문법은 모두 같은 결과를 낼 수 있지만, 읽기 쉽고 의도를 드러내는 코드가 더 좋은 코드입니다.

참고자료

[WIL] 자바 조건문 그리고 아쉬운 부분

dev_Hyeonjoon — Sun, 26 Oct 2025 19:05:29 +0900

1. 이번 주 학습 주제

이번 주에는 조건문, 반복문 (20%) 를 수강

2. 배운 점 요약

자바의 삼항 연산자에 대해 배움

switch 함수를 어떻게 쓰고 long 과 같은 값은 안됨

사용자 값을 읽는 Scanner

3. 삽질(실수) & 해결 과정

처음 강의에서 Scanner를 Jshell에서 사용했다. 그래서 임포트도 안하고 계속 에러 뜬 이유를 찾아다니다 구글링을 통해서 해결했다

4. 깨달음 / 느낀 점

반복된 구문은 Switch로 줄여봐야겠다

Scanner로 조금 더 사용자와 상호작용할 수 있는 방법으로 나아가봐야겠다

5. 아쉬운 부분

현재 군 e러닝으로 kcu 온라인 대학교 강의와 컴활 그리고 자바 공부까지 하느라 군 생활이 많이 바쁘다...
그렇기에 계획도 잘 못 지키고 자바도 까먹고... 그게 너무 아쉽다
계획을 수정할 수 도 없고 최대한 안까먹게 오늘처럼 전부 복습도 하고 그래야겠다!!

6. 다음 주 계획

욕심 부리지 않고 자바 반복분 공부해서 TIL 올리기

컴활 엑셀 강의 다 보기

[TIL] Java 조건문 (if, switch, 삼항연산자, Scanner )

dev_Hyeonjoon — Tue, 21 Oct 2025 23:06:04 +0900

if 조건문

조건에 맞는 문이 실행됩니다

if(i==3){
	System.out.println("True");
}
//조건을 명시하고, 조건으로 실행될 코드를 if 블록 안에 쓴다

if-else

int i = 25;
if(i==25){
    System.out.println("i = 25");
 } else {
    System.out.println("i != 25");
 }

if 조건이 true와 false 두 가지 경우의 수를 적을 수 있습니다.

Nested if (중첩 if)

//if - else if - else (Nested If)
int i = 24;
if(i==25){
	 System.out.println("i = 25");
} else if (i == 24) {
			System.out.println("i == 24");
} else {
       System.out.println("i != 24 and i != 25");
	}

if → else if → else 구조로 실행됩니다.
상이한 조건 여러 개 중 하나만 참일 때 유용합니다.
한 번 true가 되면 나머지는 검사하지 않습니다.
각 블록 {}은 반드시 열고 닫는 습관을 들이세요.

사용자 값을 읽는 Scanner

조건문에서 자주 쓰이는 입력값은 Scanner 클래스로 받을 수 있습니다.

사용법

import java.util.Scanner;

자바에 내재된 클래스임으로 임포트를 받아야 합니다
그 후 아래 있는 코드와 같이 작성 시 쉽게 불러올 수 있게 됩니다.

import java.util.Scanner;

public class MenuRunner
{
    public static void main(String[] args)
    {

        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter Number1: ");
        int number1 = scanner.nextInt(); //정수를 읽는 방법
        System.out.println("The number you entered is - " + number1);
    }
}

참고: Scanner 자세한 사용법 보기

Switch 문

if의 문제점

if문에 문제가 있습니다 뭘까요??

바로 선택 옵션이 여러 개 있다면 코드의 길이가 매우 길어집니다.
- 이 코드가 정말 100개 까지 있다고 생각해보세요 엄청 길어질 것이며 사용하기에도 불편할 것입니다
- 이를 조금이나마 해소할 수 있는게 Switch 문입니다

 if (operation == 1){
             System.out.println(number1 + number2);
        }
        else if (operation == 2){
             System.out.println(number1 - number2);
        }
        else if (operation == 3){
             System.out.println(number1 / number2);
        }
        else if (operation == 4){
             System.out.println(number1 * number2);
        } 
        else{
            System.out.println("Invalid Operation");
        }

Switch문 사용법

int number = 1;
switch (number) {
	 case 1 : System.out.println("hello");
	 case 2 : System.out.println("안녕");
	 default :  System.out.println("기본값");
}

switch를 적고 원하는 변수를 적은 뒤, 중괄호를 열어 필요한 코드를 입력합니다
switch문에서 default case는 그냥 default
하지만 여기서 또 문제가 생깁니다.
위에 있는 코드를 실행시키면

hello
안녕
기본값

이런 식으로 출력될 것입니다
왜 일까요?
- 조건에 부합하는 케이스와 그 이하 케이스들을 다 실행됩니다
- 이를 fall through 현상이라고 부릅니다
- 해결 방법은 break을 사용하면 됩니다

fall through를 막는 break

int number = 1;
switch (number) {
	 case 1 : 
	 case 2 : System.out.println("이것은 2 일까요 1일까요?"); break;
	 case 3 : 
	 case 4 : System.out.println("이것은 3 일까요 4일까요?"); break;
}

//출력: "이것은 2 일까요 1일까요?"

int number = 10;
switch (number) {
	default:
		System.out.println("Default");
		break;
	case 1:
		System.out.println("Default");
		break;
	case 2:
		System.out.println("Default");
		break;
	case 3:
		System.out.println("Default");
		break;
}

fall-through 코드는 떄로는 유용하게 사용될 수 있습니다
하지만 주의할 점도 있습니다
- Nested if 의 경우 매칭되는 조건이 없으면 마지막 ‘else’ 코드가 실행되게 된다
- 유일하게 마지막 조건 입력이 가능한 곳
- 하지만 switch문에서는 첫 번째를 디폴트 조건으로 설정할 수 있다
- 그 어떤 case 문도 매칭되는 바가 없을 때 디폴트 설정이 실행되는 것

switch의 컴파일 에러

long l = 15;
switch (l) {
}

컴파일 에러
- 롱 타입에서 switch 불가능, 타입, 스트링에서만 변환 가능, enum 변수 허용됨
스위치에서 사용 가능한 변수들
- char, int, byte, short 등에서만 switch문을 사용 가능하다
- long 이나 double에서 switch를 사용할 수 없다
- float , boolean
케이스에는 조건이 올 수 없습니다

case number > 5 : //에러

삼항 연산자

삼항 연산자는 if로 나열된 문을 줄일 수 있다는 점에서 강점입니다

boolean isEven;
isEven = (condition ? valueIfCondnIsTrue : valueIfFalse);

위에 처럼 작성합니다
- 변수 타입, 조건, 참과 거짓 반환

isEven = (i % 2 == 0? true : false );

그리고 이 조건 연산자는 다른 데이터 타입에서도 사용할 수 있습니다

String even =  (i % 2 == 0 ? "YES" : "NO" );

중요한 건 어떤 것을 사용하든 두 개의 조건 타입이 동일해야 한다는 것

String even =  (i % 2 == 0 ? "YES" : false );

물론 이런건 안됩니다
⚠️주의! 각 그룹에 따라 삼항 연산자를 쓰지 않도록 규칙이 있을 수 있으니 조심!!!
간단한 조건문에서 삼항 연산자가 중요하다고 할 수 있고 복잡한 것에 사용하는 건 추천x
- 코드를 읽을 수 없기 때문

정리 (if 와 switch 비교 표)

구분	if문	switch문
조건 타입	boolean 표현식	int, char, String 등
실행 방식	위에서 아래로 검사	일치하는 case부터 실행
다중 조건	가능	제한적
코드 길이	복잡해질 수 있음	간결함
default	else와 동일	case 불일치 시 실행

if + scanner의 예제 (계산기 만들기)

import java.util.Scanner;

public class MenuRunner
{
    public static void main(String[] args)
    {

        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter Number1: ");
        int number1 = scanner.nextInt(); //정수를 읽는 방법
        System.out.println("Enter Number2: ");
        int number2 = scanner.nextInt(); 

        System.out.println("1 - add ");
        System.out.println("2 - Subtract ");
        System.out.println("3 - Divide ");
        System.out.println("4 - Multiply ");
        System.out.println("Choose Operation: ");
        int operation = scanner.nextInt(); 

        if (operation == 1){
             System.out.println(number1 + number2);
        }
        else if (operation == 2){
             System.out.println(number1 - number2);
        }
        else if (operation == 3){
             System.out.println(number1 / number2);
        }
        else if (operation == 4){
             System.out.println(number1 * number2);
        } 
        else{
            System.out.println("Invalid Operation");
        }
    }
}

️리팩토링

 public static void performOperationUsingNestedIfElse (int number1, int number2, int operation ){
				if (operation == 1){
             System.out.println(number1 + number2);
        }
        else if (operation == 2){
             System.out.println(number1 - number2);
        }
        else if (operation == 3){
             System.out.println(number1 / number2);
        }
        else if (operation == 4){
             System.out.println(number1 * number2);
        } 
        else{
            System.out.println("Invalid Operation");
        }
	 }
}

참고 자료

[WIL] 자바의 객체지향부터 BigDecimal까지 — 실수와 학습의 한 주

dev_Hyeonjoon — Mon, 20 Oct 2025 23:11:37 +0900

1. 이번 주 학습 주제

이번 주에는 OOP(객체 지향 프로그래밍), Java의 캡슐화, 생성자, Wrapper Class, 진수 체계, 자료형 변환, BigDecimal 클래스, 정적 메서드 등을 학습했다.

2. 배운 점 요약

객체 지향 프로그래밍이 뭔지 알게 되었고 왜 자바에서는 캡슐화를 하려고 하는지 Setter 와 Getter를 통해 배움.

부동 소수점의 더 하기는 표현 방식 때문에 달라짐으로 BigDecimal 클래스의 필요성도 알게 되었으며, 마지막으로 형변환은 단순히 타입 바꾸는 게 아니라, 메모리 구조 이해의 출발점임을 깨달음.

3. 삽질(실수) & 해결 과정

double과 float의 차이를 잘못 이해해서 계산 오류가 났다.

강의에서 배워 BigDecimal을 알게 되었고, 계산을 정확하게 할 수 있었다

또 다른 실수는 메인 메서드 내부에 또 다른 메서드를 정의한 것이다. 처음에는 이유를 몰랐지만, 디버깅과 구글링을 통해 메서드는 메인 메서드 밖에 정의해야 한다는 구조적 규칙을 이해했다. 단순한 문법 오류였지만, 코드 구조의 중요성을 다시금 깨닫는 계가 되었다.

4. 깨달음 / 느낀 점

파이썬, 자바스크립트와 비슷한 구문이 많아 지루했지만, 새로운 개념을 발견하려는 시도 자체가 즐거웠다.

되게 아쉬웠던 점은 일요일마다 WIL을 올리고 싶었지만 군대 안에서 시간을 잘쪼개면서 공부하기 쉽지 않다…

시간이 부족해서 TIL을 쓸 때마다 GPT를 많이 활용한다.. 원래 WIL을 작성하는 이유는 전과 후 자바에 적응을 잘하고 백엔드 개발자로서 성장하기 위함인데 약간 모순이 되어버리고 있다
~~(이 글은 구조만 GPT한테 부탁하고 전체 다 내가 쓰고 있다)~~

5. 다음 주 계획

조건문 강의를 마무리하고 TIL을 올릴 것이며 루프절까지 TIL에 올릴 것이다

일요일에 꼭 WIL을 올릴 계획이다

[TIL] Java 불리안, 문자형, 그리고 정적 메서드 정리

dev_Hyeonjoon — Sun, 19 Oct 2025 10:00:22 +0900

불리안(boolean)

대소문자 구분 주의
불리안의 기본 리터럴은 true, false 두 가지뿐.

boolean isValue = false;
boolean isValid = true;

관계 연산자 (Comparison Operators)

i > 7    // false
i >= 7   // true
i == 7   // true

관계 연산자의 결과는 항상 boolean 값으로 반환된다.

⚙️ 논리 연산자 (Logical Operators)

i >= 15 && i <= 25   // 두 조건 모두 참일 때만 true
false || true        // true
false || false       // false
false ^ true         // true (XOR: 두 값이 다르면 참)
!true                // false (NOT: 반대값)

연산자	의미	특징
&&	AND	두 피연산자 모두 참일 때만 true
\|\|	OR	두 피연산자 중 하나만 참일 떄 true
^	XOR	서로 다르면 true
!	NOT	반대값 반환

⚡ 단축 회로 연산자 (Short-Circuit Operator)

int j = 15;
int i = 10;

j > 15 && i++ > 5;  // false
// i는 10 그대로 (두 번째 조건 평가 X)

i > 15 & i++ > 5;   // false
// i는 11로 증가 (모든 피연산자 평가 O)

&&, || → 단축 회로 연산자
- 첫 번째 피연산자 결과로 이미 전체 결과가 결정되면 두 번째는 평가하지 않음
&, | → 모든 피연산자 평가
- 부수효과(i++ 등)가 있을 경우 값이 달라질 수 있음

✅ 팁:

부수효과 있는 코드는 피하자.

필요하면 이렇게 명확히 작성하는 게 좋다.

i++;
if (j > 15 && i > 5) { ... }

문자형(char)

char ch = 'a';   // ✅ OK
char ch = a;     // ❌ Error
char ch = 'ab';  // ❌ Error

문자는 한 글자만 가능
내부적으로는 유니코드(2바이트) 값을 가짐

char ch2 = '\\u0022'; // 출력: "

키보드로 입력하기 어려운 특수문자는 유니코드로 표현 가능.

✏️ 문자 연산

char ch = 65;  // 'A'
ch++;
System.out.println(ch); // 'B'

(int) ch; // 66 (정수로 변환)

문자도 연산 가능하며,
정수형(4바이트)과 연산 시 정수형으로 변환된다.
개행 문자 \\n → 줄바꿈

char ch = '\\n';

⚙️ 정적 메서드 (Static Method)

클래스의 데이터를 사용하지 않을 때 정적 메서드를 쓰는 것이 효율적이다.
객체 생성 없이 클래스명.메서드() 형태로 바로 호출 가능.

class MathUtils {
    static int add(int a, int b) {
        return a + b;
    }
}

int result = MathUtils.add(3, 5); // ✅ 객체 없이 호출 가능

인스턴스가 필요 없고, 독립적으로 동작하는 기능에 적합하다.
예: Math.pow(), Math.sqrt() 등

핵심 요약

구분 설명

boolean	true/false 두 가지 값
&&,\|\|	단축 회로 연산자
&,\|	모든 피연산자 평가
char	문자 하나, 2바이트, 유니코드 기반
정적 메서드	객체 없이 호출 가능, 클래스 단위 기능 구현

[TIL] Java 부동소수점(float, double)과 BigDecimal 정확도 차이 이해하기

dev_Hyeonjoon — Sat, 18 Oct 2025 22:56:40 +0900

부동 소수점?

정수 부분과 소수 부분 모두 다 가진 값을 말합니다.
자바에 부동 소숫값을 담는 데이터 유형은 총 두 가지 입니다.
- double과 float

double

기본적인 부동 소수 리터럴 유형
8바이트
어떤 부동소수 연산이던 결과는 항상 double

double dbl = 34.5678;

float

4바이트
부동 소숫값 뒤에 꼭 f를 붙여함

float f = 34.5; //에러

float f = 34.5f;
float f = 34.5F;

형변환 오류

큰 타입→ 작은 타입으로 변환 할 때 오류가 발생합니다.
위를 예로 들자면 double → float로 변환시 에러가 난다는걸 확인할 수 있습니다

public class main
{
    public static void main(String[] args)
    {
        double dbl = 3.45;
        float f = dbl;
    }
}

//incompatible types: possible lossy conversion from double to float
//      float f = dbl;
                 ^
//1 error

이는 전 글에서 말했던 명시적 형변환으로 간단히 해결할 수 있습니다

부동소수점에 형변환 적용하기

명시적 형변환

큰 타입 → 작은 타입

public class main
{
    public static void main(String[] args)
    {
        double dbl = 3.45;
        float f = (float) dbl;
        System.out.println(f);
    }
}

// 3.45

암묵적 형변환

작은 타입 → 큰 타입

public class main
{
    public static void main(String[] args)
    {
        float f2 = 3.45f;
        double dbl2 = f2;
        System.out.println(dbl2);
    }
}
// 3.450000047683716

여기서 보면 출력값이 이상한걸 확인하실 수 있습니다.
아래에서 자세히 살펴보도록 하겠습니다

부동소수점의 문제점

System.out.println(34.56789876 + 34.2234);
//출력값 : 68.79129875999999

갑자기 9는 어디서 나온걸까요?

대부분의 부동소수 오차는 IEEE 754 표준의 이진 부동소수 표현 방식 때문입니다. 10진수를 2진수로 바꿀 때 일부 소수가 무한 이진소수로 변환되어 정확히 저장되지 못합니다. (참고)

따라서 부동소수는 소숫점값을 명료하게 나타내지 않아서 결과의 정확성이 요구되는 것에는 부동소수 데이터 유형을 계산에서는 float와 double을 사용하지 않는 게 좋습니다
정확한 결과를 원한다면 BigDecimal 클래스를 사용해야합니다

BigDecimal 클래스

BigDecimal은 자바 클래스

import java.math.BigDecimal;
public class main
{
    public static void main(String[] args)
    {
        BigDecimal number1 = new BigDecimal("34.56789876");
        BigDecimal number2 = new BigDecimal("34.2234");
        System.out.println(number1.add(number2));
    }
}

//출력값: 68.79129876

여기서 중요한 점은, 자바에서 BigDecimal 클래스는 변경 불가능하다는 점
BigDecimal 객체는 불변(Immutable) 클래스입니다. 한 번 생성된 값은 변경할 수 없고, 연산 시 새로운 객체를 반환합니다.

BigDecimal에 문자열을 넣는 이유?

정확성을 올리기 위해서

import java.math.BigDecimal;
public class main
{
    public static void main(String[] args)
    {
        BigDecimal number1 = new BigDecimal(34.56789876);
        BigDecimal number2 = new BigDecimal(34.2234);
        BigDecimal number3 = number1.add(number2);
        System.out.println(number3);
    }
}

///68.79129875999999654823113814927637577056884765625

double 타입을 사용해서 만들었더니 출력값이 매우 이상해졌습니다
정확한 것을 원한다면 문자열을 사용!!

BigDecimal 끼리만 연산이 가능해요

import java.math.BigDecimal;
public class main
{
    public static void main(String[] args)
    {
        BigDecimal number = new BigDecimal("11.5");
        BigDecimal number2 = new BigDecimal("23.45678");
        int i = 5;
        System.out.println(number.add(i));
    }
}

이렇게 타입이 다른데 더할 경우 에러가 발생합니다
무조건 BigDecimal 끼리만 연산해주세요

import java.math.BigDecimal;
public class main
{
    public static void main(String[] args)
    {
        BigDecimal number = new BigDecimal("11.5");
        BigDecimal number2 = new BigDecimal("23.45678");
        int i = 5;
        System.out.println(number.add(new BigDecimal(i)));
    }
}

//출력값: 16.5

(BigDecimal 메서드 같은 경우 이 글에서 배우고 있습니다!)

예제 BigDecimal로 이자 계산기 만들기

import java.math.BigDecimal;

public class SimpleInterestCalculator {
    private BigDecimal principal;
    private BigDecimal interest;

    public SimpleInterestCalculator(String principal, String interest) {
        this.principal = new BigDecimal(principal);
        this.interest = new BigDecimal(interest);
    }

    public BigDecimal calculateTotalValue(BigDecimal noOfYears) {
        BigDecimal interestRate = this.interest.divide(new BigDecimal("100"));

        // 2. 총 이자 계산 (원금 * 이율 * 기간)
        // (Principal * Rate * Time)
        BigDecimal totalInterest = this.principal.multiply(interestRate).multiply(noOfYears);

        // 3. 총액 계산 (원금 + 총 이자)
        // (Principal + Total Interest)
        BigDecimal totalValue = this.principal.add(totalInterest);

        // 4. 총액 반환
        return totalValue;
    }

}

import java.math.BigDecimal;
public class SimpleInterestCalculatorRunner
{
    public static void main(String[] args)
    {
        SimpleInterestCalculator calculator = new SimpleInterestCalculator("4500.00", "7.5");
	 
	// '5'는 문자형, 5는 숫자형 → 문자 '5'는 내부적으로 아스키코드 53으로 처리됩니다.
        BigDecimal totalValue = calculator.calculateTotalValue(new BigDecimal("5"));
        System.out.println(totalValue);
    }
}

✍️ 요약

Java의 float와 double은 부동소수점 오차를 가질 수 있습니다.

정확한 계산이 필요한 금융, 이자 계산, 금액 처리에서는 BigDecimal 클래스를 사용해야 합니다.

특히 new BigDecimal("문자열") 형태로 선언하면 오차 없이 안전하게 연산할 수 있습니다.

참고자료

[TIL] Java 자료형과 형변환 완전 정리 (Wrapper Class · 진수 체계)

dev_Hyeonjoon — Sat, 18 Oct 2025 19:51:00 +0900

Java의 자료형과 크기

Java에서 변수와 자료형, 형변환, 진수 체계를 정확히 이해하면 코드의 안정성과 가독성을 높일 수 있습니다.

이 글에서는 Wrapper Class를 통한 자료형 정보 확인, 형변환 종류, 진수 체계까지 한 번에 정리합니다.

Java 기본 자료형과 Wrapper Class

Java의 기본 자료형(primitive type) 은 각각 대응하는 래퍼 클래스(Wrapper Class)가 있습니다.

래퍼 클래스는 해당 자료형의 크기, 최댓값, 최솟값 등을 제공하여 프로그래밍에 활용할 수 있습니다.

Wrapper Class 예시

기본형	래퍼 클래스	크기(bit)	크기(bite)	최소값	최대값
byte	Byte	8	1	-128	127
short	Short	16	2	-32,768	32,767
int	Integer	32	4	-2,147,483,648	2,147,483,647
long	Long	64	8	-9,223,372,036,854,775,808	9,223,372,036,854,775,807
float	Float	32	4	-3.4E38	3.4E38
double	Double	64	8	-1.7E308	1.7E308
char	Character	16	2	'\u0000'	65,535
boolean	Boolean	1 (논리값)	1	true	false

Wrapper Class 활용 예제

System.out.println("Integer.SIZE: " + Integer.SIZE);       // 32 (비트)
System.out.println("Integer.MIN_VALUE: " + Integer.MIN_VALUE); // -2147483648
System.out.println("Integer.MAX_VALUE: " + Integer.MAX_VALUE); // 2147483647

형변환 (Casting)

형변환이란 자료형을 다른 타입으로 변환하는 것을 의미합니다.

Java는 엄격한 자료형을 요구하기 때문에 자동 변환과 강제 변환을 이해하는 것이 중요합니다.

2-1. 묵시적 형변환 (Implicit Casting)

작은 타입 → 큰 타입으로 변환
자동으로 처리, 데이터 손실 없음

int i = 500000;
long l = i; // 묵시적 형변환 (자동)

2-2. 명시적 형변환 (Explicit Casting)

큰 타입 → 작은 타입으로 변환
데이터 손실 가능, 반드시 (타입) 명시 필요

long l = 10000000000L;
int i = (int) l; // 명시적 형변환, 데이터 손실 가능
System.out.println(i); // 출력: -147483648

⚠️ 주의: 큰 값(long)을 int로 변환하면 값이 잘못 나올 수 있습니다.

자바 진수 체계

Java는 2진수, 8진수, 10진수, 16진수를 지원합니다.

예제

int decimal = 10;       // 10진수
int octal = 010;        // 8진수 (8)
int hex = 0x10;         // 16진수 (16)
int binary = 0b1010;    // 2진수 (10)

진수 규칙

0으로 시작 → 8진수
0x로 시작 → 16진수
0b로 시작 → 2진수
10진수는 0~9
16진수는 0~9, A~F (A=10, B=11 … F=15)

진수 변환 메서드

Integer.toBinaryString(10); // "1010"
Integer.toHexString(10);    // "a"
Integer.toOctalString(10);  // "12"

⚠️ 주의: 다른 진수 사용은 코드 가독성을 떨어뜨리므로, 가능하면 10진수를 기본으로 사용하세요.

참고 자료

정리

Wrapper Class를 활용하면 자료형의 크기와 범위를 쉽게 확인 가능
형변환은 묵시적(자동)과 명시적(강제)으로 나뉘며, 데이터 손실 여부를 확인해야 함
진수 체계와 변환 메서드를 알고 있으면 진수 관련 연산과 출력이 편리함

[TIL] 자바(Java) 생성자(Constructor) 완벽 정리: 메소드 오버로딩과 함께 사용하는 예제

dev_Hyeonjoon — Thu, 16 Oct 2025 19:47:54 +0900

생성자(Constructor)란 무엇일까요?

생성자는 객체(Object)가 생성될 때 단 한 번 호출되는 특별한 종류의 메소드입니다. 주된 역할은 클래스의 인스턴스 변수(필드)들을 원하는 값으로 초기화하는 것입니다. 우리가 new 키워드를 사용하여 객체를 만들 때, 내부적으로는 이 생성자가 호출되고 있는 것이죠.

생성자, 일반 메소드와 무엇이 다를까요?

생성자는 일반적인 메소드와 몇 가지 뚜렷한 차이점을 가집니다.

반환 타입(Return Type)이 없습니다. 일반 메소드는 void, String, int 등 반드시 반환 타입을 명시해야 하지만, 생성자는 반환 타입을 지정하지 않습니다. 값을 반환하는 목적이 아니라 객체를 초기화하는 것이 유일한 임무이기 때문입니다.
이름이 클래스 이름과 동일합니다. 생성자의 이름은 반드시 해당 클래스의 이름과 대소문자까지 정확하게 일치해야 합니다. 만약 단 한 글자라도 다르다면, 자바는 그것을 생성자로 인식하지 않고 일반 메소드로 취급합니다.

기본 생성자 예제: MotorBike 클래스

간단한 MotorBike 클래스를 통해 생성자를 직접 만들어 보겠습니다.

public class MotorBike {
    // 인스턴스 변수 선언
    String brand;
    int speed;

    // 생성자
    public MotorBike(String brandName, int initialSpeed) {
        System.out.println("생성자가 호출되었습니다.");
        // this는 현재 객체(만들어질 인스턴스)를 가리킵니다.
        this.brand = brandName;
        this.speed = initialSpeed;
    }

    public static void main(String[] args) {
        // new 키워드로 객체를 생성하는 순간, 생성자가 호출됩니다.
        MotorBike myBike = new MotorBike("Harley-Davidson", 0);

        System.out.println("내 바이크 브랜드: " + myBike.brand); // 출력: Harley-Davidson
        System.out.println("내 바이크 초기 속도: " + myBike.speed); // 출력: 0
    }
}

위 예제에서 MotorBike myBike = new MotorBike("Harley-Davidson", 0); 코드가 실행되는 순간, MotorBike 클래스의 생성자가 호출됩니다. 생성자는 전달받은 "Harley-Davidson"과 0이라는 값으로 객체의 brand와 speed 변수를 각각 초기화합니다. 이처럼 생성자는 객체가 처음 만들어질 때 필요한 초깃값을 설정하는 데 매우 유용합니다.

메소드 오버로딩을 활용한 여러가지 생성자 만들기

하나의 클래스 안에는 여러 개의 생성자를 만들 수 있습니다. 이때 메소드 오버로딩 규칙이 적용되는데요, 바로 매개변수의 개수나 타입을 다르게 하여 같은 이름의 생성자를 여러 개 정의하는 것입니다.

상황에 따라 객체를 다르게 초기화하고 싶을 때 매우 유용합니다.

public class MotorBike {
    String brand;
    int speed;

    // 1. 매개변수가 없는 생성자
    public MotorBike() {
        this.brand = "Unknown"; // 기본 브랜드 설정
        this.speed = 0;         // 기본 속도 설정
    }

    // 2. 브랜드만 받는 생성자 (오버로딩)
    public MotorBike(String brandName) {
        this.brand = brandName;
        this.speed = 0;         // 속도는 기본값으로 설정
    }

    // 3. 브랜드와 속도를 모두 받는 생성자 (오버로딩)
    public MotorBike(String brandName, int initialSpeed) {
        this.brand = brandName;
        this.speed = initialSpeed;
    }

    public static void main(String[] args) {
        MotorBike bike1 = new MotorBike(); // 1번 생성자 호출
        System.out.println("바이크1: " + bike1.brand + ", 속도: " + bike1.speed);
        // 출력: 바이크1: Unknown, 속도: 0

        MotorBike bike2 = new MotorBike("Ducati"); // 2번 생성자 호출
        System.out.println("바이크2: " + bike2.brand + ", 속도: " + bike2.speed);
        // 출력: 바이크2: Ducati, 속도: 0

        MotorBike bike3 = new MotorBike("BMW", 10); // 3번 생성자 호출
        System.out.println("바이크3: " + bike3.brand + ", 속도: " + bike3.speed);
        // 출력: 바이크3: BMW, 속도: 10
    }
}

예제 1: 기본값으로 초기화하는 생성자
예제 2: 브랜드만 받아서 초기화하는 생성자
예제 3: 브랜드와 속도를 모두 받아서 초기화하는 생성자

이처럼 생성자 오버로딩을 활용하면, 객체를 생성하는 시점에 전달하는 인자에 따라 각기 다른 방식으로 객체를 초기화할 수 있어 코드의 유연성이 크게 향상됩니다.

정리

이번 포스팅의 핵심 내용을 다시 한번 정리해 보겠습니다.

생성자는 객체가 생성될 때 호출되는 초기화 메소드입니다.
생성자는 반환 타입이 없고, 이름이 클래스명과 반드시 동일해야 합니다.
메소드 오버로딩을 통해 매개변수가 다른 여러 생성자를 만들어, 상황에 맞게 객체를 다양하게 초기화할 수 있습니다.

참고 자료

[TIL] Java 객체의 상태와 캡슐화 - Setter, Getter로 배우는 OOP 기본

dev_Hyeonjoon — Wed, 15 Oct 2025 23:27:26 +0900

객체의 상태

객체의 상태는 클래스 내 멤버 변수를 만들어 나타낼 수 있습니다
상태는 변할 수 있습니다

class Publishing{
    int noOfCopies;
    public void publish(int noOfCopies){
        System.out.println("publish");
    }
}

class PublishingExample
{
    public static void main(String[] args)
    {
        Publishing zeroToOne = new Publishing();
        zeroToOne.publish = 10
    }
}

여기서 문제점이 무엇일까요?

캡슐화를 위반하고 있습니다
- 필드 noOfCopies가 public이 아니라 default지만, 외부에서 직접 접근 가능하지 않은 게 아니라, setter/getter 없이 직접 변경이 가능하다는 점에서 OOP 원칙 위배
복사본 조건 설정 불가: 현재 publish(int noOfCopies)는 아무 값이나 받을 수 있음. 예: 음수 입력 가능 → 논리적 오류 발생 가능.

이를 해결하기 위해서 Setter와 Getter가 사용됩니다.

Setter & Getter 가 필요한 이유

클래스의 데이터 접근을 제한하고 제어하기 위해 사용됩니다.
외부에서는 메서드를 통해서만 데이터에 접근하도록 하여, 안정성과 일관성을 확보합니다.

Setter

외부에서 메소드를 통해 데이터를 변경할 때 사용합니다.
동시에 조건 검사나 검증 로직을 추가할 수 있습니다.

class Publishing{
    private int noOfCopies;
    public void setPublish(int noOfCopies){
        if ( noOfCopies > 0){
            this.noOfCopies = noOfCopies;  
            //여기서 this.noOfCopies는 2번째 줄의 noOfCopies를 가르키며
						// 등호 오른쪽에 있는 noOfCopies는 매개변수를 가르킵니다.
            System.out.println(noOfCopies);
        }
    }
}

class PublishingExample
{
    public static void main(String[] args)
    {
        Publishing zeroToOne = new Publishing();

        zeroToOne.setPublish(10);
    }
}

이제 복사본이 1개 이상일 때만 성공적으로 출판되게 만들었습니다.
이렇게 하면 캡슐화 뿐아니라 조건도 걸 수 있기에 아주 유용합니다

Getter

객체 외부에서 필드 값을 읽어올 때 사용합니다.
단순 접근이 아닌, 가공된 데이터 반환에도 활용됩니다.

class Publishing{
    private int noOfCopies;

    public void setNoOfCopies(int noOfCopies){
        this.noOfCopies = noOfCopies;
    }

    public int getNoOfCopies(){
        return this.noOfCopies;
    }
    public void setPublish(int noOfCopies){
        if ( noOfCopies > 0){
            System.out.println(noOfCopies);
        }
        
    }
}

class PublishingExample
{
    public static void main(String[] args)
    {
        Publishing zeroToOne = new Publishing();

        zeroToOne.setNoOfCopies(10);
        System.out.println(zeroToOne.getNoOfCopies());
    }
}

//출력 결과 : 10

결론

캡슐화(encapsulation)는 객체 지향의 핵심 원칙으로,
데이터(필드)는 private으로 보호하고, Setter와 Getter를 통해서만 접근하도록 해야 합니다.

구분	역할	핵심 목적
Setter	데이터 변경	유효성 검사 가능
Getter	데이터 읽기	안전한 접근 및 가공

이렇게 하면 객체의 상태를 안정적으로 유지하면서도 유연한 제어가 가능합니다.

(하지만 요새는 Setter와 Getter를 지양하기도 합니다)

참고 자료

[TIL] 객체 지향 프로그래밍 (OOP) 핵심 개념 총정리

dev_Hyeonjoon — Wed, 15 Oct 2025 20:02:48 +0900

객체 지향 프로그래밍?

객체 지향형 프로그래밍 (Object-oriented programming, OOP)은 프로그램을 데이터(객체) 중심으로 구성하여, 객체 간의 상호작용을 통해 동작하도록 설계하는 프로그래밍 패러다임입니다.

객체 지향 프로그래밍에서 클래스가 중요한 이유

전 글에서 말했듯이 클래스는 무엇이라고 비유할 수 있을까요?

(전 글에서 조금 더 추가해서)
클래스는 객체를 생성하기 위한 설계도(blueprint) 또는 템플릿 입니다.
즉, 클래스는 객체가 가져야 할 속성과 동작을 정의하고,
실제 실행 시 이 설계도를 기반으로 객체가 메모리에 생성됩니다.

객체는 클래스의 인스턴스입니다.
- 객체가 내포한 데이터는 객체의 ‘상태’라고 하고 객체의 상태는 시간에 따라 바뀔 수 있습니다
- 객체에 행할 수 있는 행동은 ‘동작’ 이라고 합니다
즉, 객체가 갖고 있는 데이터와 객체에 행할 수 있는 동작이 무엇인지 규정할 수 있습니다.

객체 지향 프로그래밍의 특징

추상화(abstraction)

복잡한 시스템으로부터 핵심적인 개념 또는 기능을 간추려내는 것을 의미합니다.
예를 들어,
- 오토바이를 탄다고 할 때, 엔진이 어떻게 돌아가는지 알 필요는 없습니다. 단지 기어와 엑셀 사용법 정도만 알고 있으면 되죠

캡슐화(encapsulation)

객체의 속성과 메서드를 하나로 묶고 일부를 외부에 감추어 은닉하는 것을 말합니다.
예를 들어,
- 오토바이 운전자는 ‘가속 페달’을 밟을 뿐 내부 엔진의 복잡한 로직은 알 수 없습니다.
- 이렇게 내부 동작을 숨기고 필요한 인터페이스만 제공하는 것이 캡슐화입니다.

상속성(inheritance)

상위 클래스의 특성을 하위 클래스가 이어받아서 재사용하거나 추가, 확장하는 것을 말합니다

다형성(polymorphism)

하나의 메서드나 클래스가 다양한 방법으로 동작하는 것을 말합니다
예를 들어,
- ‘달린다’ 메서드가 사람, 자동차, 동물 클래스에서 각각 다르게 구현될 수 있습니다
- 오버로딩, 오버라이딩

객체지향프로그래밍의 단점

설계와 구조화에 많은 시간이 소요됩니다.
처리 속도가 절차지향 프로그래밍에 비해 상대적으로 느릴 수 있습니다.
클래스와 객체 간 의존성이 복잡해지면 유지보수 난이도가 높아질 수 있습니다.

요약

구분	의미	예시
추상화	핵심만 간추리기	자동차의 ‘달린다’, ‘멈춘다’ 기능만 표현
캡슐화	내부 로직 은닉	가속페달을 밟지만 엔진 동작은 숨김
상속성	코드 재사용	Animal → Dog, Cat
다형성	다양한 형태로 동작	run()이 객체마다 다르게 실행됨

결론

객체 지향 프로그래밍은 단순히 문법이 아닌 사고방식이다.
현실 세계를 코드로 모델링하며, 유지보수성과 확장성을 높이는 핵심 패러다임이다.
다만, 설계에 신중해야 하며 구조가 복잡해질수록 관리가 어려워질 수 있다.

+ 객체 지향 프로그래밍은 Java뿐만 아니라 Python, C++, Kotlin 등 대부분의 현대 언어에서 핵심 개념으로 사용

이 글은 Udemy Java 강의와 『면접을 위한 CS 전공지식 노트』를 기반으로,

제가 직접 이해한 내용을 제 사비로 구매·학습 후 정리한 글입니다.

참고 자료

[WIL] 자바 주간 회고

dev_Hyeonjoon — Mon, 13 Oct 2025 19:01:01 +0900

자바를 시작한 이유

검정색 배경에 코드를 입력하는 순간이 저에겐 정말 짜릿했습니다.처음엔 “공부가 부족해서 어렵나?” 싶었지만, 시간이 지나도 나아지지 않자 결국 백엔드로 전향하기로 결심했고, 그렇게 자바(Java) 공부를 시작했습니다.
하지만 대학교 때부터 군대까지 프론트엔드를 계속 하다 보니, CSS 스트레스가 한계에 다다랐습니다.

자바를 배우면서 힘들었던 점

자바스크립트와 파이썬만 배웠던 제게 타입 지정, 메모리 크기 관리, 공용 정적 메서드(static method) 등은 처음엔 낯설었습니다.
특히 메서드 안에서 다른 메서드를 불러오고, 그 안에서 System.out.println()으로 출력하는 과정이 복잡하게 느껴졌습니다.
하지만 반복 학습과 코드 분석을 통해 “아, 이런 구조로 흘러가는구나” 하는 순간이 오면서 점점 적응해나가고 있습니다.

TIL(Today I Learned)을 시작한 이유

그동안 모든 강의는 Udemy → 노션 정리 방식으로 공부했습니다.
하지만 이 방식은 ‘정리만 하고 복습은 없는’ 비효율적 루프였습니다.
1년 넘게 공부했는데도 머릿속엔 남는 게 거의 없다는 걸 느끼며,
이제는 기록 중심이 아닌 복습 중심의 학습 루틴을 만들고자 TIL을 시작했습니다.
TIL은 저에게 “공부한 것을 내 것으로 만드는 과정”이자, “성장의 증거를 남기는 기록”입니다.

‍ 간단한 자기소개

현재 군 복무 중인 병장(3호봉)이며, 전역까지 약 45일 남았습니다.
일과 시간에는 맡은 업무를 마치고, 개인정비 시간에는 책을 읽거나 코딩 공부를 병행하고 있습니다.
입대 후 SQLD 자격증을 취득했고, 전역 전까지는 두 가지 목표를 꼭 이루려 합니다.
1. 자바 완전 마스터하기
2. 군 e-러닝 2학기 A+ 달성하기

행복한 프로그래머를 위한 10가지 규칙

dev_Hyeonjoon — Thu, 9 Oct 2025 13:10:24 +0900

프로그래밍은 단순한 기술이 아니라, 삶의 태도다.

1️⃣ 도전을 받아들여라

문제는 배움의 시작이다.
에러는 네가 성장하고 있다는 증거다.

2️⃣ 실패해도 괜찮다

실패는 ‘끝’이 아니라, 학습의 한 과정이다.
한 번의 오류가 너를 더 단단하게 만든다.

3️⃣ 연습은 완벽함을 만든다

많은 코드는 결국 너를 더 나은 개발자로 만든다.
꾸준함이 최고의 알고리즘이다.

4️⃣ 인내심을 가져라

프로그래밍은 단거리 달리기가 아니라 마라톤이다.
오늘 이해하지 못한 개념도, 내일엔 보일 수 있다.

5️⃣ 즐겨라

코드의 과정 속에서 작은 성취감을 느껴라.
즐기는 사람은 결국 더 멀리 간다.

6️⃣ 포기하지 마라

에러는 끝이 아니라, 다음 줄의 시작이다.
멈추지 않으면 결국 완성된다.

7️⃣ 문제를 쪼개라

복잡한 문제는 작은 단위로 나누면 단순해진다.
한 줄씩, 한 단계씩.

8️⃣ 끈기를 가져라

어려워 보여도 계속하라.
진짜 실력은 버텨낸 시간에서 만들어진다.

9️⃣ 스스로를 칭찬하라

작은 성취라도 스스로에게 박수를 쳐라.
그것이 다음 단계로 가는 연료다.

호기심을 가져라

프로그래밍은 평생 학습의 여정이다.
새로운 언어, 개념, 기술에 끊임없이 마음을 열어라.

“완벽한 개발자가 아니라, 행복한 개발자가 되어라.”

코멘트

유데미: 완전 초보자를 위한 Java 프로그래밍: 단기간에 Java 완벽 정복을 보다가 강의에서 나온 말 중에 감명받고 정리해서 블로그에 올립니다. 저도 완벽함에 집착하기 보단 행복한 개발자가 되기 위해 노력해야겠습니다!

[TIL] 자바 개발자를 위한 IDE 비교표 (Eclipse, VS Code, JShell, Web IDE)

dev_Hyeonjoon — Thu, 9 Oct 2025 11:13:24 +0900

IDE이란?

IDE는 '통합 개발 환경'(Integrated Development Environment)의 약자로, 소프트웨어 개발에 필요한 여러 도구(코드 편집기, 컴파일러, 디버거 등)를 하나의 그래픽 사용자 인터페이스(GUI) 환경에 통합하여 프로그래머가 코드를 작성하고, 디버깅하고, 테스트하는 과정을 효율적으로 진행할 수 있도록 돕는 소프트웨어 애플리케이션입니다.

IDE를 사용해야 하는 이유

1.클래스 분리

IDE를 사용하면 가장 좋은 점은 클래스를 분리 시켜서 가독성과 유지보수 측면에서 큰 이점이라는 것입니다
- 사진에서 보면 구구단 표 클래스를 먼저 만들고 메인 클래스에서 메서드만 실행하는 방식을 채택하는걸 확인할 수 있습니다.
- 메서드는 이렇게 일반화할수록 더 쓸모 있습니다
  - 사실, 이 부분은 '객체 지향 프로그래밍(OOP)'의 핵심 원칙에 따른 것이지만 IDE를 사용하면 이런 핵심원칙에 따르기 쉬워집니다.

2.편리한 단축키

파일을 생성하는 것부터 저장하는 것 까지 그 외 다양한 기능의 단축키들이 IDE 프로그램에 따라서 존재

3.리팩터링이 쉽다

리팩토링이란?

코드의 기능을 건드리지 않으면서 구조에만 변화를 주는 것
본인의 코드를 개선하는 더 나은 아이디어를 생각해 내는 것이 리팩터링의 본질

리팩토링 예시

package project;

public class MultiplicationTable
{
    void print (){
       for(int i = 1 ; i <= 10; i ++){
           System.out.printf("%d * %d = %d", 5, i, 5 *i).println();
        }
    }

    void print (int n){
       for(int i = 1 ; i <= 10; i ++){
           System.out.printf("%d * %d = %d", n, i, n*i).println();
        }
    }

    void print (int n, int from, int to){
       for(int i = from ; i <= to; i ++){
           System.out.printf("%d * %d = %d", n, i, n*i).println();
       }
    }
}

//길고 중복되는 코드가 너무 많다 이걸 리팩토링한다면

package project;

public class MultiplicationTable
{
    void print (){
        print(5);
       // print(5, 1, 10);
    }

    void print (int n){
      print(n, 1, 10);
    }

    void print (int n, int from, int to){
       for(int i = from ; i <= to; i ++){
           System.out.printf("%d * %d = %d", n, i, n*i).println();
       }
    }
}

주의할 점

자바에서는 파일 경로를 이용해 클래스를 가져오지 않고, 패키지 경로를 사용합니다.
- 하지만 MultiplicationTable 클래스가 Main 클래스와 같은 project 패키지(폴더) 안에 있다면, import 문은 아예 필요 없습니다.

비교표: Web IDE, Eclipse, VS Code, JShell

도구명	특징 요약	장점	단점
Web IDE	브라우저 기반 IDE (예: Replit, GitHub Codespaces)	- 설치 없이 사용 가능- 협업에 용이- 자동 저장 및 클라우드 연동	- 인터넷 환경 의존- 실행 속도 느림- 제한된 확장성
Eclipse	Java 개발 대표 IDE	- 강력한 디버깅 및 플러그인- 대형 프로젝트에 안정적- 정통 IDE 구조	- 초기 설정 복잡- 무겁고 느림- UI 직관성 낮음
Visual Studio Code (VSC)	경량화된 코드 에디터형 IDE	- 빠른 속도, 다양한 확장 기능- 여러 언어 지원- 커스터마이징 자유도 높음	- 고급 기능은 플러그인 의존- 초보자는 세팅 어려움
JShell	Java 9+ 버전부터 제공된 REPL 도구	- 즉시 실행 및 테스트 가능- 실험적 코드 작성 용이- 학습용으로 적합	- 대형 프로젝트 부적합- 파일 단위 관리 어려움- IDE 수준 기능 부족

요약 정리

상황 추천	IDE
빠르게 코드 테스트 / 학습용	✅ JShell
가벼운 개발, 웹 프로젝트 중심	✅ VS Code
자바 중심의 대규모 프로젝트	✅ Eclipse
설치 없이 간단히 실습 / 팀 협업용	✅ Web IDE

JShell은 실험용,

Eclipse는 본격 개발용,

VS Code는 확장형 경량 IDE,

Web IDE는 언제 어디서나 접근 가능한 클라우드형.

참고자료

https://www.redhat.com/ko/topics/platform-engineering/what-is-ide#:~:text=통합 개발 환경(Integrated Development Environment%2C IDE)이란 공통된,Interface%2C GUI

https://www.megazonesoft.com/google_ide-cloudworkstatiom/

https://studioplug.tistory.com/351

https://i-ri.tistory.com/64

https://jjini-note.tistory.com/22

https://comparedev.tistory.com/entry/JShell-을-이용해-자바-테스트하기

https://dimorin.tistory.com/entry/Eclipse-vs-Visual-Studio-Code-VS-Code-비교

그 외 유데미 자바 강의

[TIL] 자바 플랫폼 독립 (+ 클래스)

dev_Hyeonjoon — Wed, 8 Oct 2025 16:38:21 +0900

GeeksforGeeks

컴퓨터는 0과 1 밖에 모른다

컴퓨터는 사실 0과 1밖에 알아듣지 못 합니다. 0과1로만 코딩하는걸 기본 명령이라고 하는데 이는 어셈블리 언어에서 사용됩니다.
- 이 0과1은 CPU가 이해하는 기계어이며, 운영체제는 그 위에서 동작합니다
그런데 운영체제마다 명령어가 다르다면 자바 코드는 어떻게 운영체제에서 작동될 수 있을까요?
이는 플랫폼 독립성으로 해결 가능합니다

플랫폼 독립성이란

특정 하드웨어나 운영체제 등 플랫폼에 제약받지 않고 소프트웨어가 실행될 수 있는 특성
- 즉, 자바 코드를 짜게 되면, 다양한 운영체제에서 작동되는 것입니다.
- 이 과정은 아래 글에서 자세히 설명드리겠습니다

바이트 코드

자바 소스 코드를 자바 가상 머신(JVM)이 이해할 수 있도록 변환한 중간 코드
바이트 코드는 운영체제와 관계없이 공통적인 포맷을 취합니다
하지만, 운영체제들은 기초적인 명령들만 알아듣기에 이해할 수 없습니다
이 문제를 해결하기 위해 등장한 것이 JVM (자바 가상 머신) 입니다.

통역사 같은 역할 JVM

바이트코드를 각 운영체제를 위한 명령으로 바꿔주는 역할을 합니다
- 여기서 명심해야할 사실은 JVM은 운영체제마다 다르다는 것입니다.
덕분에 윈도우에서 작성한 자바 코드가 리눅스 나 유닉스에서도 작동될 수 있죠
다시 말하자면 JVM이 바이트 코드를 기반으로 코드를 실행하는데 그걸 위해서 JVM이 바이트코드를 기계 명령으로 바꾸는 것
- ⇒ 운영체제가 이해하기 쉽게

실행 과정

소스 코드 작성 → 컴파일 -> 바이트코드로 변환 -> 실행 중 JVM이 바이트코드 읽어 특정 운영체제 명령어로 바꿈 -> 운영체제에 프로그램을 실행

JVM이 실제 실행을 담당한다면, 자바 프로그램이 실행되기까지는 다른 도구들도 필요합니다. 바로 JRE(Java Runtime Environment) 와 JDK(Java Development Kit)입니다. 다음은 이들이 어떤 역할을 하는전 이해하기 쉽도록 자바 프로그램이 어떤 구조(클래스와 메서드)로 구성되는지를 알아보겠습니다.

자바 클래스

자바는 객체지향언어로써 ‘클래스’로 이루어져 있습니다.
JVM, JRE, JDK 를 이해하기 전 클래스가 어떻게 구성되었는지 반드시 알아야 합니다.

클래스란

클래스는 ‘템플렛’ 이라고 말할 수 있습니다.
- 즉 같은 걸 여러 개 만들 수 있는거죠

클래스 생성하기

class Country {
   //methods
 }

이와 같이 클래스를 정의할 수 있습니다.
class 는 Country 라는 유형을 정의한 것입니다.
- int num = 1 과 같이 말이죠

오브젝트

Country라는 클래스가 있을 때 India, USA, Korea 등 과 같은 나라들을 만들 수 있겠죠
- 여기서 Country는 클래스, India, USA, Korea 는 오브젝트들이 됩니다.

오브젝트 생성하기

Country India = new Country();
Country USA  = new Country();
Country Korea = new Country();

India, USA, Korea는 Country 형의 오브젝트입니다
- 즉, 형이든 클래스든 둘 다 Country를 뜻함
보통 클래스에서는 데이터, 메서드가 있으며 메서드로 클래스의 데이터에 작업을 할 수 있습니다.

메서드

클래스들에 행해질 수 있는 행동 (전글 참조)

class Country {
   void sayHello(){
		System.out.println("Hello!!!")
	}
    }
    
Country India = new Country();
Country USA  = new Country();
Country Korea = new Country();

Korea.sayHello();

이렇게 하면 오브젝트도 클래스에 정의된 메서드를 사용할 수 있습니다

⚠️ 주의

클래스이름.메소드 는 에러를 일으킵니다

컴파일 과정

자바 코드 → 파일로 만듦 → 컴파일 → 바이트코드

~~(터미널이 불가하여 글로 대체하겠습니다… 양해부탁드려요)~~

class Country {
   void sayHello(){
		System.out.println("Hello!!!")
	}
    }

이 파일을 가지고 컴파일한다고 가정해보겠습니다
컴파일 명령어는 javac 파일명
- *.java 파일을 컴파일하면 *.class 로 컴파일되어 새로운 파일이 생깁니다.
- 이 클래스 파일이 바이트코드를 담고 있습니다
실행하고 싶다면
- java 클래스의 이름
  - *.class 의 파일을 사용한다
다시 정리하자면

*.java -> 컴파일 -> *.class 생성 -> java *이 *.class를 실행하려고 할 것이다

그러나 이렇게 실행 시 오류가 발생할텐데 컴파일하고 실행해야하는데 실행하려면 공용 정적 보이드 메인이 필요하다 (JShell 외에서)
- 공허는 메서드가 아무것도 반환하지 않았고 메인은 메서드의 이름이고 String[] args 인수들 입니다
- 문자열,대괄호는 인수의 배열이라는 걸 뜻 합니다
public static void main(String[] args) {}

package project;
class Country{
    void sayHello() {
        System.out.println("Hello");
    }
    public static void main(String[] args) {
        Country Korea = new Korea();
        Korea.sayHello();
    }
}

최종적으로 이렇게 바꿨음에도 아직 오류가 뜰 겁니다.
- 이는, *.class 파일이 실행되고 있기 때문인데 *.java를 컴파일하고 다시 *.class 파일을 실행하면 해결 가능합니다

⚠️주의사항

자바 파일은 메인 메서드가 있어야 실행되는데 어떤 것을 추가하거나 어떤 변화라도 준다면 다시 꼭 컴파일해야만 변화가 적용됩니다
javac(자바 컴파일)를 실행하려면 *.java 가 있는 폴더와 똑같은 곳에 있어야 합니다

JVM, JRE, JDK 함께 보기

GeeksforGeeks

JVM (Java Virtual Machine)

바이트코드를 운영체제의 특정한 명령으로 바꿔주는 소프트웨어
그러니 윈도우 JVM, 유닉스 JVM, 리눅스 JVM 모두 제각각 다릅니다
이것들이 할 수 있는 건 바이트코드를 가져다가 특정한 운영 체제가 명령을 실행할 수 있도록 바꾸는 것
다시 말하자면 JVM이 바이트 코드를 기반으로 코드를 실행하는데 그걸 위해서 JVM이 바이트코드를 기계 명령으로 바꾸는 것
- ⇒ 운영체제가 이해하기 쉽게

JRE(Java Runtime Environment, 자바 실행 환경)

JVM + Libraries + Other Components
어떤 자바 프로그램을 예로 들어도 기본적으로 내재되어 있는 자바 클래스가 몇 개는 필요
System.out.println 은 자바 라이브러리 안에 있음
어떤 자바 라이브러리든 어떤 자바 클래스가 필요하든 여기에 포함되어 있을 것
JRE, 자바 실행 환경은 JVM과 내재된 모든 자바 클래스를 합친 것

JDK(Java Development Kit)

JRE + Compilers + Debuggers
JRE, JVM 하고 자바 라이브러리가 더해진 거고 모든 컴파일러와 디버거가 합쳐진 것
전체가 자바 프로그램을 개발하고, 컴파일하고 실행시킬 때까지 필요한 것들이라는 것
JDK는 자바 프로그램을 개발하고 실행할 때 필요하고 JRE는 자바 프로그램을 실행할 때 필요하고 그리고 모든 자바 프로그램은 JVM을 이용해서 실행

참고

https://velog.io/@hyhy9501/섹션5-자바-플랫폼-소개

https://www.geeksforgeeks.org/java/jdk-in-java/

https://www.geeksforgeeks.org/java/java-platform-independent/

https://ko.wikipedia.org/wiki/%EC%9E%90%EB%B0%94_%EB%B0%94%EC%9D%B4%ED%8A%B8%EC%BD%94%EB%93%9C

[인프런] 무료 노션 강의 후기 — “노션, 단순 기록을 넘어서 시스템으로”

dev_Hyeonjoon — Tue, 7 Oct 2025 23:31:25 +0900

https://inf.run/P2KrQ

강의를 듣게 된 계기

개발 공부를 하면서 느낀 건, 정리는 결국 실력이다였습니다.

메모만 하는 수준을 넘어서 데이터를 체계적으로 관리하고 싶었고,

노션 템플릿을 사용하다 보니

“이건 어떻게 만들었지?”

“여기서 수식은 뭐지?”

이런 궁금증이 생겼습니다.

마침 인프런에서 무료로 제공되는 노션 기초 강의가 있어 바로 수강하게 되었습니다.

강의 구성

총 5개 섹션 / 48강 / 약 5시간 44분 분량
하루에 한 섹션씩, 5일 플랜으로 완강 (25.10.02 ~ 25.10.07)

단순히 페이지를 꾸미는 수준이 아니라,

데이터베이스 관계(Relation)
Rollup, Formula 계산식
템플릿 자동화 및 필터링 시스템

까지 다루어 노션의 기술적 구조를 전반적으로 이해할 수 있었습니다.

이런 분들에게 추천합니다

노션을 처음 접하거나 계정만 만든 채 방치한 분
노션을 쓰고 있지만 기능을 30%도 활용하지 못하는 분
개인 공부나 프로젝트를 체계적으로 관리하고 싶은 사람

✅ 장점

실습 중심으로 따라 하기 쉬운 구성
강사님의 톤이 친절하고 세세하게 설명
“왜 이렇게 설계해야 하는가”에 대한 설명이 있어 응용이 쉬움

⚠️ 단점

2020년 기준 강의라 일부 기능(데이터베이스 뷰, 캘린더 UI 등)이 현재 버전과 다름
→ 하지만 공식 노션 문서나 구글, Reddit 커뮤니티 참고로 쉽게 해결 가능
중급 이상 유저에게는 다소 기본적으로 느껴질 수 있음

수강 후 변화

이전에는 템플릿을 아예 만들지 못했지만,

이제는 데이터베이스와 Formula를 이용해

Java 학습 노트 관리용 템플릿을 직접 제작했습니다.

Before: 단순 텍스트 기록

After: 학습 진도, 복습 주기, 요약을 자동 계산하는 시스템화된 노트

노션이 단순 노트가 아니라,

개인 맞춤형 생산성 툴이라는 걸 실감했습니다.

앞으로의 활용 계획

이번 강의를 통해 노션의 구조적 사고를 익혔고,

앞으로는 개발 공부, 프로젝트 관리, 사이드 템플릿 제작까지

직접 시스템을 설계하는 단계로 발전시킬 계획입니다.

특히 전역 후에는 학습 대시보드와 템플릿을 만들어

수익화에도 도전해볼 생각입니다.

이 글은 광고나 협찬이 아닌,
제가 순수하게 배우고 싶어서 들은 강의 후기입니다.
노션을 막 시작하려는 분들께 도움이 되길 바랍니다!

[TIL] 자바 메서드

dev_Hyeonjoon — Tue, 7 Oct 2025 15:45:55 +0900

Java 메서드란?

메서드란 클래스 내부에 정의되어, 특정 객체의 행동을 나타내는 함수입니다.
- 예를 들어, 자동차 라는 클래스에 시동을 거는 것 그것이 메서드로 볼 수 있습니다

메서드의 이점

1. 코드의 재사용성 (Reusability)

똑같은 코드를 여러 곳에 복사해서 붙여넣을 필요가 없습니다. 특정 기능을 하는 코드를 메서드로 만들어두면, 필요할 때마다 그 메서드를 호출하기만 하면 됩니다.

2. 가독성 및 구조화 (Readability & Organization)

복잡한 프로그램을 잘게 쪼개진 여러 개의 메서드로 나누면 전체 코드의 구조를 파악하기가 매우 쉬워집니다. 각 메서드는 하나의 특정 기능만 담당하므로, 메서드 이름만 봐도 어떤 작업을 하는지 바로 알 수 있습니다.

3. 유지보수 용이성 (Maintainability) ️

코드 수정이 필요할 때, 해당 기능을 담당하는 메서드 한 곳만 수정하면 됩니다. 만약 메서드를 사용하지 않고 코드를 복사해서 붙여넣었다면, 그 코드가 사용된 모든 곳을 찾아서 일일이 수정해야 하는 번거로움이 있습니다

아래 메서드의 예제를 보고 다시 한번 이점을 생각해보도록 합시다!

Java에는 함수가 없나요?

네, Java는 모든 코드가 클래스 안에 작성되어야 하는 객체 지향 언어입니다. 따라서 Java에서 만드는 모든 기능은 클래스에 소속되므로 메서드라고 부르는 것이 가장 정확한 표현입니다.

메서드

메서드 문법

ReturnType nameOfTheMethod() {
	//Body of the method
}

리턴 타입, 메서드 명 , 매개변수, 그리고 메서드 몸통으로 이루어져 있습니다
리턴 타입 : 변수와 같이 리턴할 타입을 입력하면 됩니다
- void : 반환하지 않는 타입 (공허 메서드 라고도 불림)
- String: 문자를 반환
- int : 숫자 반환
- 기타 등등
메서드 명: 메서드의 역할이 드러나게 동사형으로 작성합니다
- 읽었을 때 한번에 메서드의 역할을 이해할 수 있는게 가장 좋은 메서드 명
메서드 몸통: 코드 블록({}) 안에 들어가는것들

예제

void sayHelloWorldTwice() {
	System.out.println("Hello World");
	System.out.println("Hello World");
}

sayHelloWorldTwice() // 메서드 실행

⚠️ : 메서드 "선언"과 "실행(호출)"은 엄연히 다릅니다
선언만 해서는 코드가 실행되지 않습니다

메서드 명명 규칙

소문자 동사로 시작 메서드는 '어떤 동작을 수행'하므로, 그 동작을 나타내는 동사로 시작하는 것이 좋습니다. 첫 글자는 반드시 소문자여야 합니다.
- 좋은 예: print, send, calculate
카멜 케이스(Camel Case) 표기법 사용 메서드 이름이 여러 단어로 이루어진 경우, 첫 단어는 소문자로 시작하고 그 이후 각 단어의 첫 글자만 대문자로 작성합니다.
- get user name → getUserName()
- calculate total price → calculateTotalPrice()
명확하고 서술적으로 작성 이름만 봐도 메서드가 어떤 기능을 하는지 명확하게 알 수 있어야 합니다. 축약어보다는 의미가 명확한 전체 단어를 사용하는 것이 좋습니다.
- 나쁜 예: proc(), calc(), ud()
- 좋은 예: processUserData(), calculateScore(), updateDatabase()

자주 사용되는 접두사

메서드의 역할을 더 명확하게 나타내기 위해 다음과 같은 접두사를 관례적으로 사용합니다.

접두사	역할	예시
get...	값을 가져올 때	getName()
set...	값을 설정할 때	setAge(25)
is... / has...	boolean 반환 시	isEmpty(), hasChildren()
calculate...	계산 기능	calculateTax()
find...	탐색 기능	findUserById()

메서드에 매개변수 및 인자 넣기

만약 Hello World를 1000번 해야한다고 했을 때 sayHelloWorldTwice 를 500번 적는다면 그건 상당한 고충일 것입니다.
이는 쉽게 매개변수와 인자로 간편하게 해결할 수 있습니다
- 매개변수와 인자는 아래에서 더 자세히 설명드리겠습니다

void sayHelloWorld(int num) {
        for (int i = 1 ; i <= num ; i++ ){
            System.out.println("Hello World");
}

sayHelloWorld(3)
//HelloWorld는 총 3번 출력된다

호출할 때 꼭! 인자를 넣어줘야 합니다
추가적으로 매개 변수를 전달하려면 메서드 안에 있는 인수 타입을 꼭 맞춰줘야 해요

⚠️ 인자가 없거나 타입이 맞지 않을 때

Main.java:21: error: method printSquaresOfNumbers in class Main cannot be applied to given types;
        printSquaresOfNumbers();
        ^
  required: int
  found:    no arguments
  reason: actual and formal argument lists differ in length
1 error

**이런식으로 오류가 뜬다**
---------------------------------------------------------------------------------------

Main.java:21: error: unclosed character literal
        sayHelloWorld('hi');
                              ^
Main.java:21: error: unclosed character literal
        sayHelloWorld('hi');
                                 ^
Main.java:21: error: not a statement
        sayHelloWorld('hi');
                                ^
3 errors

**타입이 안맞는 경우에도 그럼**

매개 변수 그리고 인자 소개

매개변수(Parameters)
- void sayHelloWorld(int num) 처럼 함수를 선언할 때 들어가는 변수를 매개변수라고 불러요
- 즉, 매개변수는 메서드 코드 내에서 사용하는거죠
인자 (Arguments)
- sayHelloWorld(3) 메서드 호출할 때 전달하는 것을 인자라고 해요
- 즉, 메서드를 호출할 때 인자를 전달하는거죠

메서드 오버로딩

한 클래스 내에 똑같은 메서드 이름으로써 다른 역할을 하는 메서드를 뜻해요
대부분 매개 변수의 유무로 메서드를 달리하는 default 값으로 주로 사용합니다!
- JS, Python과 달리 default 값을 메서드를 사용해 지정해줘야 해요

예제

//메서드 오버로딩
class Main {
    public static void prinMultiplicationTable() {
        for (int i = 1 ; i <= 10 ; i++ ){
            System.out.printf("%d * %d = %d", 5,i, 5 *i).println();
        }
    }
    public static void prinMultiplicationTable(int table) {
        for (int i = 1 ; i <= 10 ; i++ ){
            System.out.printf("%d * %d = %d", table,i, table *i).println();
        }
    }
    public static void main(String[] args) {
        prinMultiplicationTable(6);
        prinMultiplicationTable();
    }
}

//매개 변수가 없는, 기본값인 5단을 출력하는 메서드를 부를 수 잇고 아니면 매개 변수를 전달할 수 도 있다
//여기서 매개 변수의 유무도 다른 똑같은 이름의 두 개의 메서드를 만든 것

여러 개의 매개변수를 자바 메소드로 전달하기

지금까지 배우면서 매개변수가 한 개라니 불편하지 않으셨나요?
다른 언어들과 같이 매개변수는 여러 개를 넣을 수 있어요
아래 예제를 통해 함께 배워봐요!

예제

// 여러 개의 매개변수를 자바 메소드로 전달하기 
sum(int a, int b) {
     System.out.println(a + b);
} 
sum(5,6) //11

이때도 타입은 꼭 필수로 명시해주셔야 합니다

메서드 값 반환하기

호출하는 메서드에 계산 결과를 반환하는데에 사용됩니다
글로만 보면 어려우실 수 있는데 아래 예제를 보면서 함께 이해해봐요

예제

int sumOfTwoNumbers(int fristNumber, int secondNumber){
        int sum = fristNumber + secondNumber;
        return sum;
}
sumOfTwoNumbers(1,1); //반환 값이기때문에 출력은 안된다

int sumOfThirdNumbers = sumOfTwoNumbers + 1;
System.out.print(sumOfThirdNumbers);

// 3 출력

int sumOfThirdNumbers = sumOfTwoNumbers + 1; 이 코드를 분해 해봤을 때,
- sumOfTwoNumbers 는 메서드입니다. 하지만 return 즉, sum을 반환 했기에 sumOfTwoNumbers는 인수 2개에 의해서 결국 2가 되었습니다.
- 그리고 나서 2 + 1 을 했으니 결국 sumOfThirdNumbers 는 3이 된거죠

오늘의 예제

// 코드 예시

class Main {

		// 세 개의 수를 더하기 
    public static int sumOfThreeNumbers(int firstNumber, int secondNumber, int thirdNumber){
        int sum = firstNumber + secondNumber + thirdNumber;
        return sum;
    }
    
    // 삼각형의 마지막 각 구하기 
    public static int calculateThirdAngle(int firstAngle, int secondAngle){
        int thirdAngle = 180 - (firstAngle + secondAngle);
        return thirdAngle;
    }
    
    public static void main(String[] args) {
        System.out.println(sumOfThreeNumbers(1, 1, 3));
        System.out.println(calculateThirdAngle(50, 70));
    }
}

계산 결과는 무엇일까요??

참고 자료

https://namu.wiki/w/%EA%B0%9D%EC%B2%B4%20%EC%A7%80%ED%96%A5%20%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D

https://peemangit.tistory.com/389

[TIL] 자바 IF 조건문 그리고 For 반복문

dev_Hyeonjoon — Mon, 6 Oct 2025 22:07:32 +0900

IF 조건문

if 조건문은 조건식의 결과가 참과 거짓을 구별한다
- 조건은 무조건 불리언 값만 가능하다
else는 거짓일 때 실행 조건을 가르킨다

if 예제

if (조건) 문

위에 코드의 경우 문이 한 줄일 때 밖에 쓰지 못 합니다
조건이 true일 시 문이 실행됩니다
그러나 많은 개발자들이 코드 블록을 쓰는걸 선호하기에 비추천되는 방식
- 가독성
- 나중에 수정하기 용이 등

int a = 1;
if (a >= 1) {
	System.out.println("True");
}

문이 여러 개일때 사용됩니다
가독성 및 유지 보수에 용이

if- else

조건을 딱 한번만 확인해도 될 때

int a = 1;
if (a >= 1) {
	System.out.println("True");
} else {
  // 거짓일 때 실행될 문
  System.out.println("false");
}

만약 if에서 거짓이 될 시에 else로 바로 이동합니다!

else if

조건이 복수로 확인이 필요할 때

int a = 1;
if (a >= 1) {
	System.out.println("a는 양수입니다.");
} else if (a <= -1) {
  // 거짓일 때 실행될 문
  System.out.println("a는 음수 입니다.");
}

else if는 개수 제한이 없으며 위에서 아래로 순차적으로 계산하며 내려갑니다.

else if - else

else if 가 끝났는데도 불구하고 false 일 때

int a = 1;
if (a >= 1) {
	System.out.println("a는 양수입니다.");
} else if (a <= -1) {
  // 거짓일 때 실행될 문
  System.out.println("a는 음수 입니다.");
} else {
	 System.out.println("a는 0 입니다.");
}

for 반복문

//반복문
for(initialisation; condition; update) {
		statement;
	}

for 반복문에서 가장 중요한 부분은 조건을 설정하는 것입니다
반복문에는 우선 초기치 설정, 조건, 업데이트를 입력해야 합니다
조건이 fasle 일 경우 for는 바로 멈춥니다

for 반복문 예제

//반복문 예시
for(int i=1; i<=10; i++){
	System.out.printf("%d * %d = %d", 5, i, 5*i).println();
}

반복문이 실행될 때 초기치 설정은 단 한번만 실행됩니다.
- 반복문이 실행될 시 i는 1이라는 값을 배정받고 초기치 설정은 반복문이 끝날 때까지 실행x
- ***처음*** 초기치 설정 -> 조건절 실행 -> 문 실행 -> 업데이트 실행 ***그 후 ~ 끝날 때까지 *** 조건절 실행 -> 문 실행 -> 업데이트 실행
- 위를 예시로 만약 반복문이 10번 실행된다면 초기치 설정은 한 번만 실행되지만, 업데이트는 9번 실행된다
- 그런데 여기서 명심해야 할 점은 조건은 항상 실행된다는 것

for 반복문의 빈 문

말 그대로 “비어 있는 문”
for 반복문에는 초기치 와 조건 그리고 업데이트 하는 자리를 비워둘 수 있습니다

for ( ; i<=10 ; i++);

for 빈 문을 사용하여 무한 반복 시키기

for ( ; ; ;)

조건은 항상 참이니까 무한 반복

for 반복문에 복수 개의 식 넣기

하지만 조건식은 불가능!

int j = 0
for (i=1, j=2 ; i <= 10; i++, j++);  // i == 11 , j == 12
// 그러나 조건은 한 개 밖에 안됩니다.

반복문 예제 (별 찍어보기)

// 코드 예시
package project;

public class Main {
    public static void main(String[] args) {
        int j=0;
        for(int i=1;i<=5;i++){
            for(j=0; j<i; j++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

출력 결과:

* 
* * 
* * * 
* * * * 
* * * * *

추가 개념

리터럴

리터럴은 숫자 값을 의미합니다.
7은 정수 리터럴이고 7.5는 소수 리터럴로 나눠집니다
정수 리터럴은 int 타입이며 소수 리터럴은 double 타입니다

식

table * i 처럼 * 연산자와 두 오퍼랜드가 있을 때 *로 둘을 곱하는 건데, 이걸 통틀어서 식이라고 한다
즉, 평가했을 때 어떤 값이 되는 걸 의미합니다
- 1+1 = 2

문

명령을 실행하라는 코드 조각
- 즉, “무엇을 하라”는 지시를 담고 있습니다

int i = 0;, if(...) {...}, for(...) {...}

생각해보기

for 문과 if 문은 언제 쓰일까요?
for 문을 배우기 전 if문을 먼저 배운 이유가 뭘까요?
별을 찍는 과정에서 바깥 반복문과 안쪽 반복문은 어떤 역할을 할까요?
for 문 안에서 if 문을 사용해 짝수만 출력하는 프로그램을 만들어보세요.

[TIL] 자바 변수 이해하기

dev_Hyeonjoon — Sun, 5 Oct 2025 17:07:28 +0900

변수란?

데이터를 저장하기 위한 메모리 공간에 붙인 이름이에요

값이 변할 수 있기 때문에 ‘변수’ 라고 불립니다.
마치 이사할 때, "이 상자에는 책만 담을 거야", "이 상자에는 옷만 넣을 거야"라고 이름표를 붙이는 것과 같아요. 덕분에 컴퓨터는 데이터를 훨씬 효율적으로 관리할 수 있습니다.

자바와 자바스크립트의 변수 차이

가장 큰 차이점은 타입을 지정하는 방식이에요

자바 (Java) ☕: 정적 타입 언어 (Static Typing)

변수를 선언할 때 반드시 int, String과 같이 어떤 종류의 데이터가 들어갈지 타입을 명시해야 합니다. 한번 타입이 정해지면 다른 타입의 값은 저장할 수 없어 코드의 안정성이 높습니다.

int number = 10;
// number = "hello"; // 에러 발생! int 타입 변수에 문자열을 넣을 수 없음

핵심: 변수를 만들기 전에 어떤 데이터를 담을지 먼저 고민하고, 그에 맞는 '타입'을 고르는 습관을 들여야 합니다!

자바스크립트 (JavaScript) : 동적 타입 언어 (Dynamic Typing)

변수를 선언할 때 타입을 지정하지 않고 let, const, var 같은 키워드만 사용합니다. 변수의 타입은 값이 할당될 때 결정되며, 실행 중에 다른 타입의 값으로 변경할 수 있어 유연성이 높습니다.

let data = 10; // data는 숫자(Number) 타입이 됨 data = "hello"; // 가능! data는 이제 문자열(String) 타입이 됨

변수 종류

변수는 크게 값이 직접 저장되는 기본형(Primitive Type)과, 값이 저장된 곳의 주소가 저장되는 참조형(Reference Type) 으로 나뉩니다.

기본형(primivite type)

문자형

char: 한 개의 문자(2byte)를 저장합니다. 작은따옴표(' ')로 값을 감쌉니다.

정수형 byte, short, int, long

소수점 없는 숫자 저장.
크기에 따라 메모리 차이가 다름.

타입 크기 표현 범위

byte	1바이트	-128 ~ 127
short	2바이트	-32,768 ~ 32,767
int	4바이트	약 -21억 ~ 21억
long	8바이트	아주 큰 정수 (끝에 L 붙임)

int age = 21;
long population = 8000000000L;

실수형 float, double

소수점이 있는 숫자 저장.

타입 크기 비고

float	4바이트	끝에 F 붙임 (3.14F)
double	8바이트	기본 실수 타입 (3.14)

float pi = 3.14F;
double avg = 93.7;

논리형 boolean

true 또는 false 두 값만 가짐.

boolean isStudent = true;
boolean hasLicense = false;

참조형 (Reference Type)

객체(Object)의 주소를 저장.
기본형처럼 값을 직접 저장하는 게 아니라, 실제 데이터가 저장된 공간의 위치(주소)를 가리킴.

String name = "Hyeonjun's code";
int[] scores = {90, 85, 100};

⚡ String은 사실 ‘문자 배열’(char[])을 감싸는 참조형 객체예요.

"Hello"라는 문자열 자체가 아닌, 그 문자열이 저장된 위치를 가리키는 거죠

️ 변수 명명 규칙 (Naming Rules)

자바에서는 변수 이름에도 철저한 규칙이 있습니다.

가독성과 유지보수를 위해 꼭 지켜야 해요.

✅ 필수 규칙

영문자, 숫자, _, $만 사용 가능
숫자로 시작할 수 없음
공백, 특수문자(@, #, ! 등) 불가능
대소문자 구분함 (age ≠ Age)
예약어 사용 금지 (class, if, for 등)

✨ 권장 컨벤션

camelCase 사용
- 예: studentName, totalScore
의미 있는 이름
- x, y보다는 age, height, userName
boolean은 is/has로 시작
- isLoggedIn, hasLicense
상수는 모두 대문자 + 밑줄(_)
- final double PI = 3.14159;

요약

자바의 변수는 “타입이 있는 상자”이고,

이 상자를 만들 때 이름 붙이는 법(규칙)까지 정해져 있다.

초반엔 복잡하지만, 익숙해지면 훨씬 안정적인 코드 작성이 가능해진다.

햄버거 메뉴 만들기 [리액트+ vite + tailwindCSS v.4.1]

dev_Hyeonjoon — Wed, 24 Sep 2025 18:34:57 +0900

햄버거 닫힘

햄버거 열림

만들게 된 이유

읽잇(Readit) 프로젝트를 진행하다 보니, 반응형 UI가 꼭 필요하다는 생각이 들었습니다. 특히 기존 NavBar가 모바일 화면에서는 자리를 많이 차지해서 이용하기가 불편했죠. 그래서 TailwindCSS를 활용해 반응형 레이아웃을 만들었고, 모바일에서는 햄버거 메뉴를 적용해 더 편리하게 사용할 수 있도록 했습니다.

햄버거 메뉴 구현 해보기

1. 가장 중요한 부분 (상태 정리하기)

가장 중요한 부분은 상태를 사용해 햄버거 창이 열렸는지 안열렸지는 알려주는 useState 아닐까? 라는 생각에 가장 중요한 부분으로 뽑아봤습니다!

전제

닫힘: 메뉴가 숨겨져 있을 때 (false)
열림: 메뉴가 화면에 보일 때 (true)

const [isOpen, setIsOpen] = useState(false);

isOpen: 현재 메뉴의 상태를 알려주는 변수. 지금은 false니까 “메뉴가 닫혀 있어!"라고 말해주는 거죠.
setIsOpen: isOpen의 상태를 바꿔주는 스위치. 이 스위치를 누르면 isOpen의 값이 true로 바뀌면서 "메뉴가 열렸어!"라고 알려줘요.

2. 함수 만들기

const toggleMenu = () => {
    setIsOpen(!isOpen);
  };

함수를 실행시키면 isOpen을 Not으로 만드는 것이죠.
- 만약 참이였다면 부정이 되듯이

3. 함수와 버튼 연결하기

<button
  onClick={toggleMenu}
  className="md:hidden focus:outline-none"
>
  {/* ...SVG 아이콘들... */}
</button>

onClick={toggleMenu}: 이 코드가 바로 스위치를 연결하는 부분이에요. toggleMenu 함수는 isOpen 상태를 true와 false 사이에서 바꿔주는 역할을 해요.
- 버튼을 처음 누르면 isOpen은 false에서 true로 바뀌고,
- 다시 누르면 true에서 false로 바뀌죠.
그리고 그 아래에 있는 복잡한 <svg> 코드는 isOpen 상태에 따라 햄버거 모양(false)과 닫기 버튼 모양(true)을 보여주는 역할을 합니다.
- (이건 아래 목차에서 더 알아보기로 해요!)

4. 메뉴 내용 숨겼다 보여주기

⇒ 마지막으로, 메뉴 내용 자체를 isOpen 상태에 따라 숨기거나 보여주는 거예요.

<ul className={`${isOpen ? 'block' : 'hidden'} md:hidden w-full ...`}>
  {/* ...메뉴 내용들... */}
</ul>

className="...": 이 부분에서 CSS 클래스를 조건에 따라 다르게 넣어줘요.
- isOpen ? 'block' : 'hidden': 삼항 연산자를 사용해서 만약 isOpen이 true라면 'block' 클래스를 넣어서 메뉴를 보여주고, false라면 'hidden' 클래스를 넣어서 숨깁니다.
- md:hidden: 이 클래스는 화면이 태블릿(md) 크기보다 커지면 메뉴를 아예 숨겨버립니다. 그래서 모바일에서만 햄버거 메뉴가 작동하는 거죠.

정리

상태 블록: isOpen이라는 변수가 "메뉴가 닫혔어요"라고 말해줘요.
버튼 블록: 사용자가 햄버거 버튼을 누르면, isOpen의 상태가 "메뉴가 열렸어요!"로 바뀝니다.
메뉴 블록: isOpen의 상태가 바뀌는 것을 감지하고, 숨겨져 있던 메뉴가 나타납니다.

예제 코드

import React, { useState } from 'react';
import { Link } from 'react-router-dom';
import nav_logo from '../images/nav_logo.png';
import './Nav.css';

function Nav() {
  const [isOpen, setIsOpen] = useState(false);

  const toggleMenu = () => {
    setIsOpen(!isOpen);
  };

  return (
    <>
      <nav className="flex justify-between items-center h-12 lg:h-24 max-w-[21.875rem] lg:max-w-[75.00rem] my-2 m-auto py-0 px-2 lg:px-6 border-b border-gray-1">
        <Link to="/">
          <img src={nav_logo} alt="로고 사진" className="w-[150px] mb-[5px] lg:w-[200px] h-auto flex" />
        </Link>
        
        {/* 데스크톱 메뉴 (md: 이상 화면에서 보임) */}
        <ul className="hidden md:flex gap-12 items-center font-bold text-base leading-[1.2]">
          <li>
            <Link to="/about" className="hover:text-gray-600 transition-colors">
              <span>소개 <sup>01</sup></span>
            </Link>
          </li>
          <li>
            <Link to="/bookcase" className="hover:text-gray-600 transition-colors">
              <span>책장 <sup>02</sup></span>
            </Link>
          </li>
          <li>
            <Link to="/contact" className="hover:text-gray-600 transition-colors">
              <span>문의 <sup>03</sup></span>
            </Link>
          </li>
        </ul>

        {/* 햄버거 버튼 (모바일에서만 보임) */}
        <button
          onClick={toggleMenu}
          className="md:hidden focus:outline-none"
        >
          {/* 메뉴가 닫혔을 때 (햄버거 아이콘) */}
          {!isOpen ? (
            <svg className="w-6 h-6 text-gray-800" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" d="M4 6h16M4 12h16M4 18h16"></path>
            </svg>
          ) : (
            /* 메뉴가 열렸을 때 (X 아이콘) */
            <svg className="w-6 h-6 text-gray-800" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" d="M6 18L18 6M6 6l12 12"></path>
            </svg>
          )}
        </button>
      </nav>

      {/* 모바일 드롭다운 메뉴 */}
      {/* isOpen 상태에 따라 메뉴를 보여주거나 숨깁니다. */}
      {/* md: 이상 화면에서는 항상 숨깁니다. */}
      <ul className={`${isOpen ? 'block' : 'hidden'} md:hidden w-full max-w-[21.875rem] m-auto py-0 px-2 lg:px-6`}>
        <li className="py-3 px-2 border-b border-gray-1">
          <Link to="/about" onClick={toggleMenu} className="block text-gray-800">
            <span>소개 <sup>01</sup></span>
          </Link>
        </li>
        <li className="py-3 px-2 border-b border-gray-1">
          <Link to="/bookcase" onClick={toggleMenu} className="block text-gray-800">
            <span>책장 <sup>02</sup></span>
          </Link>
        </li>
        <li className="py-3 px-2 border-b border-gray-1">
          <Link to="/contact" onClick={toggleMenu} className="block text-gray-800">
            <span>문의 <sup>03</sup></span>
          </Link>
        </li>
      </ul>
    </>
  );
}

export default Nav;

➕ 추가) SVG 구현 부분에 대해서

이 코드는 'Scalable Vector Graphics'의 약자인 SVG라는 웹 기술로 만들어진 이미지 파일이에요. 즉, 햄버거 메뉴 아이콘을 글자처럼 코드 한 줄로 그린 것이라고 생각하시면 돼요.

핵심은 <path> 태그예요.

<svg>: SVG 이미지의 시작을 알리는 태그.
<path>: 선(line)이나 곡선(curve)을 그려서 도형을 만드는 태그예요.
d="M6 18L18 6M6 6l12 12": 이 부분이 그림을 그리는 실제 설계도예요.
- M: Move to (펜을 이동).
- L: Line to (선 그리기).
- d 속성 안의 복잡한 문자들은 **'어떤 좌표로 이동해서 어디까지 선을 그려라'**라고 명령하는 명령어들의 모음이에요.
- M6 18L18 6는 (6, 18) 지점에서 시작해서 (18, 6) 지점까지 선을 그으라는 뜻이고, M6 6l12 12는 (6, 6) 지점에서 시작해 (12, 12) 지점까지 선을 그으라는 뜻이죠. 이 두 개의 선을 합치면 바로 X자 모양이 됩니다.

즉, <path> 태그가 아이콘의 모양을 만들고, 그 앞의 <svg> 태그는 아이콘을 담는 그릇 역할을 하는 거예요.

사지방에서 풀 스택과 기획 그리고 배포까지 (읽잇 MVP 완성)

dev_Hyeonjoon — Fri, 15 Aug 2025 18:39:37 +0900

https://readit-38t1.onrender.com/

프로젝트 링크: https://readit-38t1.onrender.com/

프로젝트 개요

시작 이유

리액트를 공부하다 보니 튜토리얼 지옥에 빠져 있다는 걸 깨달았습니다.

그래서 "기획 + 개발"을 동시에 진행하는 실전형 프로젝트를 시작했습니다.

군대에서 책을 읽다 문득,

"노션이 아니라, 내가 만든 웹사이트에서 간편하게 독서 기록을 남기면 어떨까?"

라는 아이디어가 떠올랐고, 바로 실행에 옮겼습니다.

프로젝트 목표

책 검색 & 감상문 기록이 가능한 개인 독서 기록 웹서비스 제작
React 기반 감성 UI 구현
취업 포트폴리오 활용
⏳ 1달 내 MVP 완성 + 단계별 확장성 확보

역할 및 기여 범위

기획

처음 하는 기획이라 GPT를 활용해 아이디어를 구조화
MVP → 구현 단계를 조정하며 노션에 기획안을 작성
PM 역할에도 관심을 가지기 시작

저는 한번도 기획을 해본 적이 없기 때문에 GPT를 사용하여 저의 아이디어를 GPT 안에다가 넣었고 MVP와 구현 단계를 조절하며 이를 노션에 옮겨서 실행했습니다

(노션 페이지)

이런 기획 후에는 framer를 사용해 디자인을 했고 그 디자인한 걸 가지고 framer는 너무 익숙하지 않아서

Figma로 더 자세히 기획해봤습니다

(피그마 보러 가기)

아직은 피그마가 어렵긴 하지만 점점 연습해서 PM도 관심을 가져볼 예정입니다!

프런트엔드

기획안을 토대로 React (Vite) 로 구현
모르는 부분은 Gemini를 통해 학습 & 문제 해결

백엔드

Naver Book API 사용 중, API Key 보안 문제 인지
Node.js로 API 서버 구현 (Gemini 도움)
(현재 기여율: 0%, Node.js 공부 중으로써 향후 확장 계획 있음)

기술 스택과 아키텍처

구분	기술	비고
프레임워크	React (vite)	사지방+구름IDE에서 CRA보다 쾌적
스타일링	기본 CSS + CSS Modules	점진적 적용
디자인	Framer 디자인을 handoff 받아 수작업 적용	완성도 높은 UI
API	Naver Books API	책 검색 기능
상태 관리	useState / localStorage	DB 없이 MVP 가능
배포	Render	1클릭 배포 가능
검색 엔진	naver search advisor, google search console	검색 가능

주요 기능

LocalStorage를 활용한 책 데이터 CRUD

책 없을 시 → 안내 문구

책 있을 시 → 수정/삭제 가능

Naver Book API를 활용한 책 이미지

모든 책 이미지 로드 가능
단, Render 무료 플랜 → 첫 로딩 느림

무한 스크롤

페이지네이션보다 부드러운 UX 제공
이전 기록을 자연스럽게 확인 가능

문제와 해결(제약 환경 포함)

(노션 정리본)

CSS는 전역으로 설정된다

처음 리액트를 배우고 프로젝트를 하는데 서로 다른 컴포넌트인데도 불구하고 CSS가 중복 적용된다는 문제가 발생했습니다. 이렇게 중복으로 설정됐을 때 CSS Module을 사용할 수도 있었겠지만 그냥 className을 서로 다르게 설정해서 해결했습니다

Local Storage는 덮어쓰기 된다

Local Storage에 관해 지식이 없었기 때문에 기존 배열이 있다면 자연스럽게 추가되겠지라는 생각으로 했는데 다 사라지고 추가한 데이터만 있었습니다... Local Storage의 작동방식을 공부한 후 key-값으로 구성된다는 점을 이용해 기존 배열을 복사 후 새로운 원소를 추가하여 키는 고정한 채로 새로운 배열 값을 만드는 방식을 선택했습니다

상태 복잡성

책장 페이지에 있는 책 리스트와 검색창을 구현하는 과정에서 상당히 복잡했습니다

상태는 부모 -> 자식으로 흐른다고 배웠는데 검색컴포넌트가 완전히 꼬여있었습니다

이를 해결하기 위해 컴포넌트끼리 시각화를 해봤습니다

북케이스가 검색창과 북 카드를 렌더링 하고 있는 최상단이 맞기 때문에 여기서 State를 사용하는 게 분명한데 setBooks를 사용해서 하려고 했는데 Search 컴포넌트에서 어떤 것도 반환하지 않았습니다 저의 생각을 정리해보자면

SearchBar에서 검색 결과를 가지고 옴
Bookcase에서 가지고 온 걸 바탕으로 setBooks에 재렌더링
setBooks를 사용하여 Bookcard로 렌더링

이었고 가장 큰 문제는 SearchBar에서 어떻게 가져오는 지모르겠다는 것이었고 그렇게 생각하면서 풀어봤는데 제미나이 쓰기 직전에 아이디어가 떠올랐습니다

해답은 책장 페이지에서 searchResult라는 상태를 새로 만들고 검색창 컴포넌트에 searchResult를 활용한 함수를 같이 보내주는 방법을 사용해서 올바르게 표시될 수 있게 했습니다

모달창 만들기

인터넷을 찾는 도중 Protal과 라이브러리 없이 하는 방법을 찾을 수 있었습니다. Portal을 사용하기 위한 주 요인은 DOM 계층 구조와 CSS 문제 해결인데 저의 경우 DOM 계층 구조를 굳이 수정할 필요가 없다고 생각했기에 CSS를 조금 극단적이게 z-index: 100으로 설정해서 모달창을 라이브러리 없이 구현했습니다

SEO 세팅

학습 포인트

useEffect, useState를 잘 사용할 수 있게 됨
컴포넌트 분리
함수 props 활용
Local Storage 구조를 이해
API 사용법 숙지
SEO 세팅 경험
Render로 Node.js + React 동시 배포 경험

다음 개선 계획

Tailwind로 전체 전환
Node.js 연동으로 실시간 DB 저장
로그인 기능 (OAuth 또는 이메일)
감상문 태그 기능
공유 기능 (링크 복사)
TypeScript로 안정성 강화

느낀점 & 향후 계획

여전히 백엔드 vs 프런트엔드 진로 고민 중
남은 군 복무 기간(104일) 동안 기획 or 백엔드 집중 (최대한 많은 경험을 위해)
9~11월 일정
1. 백엔드 공부
2. KCU 2학기 강의 수강
3. 노션 심화 학습
4. 운동 & 다이어트

‍ 개발자 정보

기술 스택: HTML5, CSS, JavaScript, React, Git
GitHub: guswnsj0112
블로그: joon0112.tistory.com
Instagram: joonplan.dev

Minecraft Style Armor Simulator Web 만들기

dev_Hyeonjoon — Sun, 27 Jul 2025 11:53:33 +0900

https://minecraft-style-armor-simulator.netlify.app/

[프로젝트 개요]

왜 만들었을까?

이 프로젝트는 군 복무 중 짬을 내어, 리액트의 상태 관리(useState)와 컴포넌트 구조 분리를 연습하기 위해서 만들었습니다. ~~(입원 연기로 읽잇보다 리액트 연습을 더 먼저하려고...)~~ 기존 리액트 실력은 너무 강의만 따라쳐서 그런가 'props를 어떻게 넘기고 상태를 어디서 관리해야하는지' 모르는 경우가 너무 많았습니다 그래서 이를 보안하기 위해 강의를 다시 보며 강의 예제 없는 저만의 프로젝트로 만들어보고 싶었습니다

구현 목표

각 부위(머리, 몸통, 다리)의 아머 색상을 클릭해서 개별적으로 변경할 수 있도록 구현
전체 색상 변경과 초기화 기능 추가
반복되는 코드를 줄이기 위한 고차 함수 및 공통 props 처리
상태는 최상위(`Steve`)에서 관리하며 props로 자식에게 전달

⚡️ 개인적인 도전

`객체 불변성`을 지키며 상태 업데이트하기
`컴포넌트 트리 설계`, `props 흐름`, `코드 리팩토링`에 집중
Mermaid 다이어그램으로 구조 시각화도 도입해봄

이 글은 프로젝트를 진행하면서 마주한 오류들, 그 해결 과정, 리팩토링 아이디어까지 순차적으로 정리한 실전 기록입니다.

다이어그램

<Notion을 통해 만든 Mermaid>

주요 에러 & 해결 과정

❌ 객체에 .map() 사용

function earlySteve(){
	return {
		head: "",
		body: "",
		leg: "",
	}
}

const [armors, setArmors] = useState(earlySteve);
setArmors(armors.map(...)) // 오류 발생

map()은 배열 전용 메서드

✔ Object.entries()로 수정:

Object.entries(armors).map(([part, material]) => (
  <li key={part}>{part}: {material}</li>
));

❌ JSX 안에서 const, for 사용

setArmors((prev) => (
  const update = {}; // ❌ SyntaxError
  ...
));

✔ 블록 바디 사용 + return 명시 필요

setArmors((prev) => {
  const update = {};
  for (const part in prev) {
    update[part] = minerals[randIdx(minerals)];
  }
  return update;
});

❌ JSX에서 객체 직접 렌더링

<div>{armors}</div> // [object Object]

에러 사진

✔ 해결: 객체 리터럴 안에서 불변성 지키기

setArmors(prev => ({
  ...prev,
  head: minerals[randIdx(minerals)],
}));

❌ HeadArmor를 눌러도 전체 아머가 바뀜

const changeMineral = () => {
	setArmors(prev => ({
			...prev,
			head: minerals[randIdx(minerals)],
			body: minerals[randIdx(minerals)],
			leg: minerals[randIdx(minerals)],
		}))
};


// JSX 구현부분 !
<div className="Head">
	<HeadArmor changeMineral={changeMineral} setColor={mineralToHex(armors.head)} />
</div>
<div className="Body">
	<BodyArmor changeMineral={changeMineral} setColor={mineralToHex(armors.body)} />
</div>
<div className="Leg">
	<LegArmor changeMineral={changeMineral} setColor={mineralToHex(armors.leg)} />
</div>

좋지 않은 해결: 각각의 부위마다 changeHead, changeBody, changeLeg 함수를 만들어 해결

const changeHead = () => {
	setArmors(prev => ({
			...prev,
			head: minerals[randIdx(minerals)],
		}))
};
const changeBody = () => {
	setArmors(prev => ({
			...prev,
			body: minerals[randIdx(minerals)],
		}))
};
const changeLeg = () => {
	setArmors(prev => ({
			...prev,
			leg: minerals[randIdx(minerals)],
		}))
};

return (
		<div className="Steve">
			<div className="Head">
				<HeadArmor changeMineral={changeHead} setColor={mineralToHex(armors.head)} />
			</div>
			<div className="Body">
				<div className="LeftArm"></div>
				<div className="RightArm"></div>
				<BodyArmor changeMineral={changeBody} setColor={mineralToHex(armors.body)} />
			</div>
			<div className="Leg">
				<div className="centerLine"></div>
				<LegArmor changeMineral={changeLeg} setColor={mineralToHex(armors.leg)} />
			</div>
			<button onClick={allChange} >allChange</button>
			<button onClick={reset}>Reset</button>
		</div>
	)

이러한 방식은 코드의 중복을 늘리고 너무 길어지기 때문에 엄청 안좋은 방법이라고 생각이 듭니다
따라서 아래처럼 고차 함수로 리팩토링 하길 추천드립니다

♻️ 리팩토링: 커링 패턴 + 공통 Props

함수를 파라미터화한 커링 패턴

const changeMineral = (part) => {
  setArmors(prev => ({
    ...prev,
    [part]: minerals[randIdx(minerals)],
  }));
}

컴포넌트 내부:

<HeadArmor changeMineral={() => changeMineral('head')} ... />
<BodyArmor changeMineral={() => changeMineral('body')} ... />

✂️ 중복 제거용 공통 props:

export default function BodyArmor({changeMineral, setColor}){
	const commonStyle = { backgroundColor: setColor };
 	 const commonProps = { onClick: changeMineral, style: commonStyle };
	return (
	<>
		<div className="LeftArm"  {...commonProps}></div>
		<div className="RightArm" {...commonProps}></div>
		<div className="BodyArmor"{...commonProps}></div>
			
	</>
	)
	
}

최종 결과물

각 아머 클릭 시 해당 부위 색상만 변경
버튼 2개로 전체 변경 / 초기화 가능
깃 주소

회고

군대 일과시간에 나오는 짬 시간에 틈틈히 손 코딩으로 컴포넌트 설계 및 상태 관리를 해나갔습니다 실수한 부분을 통해 GPT와 Gemini에게 물어가며 JSX 문법, React 불변성, 상태 관리, 컴포넌트 설계를 확실히 익혔습니다

✨작은 실전에서 큰 배움을 얻었습니다.
앞으로도 "나만의 프로젝트 → 문제 발생 → 해결 → 리팩토링" 루틴을 계속 이어나가며 성장할 계획입니다. 감사합니다!

✅ 사용된 기술

React (useState)
Mermaid 다이어그램
Component Props
JSX 문법 규칙
고차 함수로 리팩토링

‍ 개발자 정보

기술 스택: HTML5, CSS, JavaScript, React, Git
깃허브: guswnsj0112
블로그: joon0112.tistory.com
인스타그램: https://www.instagram.com/joonplan.dev/

읽잇(ReadIt) - 감성 독서기록 웹서비스, MVP 1차 개발 회고

dev_Hyeonjoon — Fri, 11 Jul 2025 23:23:36 +0900

https://readit-38t1.onrender.com

프로젝트 개요

군 복무 중 처음으로 다량의 책을 읽게 되었고,
그 감정을 기록하고 싶다는 생각이 들었습니다.
마침 React를 공부하던 시기여서,
감성 독서 기록 웹서비스 '읽잇(ReadIt)' 을 직접 만들게 됐습니다

서비스명 : 읽잇 (ReadIt)
- 이유: 단순한 기록이 아닌, 다시 읽게 만드는 감정 저장소를 만들고 싶어서
개발 기간: 약 2주 (MVP 기준)
사용 기술: React, CSS, Frmaer
배포: Netlify
GitHub: https://github.com/guswnsj0112/readIt

서비스 바로가기

✍️ 기획 과정

"프론트? 백엔드? PM? 아예 그만둘까?"
고민만 쌓이던 시기, GPT에게 고민을 털어놓으면서 프로젝트가 시작됐습니다.

GPT와 대화하며 기획 방향 설정
Notion으로 기능 분해 및 일정 플래닝
Frmaer AI를 사용해 감성 UI시안 제작

기획 노션 링크: 읽잇 MVP 플래너

디자인& 로고

로고는 GPT가 제안한 텍스트에서 선정
로고의 배경 투명화는 Photoroom으로 해결
Framer로 Nav 포함 전체 레이아웃 구성

디자인 미리 보기: Framer 디자인

개발 구조 & 작업 내용

readIt/
├── public/
├── src/
│   ├── components/
│   ├── pages/
│   ├── styles/
│   └── App.jsx
├── package.json
└── README.md

(일부 생략)

️ 아쉬운 점

"독서 기록 시작하기" 버튼을 누르면 감상문 작성 페이지로 이동시켜했으나, 입원 일정으로 인해 현재는 랜딩 페이지까지만 배포한 상태입니다.

저는 현재 현역 병사로써 입원하게 되면 어떤 코딩도 할 수 없기에.... 그전에 회고라도 하고 싶어서 글을 남깁니다
지금은 잠시 쉬지만, 다시 돌아와 완성할 계획입니다.
- 감성 저장 기능 및 감성 문구 불러오기 기능은 추후 개발 예정

‍ 느낀 점

사실 이 프로젝트를 시작하게 된 이유는 저의 방황 때문이었습니다.

백엔드로 갈까?
프론트엔드로 갈까?
아니면 개발자를 포기할까...?
혹시 개발 PM이라도 해볼까?

이런 고민들이 계속 쌓이던 중,
너무 답답해서 GPT에게 고민을 털어놓았고,
그 대화가 시작이 되어 이 프로젝트가 만들어졌습니다.

비록 Google Books API 연동 같은 부분에선
GPT에게 너무 의존했다는 자괴감도 있었지만,
입원 전에 랜딩 페이지를 완성했다는 사실 하나만으로도
스스로에게 굉장히 자랑스럽고, 감사한 순간이었습니다.

아직 제 진로는 100% 확실하진 않지만,
하나 분명해진 건 있습니다.

“전역 후 복학한다면, 꼭 융합소프트웨어로 전과하자.”
이건 이번 프로젝트 덕분에 더욱 확실해졌습니다.

회고 한 줄 요약

기획과 디자인은 힘들었으나 랜딩 페이지가 완성된 순간. 난 내가 멋있었다

‍ 개발자 정보

이름: 장현준 (HyunJun Jang)
GitHub: @guswnsj0112
블로그: https://joon0112.tistory.com

사지방 + ChatGPT = A+ | 군 e러닝 효율적 공부법

dev_Hyeonjoon — Thu, 19 Jun 2025 20:04:37 +0900

군 생활, 단순히 흘려보낼 시간일까요? 저는 아니라고 생각했습니다. 복무 중에도 목표가 있다면, 우리는 그 시간을 ‘성장’으로 바꿀 수 있습니다.

‍♂️ 군 e러닝을 선택한 이유

군 생활을 하며 한 가지 다짐이 있었습니다.
“절대로 시간을 헛되이 보내지 말자.”

그 다짐은 단순한 의욕이 아니라, 복학 후 전과를 위한 GPA 관리라는 현실적인 목표로 이어졌고, 그 첫 실천으로 군 e러닝 수강을 시작하게 됐습니다.

또한 저는 “군대에서도 충분히 공부하고 A+을 받을 수 있다”는 것을 제 자신에게 증명해보고 싶었습니다.
그리고 복학 후에도 쓸 수 있는 효율적인 공부 루틴을 만들기 위해 실험적으로 다양한 도구도 활용해보기로 했죠.

과목 선택과 전략

제가 선택한 과목은 「인체안의 전쟁」 입니다.

선택 이유?

사지방 특성상 어떤 프로그램도 설치할 수 없어서
팀플이 없는 과목을 찾았고
- 훈련이나 외출로 인해 팀에 피해를 줄 수 있는 과목은 피하고 싶었기 때문입니다.

결과적으로 ‘혼자서도 계획적으로 밀고 나갈 수 있는’ 과목이 가장 적합했고, 자연스럽게 이 과목을 선택하게 되었습니다.

공부 방법 & 루틴

수업 자료는 저작권으로 인해 공유하지 못하지만, 공부 방식에 대해서는 자세히 설명드릴 수 있어요.

⏰ 공부 시간

평일: 약 1시간씩
주말: 2~3시간 정도 확보
(※ 프론트엔드 공부도 병행했기 때문에 ‘적게, 하지만 꾸준하게’를 핵심 전략으로 삼았습니다.)

공부 방법 요약

강의 시청 + 노션 필기
- 강의 내용을 최대한 세세하게 정리
- 정리한 노트를 PDF로 추출
AI 도구 활용
- ilovepdf로 주차별 PDF 압축
- ChatGPT, Gemini, NotebookLM을 활용하여 30문제 + 해설 생성
- 모르는 개념은 AI에게 세세하게 설명 요청

이 과정에서 AI 도구는 보조교사의 역할을 톡톡히 해냈습니다.
시험 공부를 체계적으로 할 수 있었고, 반복 학습도 훨씬 쉬워졌습니다.

결과 & 느낀 점

저는 군대에서도 A+를 받을 수 있었습니다.

이 경험을 통해 느꼈던 건 다음과 같습니다:

AI 시대에 도구를 적극 활용하는 것이 효율이다
군 복무 중이라도 충분히 성장하고 목표를 달성할 수 있다
내가 직접 만든 루틴과 도구 세트는 복학 후에도 그대로 활용 가능하다

군 e러닝 A+ 꿀팁 요약

항목팁

과목 선택	팀플 없는 과목 추천, 사지방 환경 고려
공부 시간	적게라도 꾸준하게 (1일 30분~1시간)
기록 방식	노션에 꼼꼼히 필기 후 PDF 추출
AI 활용	강의 정리 → 문제 생성 → 복습 최적화
태도	‘성장 루틴 만들기’에 집중

‍ 이런 분들께 추천합니다!

군 생활 중 헛되지 않은 시간을 보내고 싶은 분
복학 후 GPA를 올리고 싶은 예비 복학생
AI 도구를 실전 공부에 접목해보고 싶은 분

✨ 마무리하며

저는 앞으로도 이 루틴을 발전시켜 나가며,
복학 후에도 AI와 함께 공부 효율을 극대화할 계획입니다.

“당신의 군 생활도, 분명 성장의 한 챕터가 될 수 있습니다.
지금의 시간을 어떻게 쓰느냐가, 앞으로의 나를 만듭니다.”