😀
fistkim TECH BLOG
  • Intro
  • 강의
    • Reactive Programming in Modern Java using Project Reactor
      • Reactor execution model 1
      • Reactor execution model 2
      • Reactor execution model 3 - parallelism
      • Reactor execution model 4 - overview
      • Transform
      • Combine
      • Side Effect Methods
      • Exception/Error handling
      • retry, retryWhen, repeat
      • BackPressure
      • Cold & Hot Streams
    • NEXTSTEP 클린코드 with java 9기
      • 정리노트
    • NEXTSTEP DDD 세레나데 2기
      • CH01 도메인 주도 설계 이해
      • CH02 크게 소리 내어 모델링 하기
      • CH03 도메인 주도 설계 기본 요소
      • CH04 도메인 주도 설계 아키텍처
      • CH05 도메인 이벤트
    • NEXTSTEP 인프라 공방 1기
      • 망 분리하기
      • 통신 확인하기
      • 도커 컨테이너 이해하기
      • [미션 1] 서비스 구성하기 실습
      • [미션 2] 서비스 배포하기 실습
      • 서버 진단하기
      • 어플리케이션 진단하기
      • [미션 3] 서비스 운영하기
      • 웹 성능 진단하기
      • 부하 테스트
      • k6
      • [미션 4] 성능 테스트
      • 리버스 프록시 개선하기
      • 캐싱 활용하기
      • [미션 5] 화면 응답 개선하기
      • Redis Annotation 및 설정
      • 인덱스 이해하기 & DB 튜닝
      • [미션 6-1] 조회 성능 개선하기
      • [미션 6-2] DB 이중화 적용
    • NEXTSTEP 만들면서 배우는 Spring 3기
      • CH01 올바른 방향 바라보기
      • CH02 HTTP 이해 - 웹 서버 구현
        • HTTP 파싱
        • HTTP 웹 서버 구현
      • CH03 MVC - @MVC 프레임워크 구현
        • Servlet 다시 짚기
        • Cookie, Session 다시 짚기
        • MVC 프레임워크 구현
      • CH04 나만의 라이브러리 구현
      • CH05 DI - DI 프레임워크 구현
      • CH06 Aspect OP
    • 스프링 시큐리티
      • 스프링 시큐리티 아키텍처
      • WebAsyncManagerIntegrationFilter
      • SecurityContextPersistenceFilter
      • HeaderWriterFilter
      • CsrfFilter
      • (+) 스프링 시큐리티 + JWT
      • (+) 마치며
    • 더 자바, 코드를 조작하는 다양한 방법
      • CH01 JVM 이해하기
      • (+) 클래스 로더 이해하기
      • CH02 바이트 코드 분석 및 조작
      • (+) jacoco
      • CH03 리플렉션
      • CH04 다이나믹 프록시
      • CH05 애노테이션 프로세서
    • 더 자바, 애플리케이션을 테스트하는 다양한 방법
      • CH01 JUnit 5
      • CH02 Mockito
      • (+) Spy vs Mock
      • CH03 도커와 테스트
      • CH04 성능 테스트
      • (+) VisualVM
      • (+) 테스트 자동화
      • CH05 운영 이슈 테스트
      • CH06 아키텍처 테스트
    • 모든 개발자를 위한 HTTP 웹 기본 지식
      • CH01 인터넷 네트워크
      • CH02 HTTP 기본
      • CH03 HTTP 메서드 속성
      • CH04 HTTP 메서드 활용
      • CH05 HTTP 상태코드
      • CH06 HTTP 헤더1 - 일반 헤더
      • CH07 HTTP 헤더2 - 캐시와 조건부 요청
      • (+) HTTPS 원리
    • 스프링 프레임워크 핵심 기술
      • CH01 IOC 컨테이너
      • CH02 AOP
      • (+) 스프링 의존성 관리
      • (+) 생성자 주입 장점
    • 코딩으로 학습하는 GoF의 디자인 패턴
      • 객체 생성
        • 싱글톤 패턴
        • 팩토리 메소드 패턴
        • 추상 팩토리 패턴
        • 빌더 패턴
        • 프로토타입 패턴
      • 구조
        • 어댑터 패턴
        • 브릿지 패턴
        • 컴포짓 패턴
      • 행동
        • (작성중)
    • 실전 Querydsl
      • CH01 프로젝트 환경구성
      • CH02 예제 도메인 모델
      • CH03 기본문법
      • CH04 중급 문법
      • CH05 실무활용 (스프링 데이터 JPA와 Querydsl)
      • CH06 스프링데이터JPA 가 제공하는 Querydsl 기능
      • (+) 별칭(alias)
      • (+) Slice 쿼리
    • 스프링 데이터 JPA
      • CH01 핵심개념이해 1
      • CH02 핵심개념이해 2
      • CH03 핵심개념이해 3
      • CH04 Spring Data Common
      • CH05 Spring Data JPA
    • 실전! 스프링 부트와 JPA 활용2 - API 개발과 성능 최적화
      • CH01 지연 로딩과 조회 성능 최적화
      • CH02 컬렉션 조회 최적화
      • CH03 전체 정리
    • 초보를 위한 쿠버네티스 안내서
      • CH01 쿠버네티스 시작하기
      • CH02 쿠버네티스 알아보기
      • CH03 쿠버네티스 실습 준비
      • CH04 쿠버네티스 기본 실습
    • Flutter Provider Essential
      • CH01 Introduction
      • CH02 Provider Overview
      • CH03 TODO App
      • CH04 Weather App
      • CH05 Firebase Authentication App
    • Flutter Bloc Essential
      • CH01 Introduction
      • CH02 Bloc Overview
      • CH03 TODO App
      • CH04 Weather App
      • CH05 Firebase Authentication App
    • Flutter Advanced Course - Clean Architecture With MVVM
      • CH01 Introduction
      • CH02 Clean Architecture 4 Layer
      • CH03 MVVM
      • CH04 Data Layer
      • (+) Data Layer - response to model
      • (+) Data Layer - Network
      • CH05 Domain Layer
      • CH06 Presentation Layer
      • CH07 Application Layer
      • (+) Application Layer - l10n
      • (+) Application Layer - DI
      • (+) Application Layer - environment
    • 자바 알고리즘 입문
      • CH01 문자열
      • CH02 Array(1, 2 차원 배열)
      • CH03 Two pointers, Sliding window[효율성: O(n^2)-->O(n)]
      • CH04 HashMap, TreeSet (해쉬, 정렬지원 Set)
      • CH05 Stack, Queue(자료구조)
      • CH06 Sorting and Searching(정렬, 이분검색과 결정알고리즘)
      • CH07 Recursive, Tree, Graph(DFS, BFS 기초)
      • CH08 DFS, BFS 활용
      • CH09 Greedy Algorithm
      • CH10 dynamic programming(동적계획법)
  • 도서
    • 만들면서 배우는 클린 아키텍처
      • 학습목표
      • CH01 계층형 아키텍처의 문제는 무엇일까?
      • CH02 의존성 역전하기
      • CH03 코드 구성하기
      • CH04 유스케이스 구현하기
      • CH05 웹 어댑터 구현하기
      • CH06 영속성 어댑터 구현하기
      • CH07 아키텍처 요소 테스트하기
      • CH08 경계 간 매핑하기
      • CH09 어플리케이션 조립하기
      • CH10 아키텍처 경계 강제하기
      • CH11 의식적으로 지름길 사용하기
      • CH12 아키텍처 스타일 결정하기
    • 클린 아키텍처
      • 들어가며
      • 1부 소개
        • 1장 설계와 아키텍처란?
        • 2장 두 가지 가치에 대한 이야기
      • 2부 벽돌부터 시작하기: 프로그래밍 패러다임
        • 3장 패러다임 개요
        • 4장 구조적 프로그래밍
        • 5장 객체 지향 프로그래밍
        • 6장 함수형 프로그래밍
      • 3부 설계 원칙
        • 7장 SRP: 단일 책임 원칙
        • 8장 OCP: 개방-폐쇄 원칙
        • 9장 LSP: 리스코프 치환 원칙
        • 10장 ISP: 인터페이스 분리 원칙
        • 11장 DIP: 의존성 역전 원칙
      • 4부 컴포넌트 원칙
        • 12장 컴포넌트
        • 13장 컴포넌트 응집도
        • 14장 컴포넌트 결합
      • 5부
        • 15장 아키텍처란?
    • 스프링 입문을 위한 자바 객체 지향의 원리와 이해
      • CH01 사람을 사랑한 기술
      • CH02 자바와 절차적/구조적 프로그래밍
      • CH03 자바와 객체 지향
      • (+) 자바 코드 실행에 따른 메모리 적재과정
      • CH04 자바가 확장한 객체 지향
      • CH05 객체 지향 설계 5 원칙 - SOLID
      • CH06 스프링이 사랑한 디자인 패턴
      • CH07 스프링 삼각형과 설정 정보
      • (부록) 람다(lambda)
    • 객체지향의 사실과 오해
      • CH01 협력하는 객체들의 공동체
      • CH02 이상한 나라의 객체
      • CH03 타입과 추상화
      • CH04 역할, 책임, 협력
      • CH05 책임과 메시지
      • CH06 객체 지도
      • CH07 함께 모으기
      • (+) 인터페이스 개념 바로잡기
    • 도메인 주도 개발 시작하기
      • CH01 도메인 모델 시작하기
      • CH02 아키텍처 개요
      • CH03 애그리거트
      • CH04 리포지터리와 모델 구현
      • CH05 스프링 데이터 JPA를 이용한 조회 기능
      • CH06 응용 서비스와 표현 영역
      • CH07 도메인 서비스
      • CH08 애그리거트 트랜잭션 관리
      • CH09 도메인 모델과 바운디드 컨텍스트
      • CH10 이벤트
      • CH11 CQRS
    • 자바 ORM 표준 JPA 프로그래밍
      • CH01 JPA 소개
      • CH02 JPA 시작
      • CH03 영속성 관리
      • CH04 엔티티 매핑
      • CH05 연관관계 매핑 기초
      • CH06 다양한 연관관계 매핑
      • CH07 고급 매핑
      • CH08 프록시와 연관관계 관리
      • CH09 값 타입
      • CH10 객체지향 쿼리 언어
      • CH11 웹 애플리케이션 제작
      • CH12 스프링 데이터 JPA
      • CH13 웹 애플리케이션과 영속성 관리
      • CH14 컬렉션과 부가 기능
      • CH15 고급 주제와 성능 최적화
      • CH16 트랜잭션과 락, 2차 캐시
    • 소프트웨어 세상을 여는 컴퓨터과학
      • CH01 컴퓨터 과학 소개
      • CH02 데이터 표현과 디지털 논리
    • 이펙티브 자바
      • 1 장 들어가기
      • 2장 객체 생성과 파괴
        • [01] 생성자 대신 정적 팩터리 메서드를 고려하라
        • [02] 생성자에 매개변수가 많다면 빌더를 고려하라
        • [03] private 생성자나 열거 타입으로 싱글턴임을 보증하라
        • [04] 인스턴스화를 막으려거든 private 생성자를 사용하라
        • [05] 자원을 직접 명시하지 말고 의존 객체 주입을 사용하라
        • [06] 불필요한 객체 생성을 피하라
        • [07] 다 쓴 객체 참조를 해제하라
        • [08] finalizer 와 cleaner 사용을 피하라
        • [09] try-finally 보다는 try-with-resources 를 사용하라
      • 3장 모든 객체의 공통 메서드
        • [10] equals는 일반 규약을 지켜 재정의하라
        • [11] equals 를 재정의하려거든 hashCode도 재정의하라
        • [12] toString 을 항상 재정의하라
        • [13] clone 재정의는 주의해서 진행하라
        • [14] Comparable 을 구현할지 고려하라
      • 4장 클래스와 인터페이스
        • [15] 클래스와 멤버의 접근 권한을 최소화하라
  • 토픽
    • 서버 모니터링
      • CPU 사용량
      • 메모리 사용량
      • 스레드 풀
    • Spring Boot Monitoring
      • Spring actuator
      • Spring eureka
      • Prometheus
      • grafana
      • Spring actuator + Prometheus + grafana
    • JAVA 데일리 토픽
      • 메모리 누수(memory leak)
      • 객체 참조의 유형
      • 커스텀 스레드 풀
      • Mark And Compact
      • serialVersionUID 이해하기
      • 함수형 인터페이스
      • 메소드 참조
      • equals()와 hashCode()가 무엇이고 역할이 무엇인지
      • StringBuffer vs StringBuilder
      • String vs StringBuilder, StringBuffer
      • String interning
    • JAVA GC
    • 프로그래머스 문제 풀기
      • 해시
      • 스택/큐
      • 힙(Heap)
      • 정렬
      • 완전탐색
      • DFS/BFS
    • 데이터베이스 구성 및 작동 흐름
    • 데이터베이스 JOIN 원리
    • 객체지향생활체조 원칙
    • 상태(state), 상속(inheritance), 합성(composition) 의 상관관계
    • java enum은 메모리에 언제, 어떻게 할당되는가
    • Checked Exception vs UnChecked Exception
    • Reactive Streams 원리탐구 - 간단한 예제 직접 작성해보기
    • Flutter Basic
    • Flutter StatefulWidget 생명주기
    • Flutter 가 위젯을 그리는 원리
    • Flutter 클린 아키텍처
      • application layer
        • 패키지 구조 및 레이어 설명
        • environment
        • dependency injection
        • go_router
        • foreground & background
        • 다국어처리 (l10n, i18n)
        • Global 처리(시스템 점검, fore->back 등)
        • connection_manager
        • permission_manager
        • push_notification_manager
        • firebase 연동
      • data layer
        • 패키지 구조 및 레이어 설명
        • network
        • repository
      • domain layer
        • 패키지 구조 및 레이어 설명
      • presentation layer
        • 패키지 구조 및 레이어 설명
        • resources
    • 기술 관련 포스팅 읽기
  • 기타
    • 작업일지
      • 2023. 10
      • 2023. 09
      • 2023. 08
      • 2023. 07
      • 2023. 06
      • 2023. 05
      • 2023. 04
      • 2023. 03
      • 2023. 02
      • 2023. 01
      • 2022. 12
    • Business Model
      • 아이디어 불패의 법칙
      • 린 모바일 앱 개발
      • 린 스타트업
      • 제로투원
      • MIT 스타트업 바이블
      • 린치핀
    • 백로그 종합
Powered by GitBook
On this page
  • 좋은 설계란
  • 높은 응집도와 낮은 결합도를 추구해야하는 이유
  • 응집도란 무엇이며 응집도가 높으면 뭐가 좋은가
  • 결합도란 무엇이며 결합도가 낮으면 뭐가 좋은가
  • SOLID 는 결국 무엇인가
  • SRP(Single Responsibility Principle, 단일 책임 원칙)
  • 의미
  • 어떻게 SRP 를 달성할까
  • 메소드 단위에서도 SRP 는 적용된다
  • OCP(Open-Closed Principle, 개방-폐쇄 원칙)
  • 의미
  • 어떻게 OCP 를 달성할까
  • LSP(Liskov Substitution Principle, 리스코프 치환 원칙)
  • 의미
  • 이게 왜 좋은 설계에 도움이 되는걸까
  • 어떻게 LSP 를 달성할까
  • ISP(Interface Segregation Principle, 인터페이스 분리 원칙)
  • 의미
  • 어떻게 ISP 를 달성할까
  • DIP(Dependency Inversion Principle, 의존역전원칙)
  • 의미
  • 고수준, 저수준이 무슨 수준을 말하는건가
  • 어떻게 DIP 를 달성할까
  1. 도서
  2. 스프링 입문을 위한 자바 객체 지향의 원리와 이해

CH05 객체 지향 설계 5 원칙 - SOLID

좋은 설계란

여러 답이 나올 수 있겠지만 객체지향의 사실과 오해 책에서 여러차례 언급되었듯이 '수정 비용이 적은' 설계라고 생각한다. 수정 비용이 적다는 말은 신규 기능이 있을때 다른 것들을 고친다던가 하는 비용이 최소화된 설계인 것이다. 즉, 신규 기능을 개발하여 붙이기 용이한 구조라는 것이다. 한편으로 기존의 기능에 변경 사항이 발생하더라도 기존의 것들에 영향이 최소화된 구조라서 손쉽게 변경할 수 있다는 것이다. 더하든, 덜어내든, 변경시킴에 있어 그 비용이 적은 것을 의미한다.

보통 높은 응집도와 낮은 결합도를 가진 설계가 수정 비용이 적다고 생각한다.

높은 응집도와 낮은 결합도를 추구해야하는 이유

응집도란 무엇이며 응집도가 높으면 뭐가 좋은가

어떠한 객체의 응집도가 높다는 것은 해당 객체에 주어진 책임이 분명하고, 오로지 이 책임의 완벽한 수행을 위해서 객체가 설계되어 있다는 것을 의미한다. 이것을 조금 확장적으로 생각해보면 각 객체가 응집도가 높다는 것은 곧 각 객체는 다른 객체들과 책임이 겹치지 않고 각자 맡은 바에 대해서만 집중하고 있다는 것이다. 이는 곧 수정이 발생 했을때 응집도가 명확하므로 수정사항에 해당하는 특정 객체만 변경하면 될 확률이 높다는 것을 의미한다.

결합도란 무엇이며 결합도가 낮으면 뭐가 좋은가

결합도란 서로 다른 객체간의 의존도를 이야기한다. 객체 지향의 세계에서 소프트웨어는 곧 객체들의 협력이다. 객체들의 협력은 메세지를 통해서 이뤄지고 각 객체는 최대한 자율성이 보장되어야 수정비용이 가장 낮은 설계가 이뤄진다. 그런데 여기서 결합도가 높다는 것은 객체의 자율성을 떨어트리는 것이다.

특정 객체가 다른 객체에게 'A 해줘' 라고 협력을 요청하고 해당 객체는 자신의 것에만 집중해야하는데 'A를 하는데 이렇게 저렇게 해서 최종적으로 이렇게 줘' 라고 하는 것이 결합도가 높아지는 예시이다. 그러면 결국 해당 기능에 대한 수정이 발생 했을때 수정의 범위가 넓어지고 다른 여러 객체들도 이 객체에 의존하고 있다면 수정 비용은 그만큼 늘어난다.

SOLID 는 결국 무엇인가

SOLID 는 객체 지향 프로그래밍의 세계에서 보다 좋은 설계(높은 응집도, 낮은 결합도)를 위한 방법론 및 원칙들이다.

SRP(Single Responsibility Principle, 단일 책임 원칙)

의미

객체의 책임은 하나여야한다.

어떻게 SRP 를 달성할까

객체의 책임을 '명확하게' 한다. 결국 실제 비즈니스 도메인의 문제를 해결하기 위해서 객체 모델링을 하는 것인데 이 과정에서 어떠한 객체를 만든다면 해당 객체는 반드시 '무엇을 담당시키기 위한' 모델링 의도가 있어야 하며 이 의도가 세밀하여야 한다. 이 논리적 단위가 추상적이지 않고 분명하고 명확해야한다.

그리고 해당 객체는 최대한 자율적이어야 한다. 객체는 결국 메세지를 통해서 협력을 요청받게 되고 이를 수행하는데 이 과정에서 최대한 다른 객체들의 침범을 받지 않고 자율적으로 처리할 수 있는 구조여야 한다.

메소드 단위에서도 SRP 는 적용된다

책에서 좋은 예시를 들고 있는데, 메소드 내에서도 if 문에 따라 분기되는 구조가 있다면 클래스 자체를 구분하여 구현체를 따로 만들어서 SRP를 지킬 수 있도록 하자.

OCP(Open-Closed Principle, 개방-폐쇄 원칙)

의미

확장에 열려있고 변경에 닫혀 있어야 한다. 책에서는 '자신의 확장에는 열려있고, 주변의 변화에 대해서 닫혀있어야 한다' 고 표현하고 있다. 개인적으로 오히려 좀 왜곡된 표현 같다는 생각이 들었다. 그냥 소프트웨어 시스템 자체가 확장에 열려있고 변경에 닫혀있어야 한다고 이해하는 것이 더 적절한 것 같다.

확장에 열려있다는 의미는 확장이 그만큼 용이하다는 것이다. 새로운 요구사항이 있을때 손쉽게 확장시킬 수 있다는 것이다. 한편 변경에 닫혀 있다는 말은 변경을 허용하지 않겠다는 것이 아니라, 변경 발생시 기존의 것들이 '닫혀'있어서 피해를 받지 않는다는 이야기이다. 변경 발생으로 인해서 기존의 코드들이 추가적인 변경이 발생할 일이 없어야 한다는 것이다.

어떻게 OCP 를 달성할까

SOLID 각 규칙들이 의미적으로는 구분되어도 결국 달성하는 방법은 비슷한 측면이 많다. OCP도 마찬가지이다.

OCP를 달성하기 위해서는 추상화를 최대한 이용해야 한다. 변경 및 확장 가능성이 있는 것이 있다면 이에 의존하는 클라이언트 쪽에서는 구체적 객체에 의존하지 않고 추상화된 계층에 의존시키고, 각 세부적 니즈는 구현체에서 풀어내는 형태로 OCP 를 달성한다. 결국 뒤에 이어질 DIP 와 맥락이 이어진다.

LSP(Liskov Substitution Principle, 리스코프 치환 원칙)

의미

상위 타입의 객체를 하위 타입의 객체로 치환해도 프로그램의 동작이 유지되어야 한다.

이게 왜 좋은 설계에 도움이 되는걸까

객체지향의 사실과 오해에서도 나왔듯이 다형성이란 동일한 메세지에 대해서 다양하게 행동하게 되는 객체들의 모습을 의미한다. LSP를 지켰다는 것은 동일한 메세지(협력 요청)에 대해서 A도 B도 C도 모습은 다르지만 협력이라는 근본적은 요구에는 응답하는 것이므로 결국 느슨한 결합을 띄게 된다.

어떻게 LSP 를 달성할까

상위, 하위 클래스 관계는 '분류'의 관점이어야지 '위계'여서는 안된다.

ISP(Interface Segregation Principle, 인터페이스 분리 원칙)

의미

넓은 인터페이스를 특화된 인터페이스로 분리하는 것이 핵심이다.

어떻게 ISP 를 달성할까

클라이언트에는 오로지 필요한 인터페이스만 제공하면 된다. 그만큼 인터페이스들 각각이 명확한 책임을 정의하고 있어야 할 것이며 클라이언트가 이것에 의존하려면 그만큼 정말 합당한 이유가 있어야한다.

DIP(Dependency Inversion Principle, 의존역전원칙)

의미

하위 수준의 모듈은 상위 수준의 모듈에 의존해서는 안 되고, 상위 수준의 모듈은 추상화에 의존해야 한다는 원칙

고수준, 저수준이 무슨 수준을 말하는건가

DIP 에서 이게 핵심이라고 생각한다. 여기서 말하는 수준이란 '추상화의 수준'을 의미한다. 그럼 고수준은 추상화 수준이 매우 높다는 말이 되는데, 추상화 수준이 높은 것이 추상화 수준이 낮은것에 의존한다는 말이 된다.

추상화 수준이 높다는 말은 무슨 말일까? 객체의 책임을 문장으로 표현해보자. 예를 들어서 소프트웨어가 '데이터베이스에 접속해야한다' 는 표현이 있고, 'MySql 에 접속해야한다', 'Oracle 에 접속해야한다' 라는 표현들이 있고 이를 비교해보자. 데이터베이스 벤더사가 무엇이 되었든 가장 큰 맥락에서 '데이터베이스에 접속해야한다' 는 문장이 가장 추상화된 문장이다. 반대로 다른 문장이 구체화된 문장이다.

어떻게 DIP 를 달성할까

'도메인 주도 개발 시작하기 > CH02 아키텍처 개요' 에서 이미 DIP 에 대해서 정리를 해두었다. 복습시 해당 파트를 다시 보기로 한다. 일단 거기서 사용했던 이미지 하나를 여기에도 첨부한다. 결국 추상화를 이용해서 의존의 방향을 역전시키는 것이 핵심이다.

왜 이게 '역전'된다는 걸까? 가 생각나지 않는다면, 아래 DIP 가 실현된 설계에서 중간에 있는 인터페이스 레이어를 제거하고 고수준 모듈이 저수준에 바로 의존 시킨뒤 다시 인터페이스를 넣어보자. 그러면 의존 방향이 역전된다.

PreviousCH04 자바가 확장한 객체 지향NextCH06 스프링이 사랑한 디자인 패턴

Last updated 1 year ago

클라이언트가 자신이 이용하지 않는 메서드에 의존해서는 안 된다는 원칙. 범용적인 인터페이스를 사용해서는 안되고 인터페이스가 용도에 분명하게 구분되어 선언되어야 구현체를 사용하는 클라이언트도 명확하게 사용해야할 인터페이스만 사용할 수 있다. 이 블로그에 정리가 잘 되어 있어서 링크를 남긴다.

https://inpa.tistory.com/entry/OOP-%F0%9F%92%A0-%EC%95%84%EC%A3%BC-%EC%89%BD%EA%B2%8C-%EC%9D%B4%ED%95%B4%ED%95%98%EB%8A%94-ISP-%EC%9D%B8%ED%84%B0%ED%8E%98%EC%9D%B4%EC%8A%A4-%EB%B6%84%EB%A6%AC-%EC%9B%90%EC%B9%99