---
id: wiki-2026-0508-encapsulation-via-access-modifie
title: Encapsulation via Access Modifiers
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Access Modifiers, Visibility Modifiers, Encapsulation]
duplicate_of: none
source_trust_level: A
confidence_score: 0.95
verification_status: applied
tags: [oop, encapsulation, access-modifier, language-design]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: TypeScript
  framework: General
---

# Encapsulation via Access Modifiers

## 매 한 줄
> **"매 internal state 의 hide + boundary 의 explicit"**. 1967 Simula 의 OOP 의 도입 후 매 Bertrand Meyer 의 "Design by Contract", Parnas 의 information hiding 원칙 의 codify — 2026 modern lang 는 `public/private/protected` 의 보다, JS `#private`, Rust module visibility, TS `readonly`, Java `sealed`, C# `init`-only 의 fine-grained capability 의 dominate.

## 매 핵심

### 매 Access modifier 의 종류 (lang 별)
- **Java**: `public`, `protected`, package-private (default), `private`.
- **C#**: `public`, `protected`, `internal`, `private`, `protected internal`, `private protected`, `file`.
- **TypeScript**: `public` (default), `protected`, `private`, `#private` (true private — JS native).
- **Rust**: `pub`, `pub(crate)`, `pub(super)`, `pub(in path)`, default private to module.
- **Python**: convention only — `_underscore` (protected), `__double` (name-mangled).
- **Kotlin**: `public` (default), `internal` (module), `protected`, `private`.

### 매 Encapsulation 의 layer
- **Visibility**: who can see.
- **Mutability**: `final`, `readonly`, `const`, `val`.
- **Identity**: opaque type, newtype.
- **Invariant**: setter validation, factory.

### 매 응용
1. API 의 stable surface 의 maintain (semver).
2. Library author 의 internal refactoring freedom.
3. Test isolation (private — black-box test 의 강제).
4. Security boundary (capability 의 leak 방지).

## 💻 패턴

### TypeScript 의 `#private` (true private)
```typescript
class BankAccount {
  #balance = 0;  // 매 runtime 의 private — TS `private` 의 erase 의 X
  readonly id: string;

  constructor(id: string) { this.id = id; }

  deposit(amount: number) {
    if (amount <= 0) throw new Error('positive only');
    this.#balance += amount;
  }
  get balance() { return this.#balance; }
}

const a = new BankAccount('A1');
// a.#balance = 999;  // SyntaxError 의 compile + runtime
```

### Rust 의 module visibility
```rust
mod auth {
    pub struct User {
        pub name: String,
        password_hash: String,  // 매 module 외부 의 invisible
    }

    impl User {
        pub fn new(name: &str, pw: &str) -> Self {
            User { name: name.into(), password_hash: hash(pw) }
        }
        pub(crate) fn verify(&self, pw: &str) -> bool {
            self.password_hash == hash(pw)
        }
    }
    fn hash(s: &str) -> String { /* ... */ s.into() }
}
```

### Java sealed + record
```java
public sealed interface Shape permits Circle, Square, Triangle {}

public record Circle(double radius) implements Shape {
    public Circle {  // 매 compact constructor 의 invariant
        if (radius < 0) throw new IllegalArgumentException();
    }
}

// 매 exhaustive switch 의 enable
String describe(Shape s) {
    return switch (s) {
        case Circle c -> "circle r=" + c.radius();
        case Square sq -> "square";
        case Triangle t -> "tri";
    };
}
```

### C# init-only + required
```csharp
public class Order
{
    public required string Id { get; init; }      // 매 set 의 only at init
    public DateTime Created { get; init; } = DateTime.UtcNow;
    private decimal _total;
    public decimal Total
    {
        get => _total;
        private set => _total = value >= 0 ? value :
            throw new ArgumentException();
    }
}

var o = new Order { Id = "ORD-1" };  // 매 valid
// o.Id = "X";  // 매 error: init-only
```

### Python 의 convention + property
```python
class Vault:
    def __init__(self, secret):
        self._secret = secret  # 매 protected (convention)
        self.__truly_hidden = "obfuscated"  # 매 _Vault__truly_hidden

    @property
    def secret(self):
        # 매 read-only 의 access
        return f"***{self._secret[-2:]}"

v = Vault("p@ssword")
print(v.secret)  # ***rd
# v.secret = "x"  # AttributeError
```

### Capability-based design (no class)
```typescript
// 매 closure-based 의 information hiding
function makeCounter() {
  let count = 0;
  return {
    inc: () => ++count,
    get: () => count,
    // 매 reset 의 reveal 안 하면 의 capability 의 absent
  };
}
const c = makeCounter();
c.inc(); c.inc();
console.log(c.get()); // 2 — count 의 access 의 X
```

### Friend / internal API (Kotlin)
```kotlin
// 매 internal 의 same module 만의 access
internal class IndexBuilder {
    internal fun rebuild() { /* ... */ }
}

// 매 @PublishedApi 의 inline function 의 internal API 의 publish
@PublishedApi
internal fun secretImpl() = 42

inline fun publicWrapper() = secretImpl()
```

### Newtype 의 opaque ID
```rust
pub struct UserId(u64);  // 매 tuple struct 의 inner 의 private

impl UserId {
    pub fn new(id: u64) -> Self { UserId(id) }
    pub fn value(&self) -> u64 { self.0 }
}

// 매 raw u64 의 mistakenly UserId 로 의 X — type-safe boundary
fn get_user(id: UserId) { /* ... */ }
// get_user(123);  // compile error
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Library API | `pub` 의 minimal surface, internal 의 default |
| Domain model | private field + factory + invariant |
| DTO/value | `record` / `data class` / immutable |
| JS/TS browser code | `#private` (true private) 의 default |
| Cross-module refactoring | `internal`/`pub(crate)` 의 prefer |

**기본값**: most restrictive 의 default. 매 explicit 하 expand.

## 🔗 Graph
- 부모: [[Object-Oriented Programming]] · [[Information Hiding]]
- 변형: [[Module System]]
- 응용: [[API Design]] · [[Library Design]] · [[Refactoring_Best_Practices|Refactoring]]
- Adjacent: [[Abstraction]] · [[SOLID]]

## 🤖 LLM 활용
**언제**: API surface review, accessor pattern 의 generate, visibility audit.
**언제 X**: language-specific subtle case (Kotlin internal mangling 등) 의 verify 필수.

## ❌ 안티패턴
- **Public field**: encapsulation 의 broken — invariant 의 enforce 의 X.
- **Getter/setter for everything**: encapsulation 의 illusion (Tell Don't Ask 위반).
- **Reflection 의 private 의 bypass**: test 의 implementation 의 lock.
- **Java private 의 inner class**: enclosing class 의 implicit access — confusion.
- **TS `private` 의 trust**: runtime 의 erase — `#private` 사용.

## 🧪 검증 / 중복
- Verified (Bloch "Effective Java" Item 15, Parnas 1972 "Decomposition", JLS, ECMA-262).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — TS/Rust/Java/C#/Kotlin/Python access patterns |
