Encapsulation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 0){
            this.age = age;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        if(initialBalance > 0){
            this.balance = initialBalance;
        }
    }

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if(amount > 0){
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if(amount > 0 && amount <= balance){
            balance -= amount;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class Person:
    def __init__(self, name, age):
        self.__name = name  # private 변수
        self.__age = age    # private 변수

    # getter 메서드
    def get_name(self):
        return self.__name

    # setter 메서드
    def set_age(self, age):
        if age > 0:
            self.__age = age
        else:
            print("나이는 0보다 커야 합니다.")

    def get_age(self):
        return self.__age

# 사용 예시
person = Person("홍길동", 30)
print(person.get_name())  # 홍길동
print(person.get_age())   # 30
person.set_age(35)
print(person.get_age())   # 35
person.set_age(-5)        # 나이는 0보다 커야 합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class BankAccount {
    private double balance; // private으로 직접 접근 차단
    
    public double getBalance() { // public getter로 읽기 허용
        return balance;
    }
    
    public void deposit(double amount) { // 검증 로직 포함
        if (amount > 0) {
            balance += amount;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Product:
    def __init__(self):
        self._price = 0
    
    @property
    def price(self):  # getter
        return self._price
    
    @price.setter
    def price(self, value):  # setter with validation
        if value < 0:
            raise ValueError("가격은 음수일 수 없습니다")
        self._price = value

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class DatabaseConnectionFactory {
    static createConnection(type, config) {
        switch(type) {
            case 'mysql':
                return new MySQLConnection(config);
            case 'postgresql':
                return new PostgreSQLConnection(config);
            default:
                throw new Error('지원하지 않는 데이터베이스 타입');
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

const SessionManager = (function() {
    let currentUser = null; // private 변수
    
    function validateUser(user) { // private 함수
        return user && user.id && user.name;
    }
    
    return { // public 인터페이스
        login: function(user) {
            if (validateUser(user)) {
                currentUser = user;
                return true;
            }
            return false;
        },
        
        getCurrentUser: function() {
            return currentUser ? {…currentUser} : null; // 복사본 반환
        }
    };
})();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

class BankAccount:
    """은행 계좌 클래스 - 캡슐화 구현 예시"""
    
    def __init__(self, account_number, initial_balance=0):
        # Private 속성 (Python 관례상 _로 시작)
        self._account_number = account_number
        self._balance = initial_balance
        self._transaction_history = []
        self.__pin = None  # 더 강한 은닉 (__로 시작)
    
    # Public 메서드 - 외부 인터페이스
    def deposit(self, amount):
        """입금 처리"""
        if self._validate_amount(amount):
            self._balance += amount
            self._record_transaction("입금", amount)
            return True
        return False
    
    def withdraw(self, amount, pin):
        """출금 처리 (PIN 인증 필요)"""
        if self._authenticate(pin) and self._validate_amount(amount):
            if self._balance >= amount:
                self._balance -= amount
                self._record_transaction("출금", amount)
                return True
            else:
                raise ValueError("잔액이 부족합니다")
        return False
    
    @property
    def balance(self):
        """잔액 조회 (읽기 전용)"""
        return self._balance
    
    @property
    def account_number(self):
        """계좌번호 조회 (읽기 전용)"""
        return self._account_number
    
    def set_pin(self, pin):
        """PIN 설정"""
        if len(str(pin)) == 4:
            self.__pin = pin
            return True
        raise ValueError("PIN은 4자리 숫자여야 합니다")
    
    def get_transaction_history(self, pin):
        """거래 내역 조회 (PIN 인증 필요)"""
        if self._authenticate(pin):
            return self._transaction_history.copy()  # 방어적 복사
        raise ValueError("PIN이 일치하지 않습니다")
    
    # Private 메서드 - 내부 구현
    def _validate_amount(self, amount):
        """금액 유효성 검사"""
        return isinstance(amount, (int, float)) and amount > 0
    
    def _authenticate(self, pin):
        """PIN 인증"""
        return self.__pin is not None and self.__pin == pin
    
    def _record_transaction(self, transaction_type, amount):
        """거래 기록"""
        from datetime import datetime
        transaction = {
            'type': transaction_type,
            'amount': amount,
            'timestamp': datetime.now(),
            'balance': self._balance
        }
        self._transaction_history.append(transaction)

# 사용 예시
account = BankAccount("123-456-789", 1000)
account.set_pin(1234)
account.deposit(500)
print(f"현재 잔액: {account.balance}")  # 1500
account.withdraw(200, 1234)
print(f"출금 후 잔액: {account.balance}")  # 1300

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

class UserManager {
    constructor() {
        // Private 필드 (ES2022 문법)
        #users = new Map();
        #currentUser = null;
        #sessionTimeout = 30 * 60 * 1000; // 30분
    }
    
    // Public 메서드
    register(username, password, email) {
        if (this.#validateUserData(username, password, email)) {
            const userId = this.#generateUserId();
            const user = {
                id: userId,
                username: username,
                password: this.#hashPassword(password),
                email: email,
                createdAt: new Date(),
                isActive: true
            };
            
            this.#users.set(userId, user);
            return { success: true, userId: userId };
        }
        return { success: false, error: "유효하지 않은 사용자 데이터" };
    }
    
    login(username, password) {
        const user = this.#findUserByUsername(username);
        if (user && this.#verifyPassword(password, user.password)) {
            this.#currentUser = {
                …user,
                loginTime: new Date()
            };
            this.#setSessionTimer();
            return { success: true, user: this.#getSafeUserData(user) };
        }
        return { success: false, error: "로그인 실패" };
    }
    
    getCurrentUser() {
        if (this.#currentUser && this.#isSessionValid()) {
            return this.#getSafeUserData(this.#currentUser);
        }
        return null;
    }
    
    logout() {
        this.#currentUser = null;
        return { success: true, message: "로그아웃되었습니다" };
    }
    
    // Private 메서드
    #validateUserData(username, password, email) {
        return username && username.length >= 3 &&
               password && password.length >= 8 &&
               email && this.#isValidEmail(email);
    }
    
    #isValidEmail(email) {
        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
        return emailRegex.test(email);
    }
    
    #hashPassword(password) {
        // 실제로는 bcrypt 등을 사용해야 함
        return btoa(password + "salt");
    }
    
    #verifyPassword(password, hashedPassword) {
        return this.#hashPassword(password) === hashedPassword;
    }
    
    #generateUserId() {
        return 'user_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
    }
    
    #findUserByUsername(username) {
        for (let user of this.#users.values()) {
            if (user.username === username) {
                return user;
            }
        }
        return null;
    }
    
    #getSafeUserData(user) {
        const { password, …safeData } = user;
        return safeData;
    }
    
    #isSessionValid() {
        if (!this.#currentUser) return false;
        const now = new Date();
        const loginTime = new Date(this.#currentUser.loginTime);
        return (now - loginTime) < this.#sessionTimeout;
    }
    
    #setSessionTimer() {
        setTimeout(() => {
            if (this.#currentUser) {
                this.#currentUser = null;
                console.log("세션이 만료되었습니다");
            }
        }, this.#sessionTimeout);
    }
}

// 사용 예시
const userManager = new UserManager();
userManager.register("john_doe", "password123", "john@example.com");
const loginResult = userManager.login("john_doe", "password123");
console.log("로그인 결과:", loginResult);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class OrderService:
    def __init__(self):
        self._order_repository = OrderRepository()
        self._inventory_service = InventoryService()
        self._payment_service = PaymentService()
        self._notification_service = NotificationService()
    
    def create_order(self, user_id, items, payment_info):
        """주문 생성 - 복잡한 비즈니스 로직을 캡슐화"""
        try:
            # 1. 재고 확인 (내부 구현 숨김)
            if not self._validate_inventory(items):
                raise InsufficientStockError("재고 부족")
            
            # 2. 주문 생성 (내부 상태 관리)
            order = self._create_order_entity(user_id, items)
            
            # 3. 결제 처리 (외부 의존성 캡슐화)
            payment_result = self._process_payment(order, payment_info)
            
            # 4. 재고 차감 (트랜잭션 관리)
            self._reserve_inventory(items)
            
            # 5. 주문 저장 (데이터 접근 캡슐화)
            saved_order = self._order_repository.save(order)
            
            # 6. 알림 발송 (비동기 처리 캡슐화)
            self._send_notifications(saved_order)
            
            return OrderDTO.from_entity(saved_order)
            
        except Exception as e:
            self._rollback_transaction(order_id)
            raise OrderProcessingError(f"주문 처리 실패: {str(e)}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 문제가 있는 코드 예시
class BadEncapsulation:
    def __init__(self):
        self.important_data = []  # public 필드
    
    def get_data(self):
        return self.important_data  # 직접 참조 반환

# 진단 방법
import ast
import inspect

def analyze_encapsulation_violations(cls):
    """캡슐화 위반 사항 분석"""
    violations = []
    
    # 1. public 필드 검사
    for attr_name in dir(cls):
        if not attr_name.startswith('_') and not callable(getattr(cls, attr_name)):
            violations.append(f"Public 필드 발견: {attr_name}")
    
    # 2. 메서드 시그니처 분석
    for method_name, method in inspect.getmembers(cls, predicate=inspect.ismethod):
        if method_name.startswith('get_') and not method_name.startswith('_'):
            violations.append(f"잠재적 캡슐화 위반 메서드: {method_name}")
    
    return violations

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 개선된 캡슐화 구현
class GoodEncapsulation:
    def __init__(self):
        self._important_data = []  # private 필드
    
    def get_data_copy(self):
        return self._important_data.copy()  # 방어적 복사
    
    def add_data(self, item):
        if self._validate_item(item):
            self._important_data.append(item)
    
    def _validate_item(self, item):  # private 메서드
        return item is not None and len(str(item)) > 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 문제가 있는 코드
class OverAccessors:
    def __init__(self):
        self._name = ""
        self._age = 0
        self._email = ""
    
    # 모든 필드에 대한 Getter/Setter (불필요함)
    def get_name(self): return self._name
    def set_name(self, name): self._name = name
    # … 모든 필드에 대해 반복

# 개선된 코드 - Tell, Don't Ask 원칙 적용
class BetterDesign:
    def __init__(self, name, age, email):
        self._name = name
        self._age = age
        self._email = email
    
    def introduce_yourself(self):
        """객체에게 행동을 요청"""
        return f"안녕하세요, {self._name}입니다. {self._age}세입니다."
    
    def send_welcome_email(self):
        """객체가 자신의 데이터를 활용해 행동"""
        return f"{self._email}로 환영 메일을 발송했습니다."
    
    @property
    def name(self):  # 꼭 필요한 경우만 읽기 전용으로 제공
        return self._name

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 컴포지션을 활용한 해결
class Engine:
    def __init__(self):
        self._power = 100
        self._fuel_level = 50
    
    def start(self):
        if self._fuel_level > 0:
            return "엔진 시동"
        return "연료 부족"
    
    def get_status(self):
        return {"power": self._power, "fuel": self._fuel_level}

class Car:
    def __init__(self):
        self._engine = Engine()  # 상속 대신 컴포지션 사용
        self._speed = 0
    
    def start_car(self):
        result = self._engine.start()
        if "시동" in result:
            return "차량 시동 완료"
        return "시동 실패: " + result
    
    def get_engine_status(self):
        return self._engine.get_status()  # 위임을 통한 접근

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import threading
from contextlib import contextmanager

class ThreadSafeBankAccount:
    def __init__(self, initial_balance=0):
        self._balance = initial_balance
        self._lock = threading.RLock()  # 재진입 가능한 락
    
    @contextmanager
    def _thread_safe_operation(self):
        """스레드 안전 연산을 위한 컨텍스트 매니저"""
        self._lock.acquire()
        try:
            yield
        finally:
            self._lock.release()
    
    def deposit(self, amount):
        with self._thread_safe_operation():
            if amount > 0:
                self._balance += amount
                return True
        return False
    
    def withdraw(self, amount):
        with self._thread_safe_operation():
            if 0 < amount <= self._balance:
                self._balance -= amount
                return True
        return False
    
    @property
    def balance(self):
        with self._thread_safe_operation():
            return self._balance

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class BankAccount:
    def __init__(self):
        self.__balance = 0  # private 변수
        self._transaction_count = 0  # protected 변수
        
    def deposit(self, amount):
        """입금 메서드"""
        if amount > 0:
            self.__balance += amount
            self._transaction_count += 1
            return True
        return False
    
    def withdraw(self, amount):
        """출금 메서드"""
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            self._transaction_count += 1
            return True
        return False
    
    def get_balance(self):
        """잔액 조회 메서드"""
        return self.__balance

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Employee:  
	def __init__(self, name, salary):  
		self.__name = name # private  
		self.__salary = salary # private
		
	def get_name(self):
		return self.__name
		
	def get_salary(self):
		return self.__salary
		
	def give_raise(self, amount):
		if amount > 0:
			self.__salary += amount

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Database:
    def __init__(self, connection_string):
        self.__connection = self.__connect(connection_string)
        
    def __connect(self, connection_string):
        """데이터베이스 연결 (구현 세부사항 숨김)"""
        # 연결 로직 구현
        pass
        
    def execute_query(self, query):
        """공개 인터페이스"""
        self.__validate_query(query)
        return self.__connection.execute(query)
        
    def __validate_query(self, query):
        """쿼리 유효성 검사 (내부 구현)"""
        # 검증 로직 구현
        pass

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class ShoppingCart:
    def __init__(self):
        self.__items = []
        self.__total = 0
        
    def add_item(self, item):
        """아이템 추가"""
        self.__items.append(item)
        self.__update_total()
        
    def remove_item(self, item):
        """아이템 제거"""
        if item in self.__items:
            self.__items.remove(item)
            self.__update_total()
            
    def __update_total(self):
        """총액 업데이트 (내부 구현 변경 가능)"""
        self.__total = sum(item.price for item in self.__items)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Product:  
	def __init__(self, name, price):  
		self._name = name # protected  
		self.__price = price # private  
		self.id = None # public
		
	@property
	def price(self):
		"""가격 조회를 위한 프로퍼티"""
		return self.__price
		
	@price.setter
	def price(self, new_price):
		"""가격 설정을 위한 프로퍼티"""
		if new_price > 0:
			self.__price = new_price

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class GameCharacter:
    def __init__(self, name):
        self.__name = name
        self.__health = 100
        self.__experience = 0
        
    def take_damage(self, amount):
        """데미지 처리"""
        self.__health = max(0, self.__health - amount)
        self.__check_status()
        
    def gain_experience(self, amount):
        """경험치 획득"""
        self.__experience += amount
        self.__level_up_check()
        
    def __check_status(self):
        """상태 확인 (내부 로직)"""
        if self.__health == 0:
            self.__handle_death()
            
    def __handle_death(self):
        """사망 처리 (내부 로직)"""
        # 사망 관련 로직 구현
        pass