OOP..?

객체지향 프로그래밍(OOP)

1. 개요(Overview)
   객체지향 프로그래밍(Object-Oriented Programming, OOP)은 데이터와 그 데이터를 처리하는 로직을 하나의 객체(Object)단위로 묶어 설계하는 프로그래밍 패러다임이다.

절차지향(Procedure-Oriented)이 "동작 중심" 이라면, 객체지향은 "현실 세계의 개체 모델링 중심"이다.

ex)
절차지향 -> "주문한다 -> 결제한다 -> 배송한다"
객체지향 -> Customer / Order / Payment / Delivery 객체 설계

---

2. 객체지향의 핵심 구성요소
   Class: 객체 설계도
   Object: 클래스의 인스턴스
   Field: 상태(데이터)
   Method: 행동(로직)

   ex)
   	class Car {
   		String color;	//상태
       	int speed;
       
       	void drive() {  //행동
       		System.out.println("Driving");
           }
      }
      

---

3. 객체지향 4대 특징 (Four Pillars)
   3-1 캡슐화 (Encapsulation)
   개념:
   데이터와 메서드를 하나로 묶음
   외부에서 직접 접근 제한
   정보 은닉(Information Hiding)
   목적:
   무결성 보장
   의존성 감소
   유지보수성 향상

   	ex) Java 구현 방식
         	
     class Account {
    		private int balace;
         
        	publice void deposit(int money) {
        		balance += money;
                 }
           public int getBalance() {
             	return balace;
                 }
             }    
             
   private -> 직접 접근 차단

   Getter/Setter -> 간접 접근 허용

   * 핵심 포인트 
    	-> 데이터 보호 + 접근 통제
     

   3-2 상속(Inheritance)
   개념:
   기존 클래스의 속성과 기능을 재사용하여 새로운 클래스 생성
   목적:
   코드 재사용성
   계층 구조 모델링
   유지보수 용이

   		ex)구조
   			class Animal {
         		void eat() {}
             }
         	class Dog extends Animal {
         		void bark() {}
             }
             
     * Animal -> 부모(Super Class)
     * Dog -> 자식(Sub Class)

   특징
   단일 상속(Java)
   다중 상속 -> Interface로 대체
   

3-3 다형성(Polymorphism)
개념:
"하나의 인터페이스, 여러 구현"
즉, 동일 메서드 호출 -> 객체에 따라 다르게 동작

유형:
1. 오버로딩(Compile Time)
void print(int a)
void print(String s)

2. 오버라이딩(Runtime)
   class Animal {
   void sound() {}
   } class Dog extends Animal {
   void sound() {
   System.out.println("Bark");
   }
   }
   

• 핵심
  Animal a = new Dog();
  a.sound(); // Dog 동작 실행
  -> 동적 바인딩(Dynamic Binding)
  

3-4 추상화(Abstraction)
개념:
핵심 기능만 노출
내부 구현 숨김

구현방식:
1) Abstract Class
abstract class Shape {
abstraact void draw();
}

2) Interface
interface Flyable {
void fly();
}

목적:
설계 표준화
결합도 감소
확장성 증가

---

4. 4대 특징 관계 구조
   추상화 -> 설계 모델 정의
   ↓
   상속 -> 구조 확장
   ↓
   다형성 -> 동작 확장
   ↓
   캡슐화 -> 내부 보호

   즉,

   • 추상화 = 설계 철학
   • 상속 = 구조 재사용
   • 다형성 = 행위 확장
   • 캡슐화 = 보호 메커니즘

---

5. 객체지향 설계 5원칙 (SOLID)
   S - Single Responsibility
   클래스는 하나의 책임만
   O - Open / Closed
   확장에는 열림
   수정에는 닫힘
   L - Liskov Substitution
   부모 -> 자식 치환 가능
   I - Interface Segregation
   인터페이스 분리
   D - Dependency Inversion
   구현이 아닌 추상에 의존
   

---

6. 절차지향 vs 객체지향 비교
   구분 /절차지향 /객체지향
   중심 /함수 /객체
   데이터 /공유 /캡슐화
   재사용 /낮음 /높음
   유지보수 /어려움 /용이
   확장성 /낮음 /높음

---

7. Java에서 OOP가 중요한 이유
   7-1 JVM 구조와 결합
   클래스 로딩 단위 실행
   객체 Heap 생성
   GC관리
   즉, OOP 구조 <-> JVM 메모리 모델 직결7.2 프레임워크 설계 기반
   ex:
   DI(Dependency Injection)
   AOP
   Proxy
   모두 OOP 확장 개념
   

** 객체지향은 단순 문법 개념이 아니라:
JVM 메모리 구조와 연결, 프레임 워크 설계 기반, 대규모 시스템 유지보수 핵심

---

8. OOP <-> JVM 메모리 매핑 구조
   객체지향은 "설계 철학", JVM 메모리는 "실행 물리 구조"다.
   즉, OOP 설계 -> 클래스 정의 -> 객체 생성 -> JVM 메모리 배치8.1 JVM Runtime Data Area
   먼저 메모리 구조 기준 축을 잡는다.
   Thread 공유 영역 - Heap, Method Area
   Thread 독립 영역 - Stack, PC Register, Native Method Stack
   8.2 OOP 구성요소별 메모리 매핑
   8.2.1 Class <-> Method Area
   매핑대상
   클래스 정의 정보:
   - 클래스 이름
   - 필드 메타데이터
   - 메서드 바이트코드
   - static 변수
   - Runtime Constant Pool
   흐름
   .class 로딩
   -> ClassLoader
   -> Method Area 저장

           ex)
           	class User {
              	static int count = 0;
                  String name;
                  }

   저장위치
   요소 - 메모리
   User 클래스 정보 - Method Area
   count(static) - Method Area
   name 필드 정의 - Method Area *핵심
   "클래스 설계도는 Method Area" 8.2.2 Object <-> Heap
   매핑대상
   인스턴스, 객체 상태 데이터, 배열
   ex)
   User u1 = new User();
   메모리 생성:
   Heap -> User 객체 생성
   Stack -> u1 참조 저장
   구조
   stack Heap
   u1------> user Object
   -name
   -기타 필드

   *핵심
   "객체 실체는 Heap"

   8.2.3 Reference <-> Stack
   객체지향에서 변수는 객체 자체가 아니라 참조값을 가진다.
   ex)
   User u1 = new User();
   User u2 = u1;
   구조
   Stack Heap
   u1 -
   User Object
   u2 - 특징 : 참조 복사, 객체 복사 아님, GC Root 가능 8.2.4 메서드 실행 매핑
   1) Method <-> Method Area + Stack
   저장 vs 실행 분리
   메서드 코드 - Method Area
   실행 Freame - Stack 실행흐름
   u1.login();
   1. Method Area -> login()코드 존재
   2. Stack -> Frame 생성
   3. 지역변수/파라미터 저장

   Stack Frame구성
   	Local Variables
      Operand Stack
      Return Address
      

   ---

9. OOP 4대 특징 <-> JVM 매핑
   9.1 캡슐화 <-> 접근 제어 + 메모리 보호
   private int balance;

   영향:
   	Method Area -> 필드 메타 정보
    Heap -> 실제 데이터
    접근 -> Method 호출만 허용
    즉, 캡슐화 = 메모리 직접 접근 차단 설계
    

   9.2 상속 <-> Method Area Class 구조 확장
   class Animal {}
   class Dog extends Animal {}

   Method Area 구조:
   	Animal Class Metadata
    Dog Class Metadata
       -> Animal 참조
       
   특징:
   	부모 메서드 재사용
    vtable 기반 탐색
    

   9.3 다형성 <-> Heap 객체 + Stack 참조
   Animal a = new Dog();

   메모리
   	Stack -> Animal 타입 참조
    Heap -> Dog 객체
    
   실행시
   Method Area -> Dog 메서드 호출
   동적 바인딩 수행

   9.4 추상화 <-> 인터페이스 메타데이터
   interface payment {
   void pay();
   }
   저장
   Method Area -> 인터페이스 정의
   Heap -> 구현 객체 생성

   ---

10. 객체 생성부터 GC까지 End-toEnd
    10.1 생성
    User u = new User();

         흐름
      1. ClassLoader -> User 로딩
      2. Method Area -> 클래스 저장
      3. Heap -> 객체 생성
      4. Stack -> 참조 저장

    10.2 사용
    u.login();
    Stack Frame 생성
    Method 실행 10.3 참조 소멸
    u = null;
    GC Root 참조 제거 10.4 GC 대상
    Heap:
    Unreachable Object
    -> Mark
    -> Sweep
    즉, OOP 객체 생명주기 = GC 관리 대상

    ---

11. 메모리 매핑 통합 구조도
    [Method Area]
    - Class Metadata
    - Method Bytecode
    - Static Variables
    - Constant Pool [Heap]
    - Object
    - Instances
    - Arrays[Stack]
    - Reference Variables
    - Method Frames
    - Local Variables
    

---

12. 실무 관점 연결
    12.1 Memory Leak
    원인: Heap 객체 참조 유지, static 컬렉션
    OOP 설계 문제 -> JVM 메모리 문제

    12.2 DI/ IoC 컨테이너
    Spring:
    Bean -> Heap 생성
    Singleton -> GC 대상 아님

    12.3 대용량 트래픽
    객체 생성 과다:
    Young GC증가
    Promotion증가

• OOP 객체는 JVM 어디 저장?
  클래스 메타데이터는 Method Area에 저장되고, 객체 인스턴스는 Heap에 생성되며, 참조 변수와 메서드 실행 프레임은 Stack에 저장된다.

• 다형성 메모리 관점 설명?
  참조 타입은 Stack에, 실제 객체는 Heap에 존재하며 실행 시 동적 바인딩으로 실제 객체 메서드가 호출된다.

• 캡슐화 JVM 영향?
  필드 접근을 메서드로 제한해 Heap 데이터 직접 접근을 제어하는 구조이다.

  ** 최종 요약

  Class 설계 -> Method Area

  Object 생성 -> Heap
  Reference -> Stack
  Method 실행 -> Stack Frame
  GC -> Heap 정리
  즉, OOP는 "논리 설계", JVM 메모리는 "물리 실행 구조"이며 둘은 1:1로 매핑된다.