접근 제어자

class Product {
  public name: string; // 'public' 명시
  price: number;      // 접근 제어자를 명시하지 않으면 기본적으로 'public'

  constructor(name: string, price: number) {
    this.name = name;
    this.price = price;
  }

  public getDetails(): string { // 'public' 명시
    return `제품명: ${this.name}, 가격: ${this.price}원`;
  }
}

const laptop = new Product("노트북", 1200000);

console.log(laptop.name);      // '노트북' - public 속성에 외부에서 직접 접근
console.log(laptop.price);     // '1200000' - public 속성에 외부에서 직접 접근
console.log(laptop.getDetails()); // '제품명: 노트북, 가격: 1200000원' - public 메서드 호출

// public 멤버는 외부에서 자유롭게 변경 가능
laptop.price = 1150000;
console.log(laptop.price); // 1150000

class BankAccount {
  private _balance: number; // 계좌 잔액은 private으로 선언하여 외부에서 직접 변경 불가

  constructor(initialBalance: number) {
    if (initialBalance < 0) {
      throw new Error("초기 잔액은 0보다 작을 수 없습니다.");
    }
    this._balance = initialBalance;
  }

  // public 메서드를 통해 private 속성에 간접적으로 접근
  public getBalance(): number {
    return this._balance;
  }

  public deposit(amount: number): void {
    if (amount > 0) {
      this._balance += amount;
      console.log(`${amount}원 입금. 현재 잔액: ${this._balance}원`);
    } else {
      console.log("0원보다 큰 금액을 입금해 주세요.");
    }
  }

  public withdraw(amount: number): void {
    if (amount > 0 && this._balance >= amount) {
      this._balance -= amount;
      console.log(`${amount}원 출금. 현재 잔액: ${this._balance}원`);
    } else {
      console.log("잔액이 부족하거나 유효하지 않은 금액입니다.");
    }
  }
}

const myAccount = new BankAccount(10000);

// console.log(myAccount._balance); // Error: '_balance' 속성은 private이며 'BankAccount' 클래스 내에서만 접근할 수 있습니다.

myAccount.deposit(5000);   // 5000원 입금. 현재 잔액: 15000원
myAccount.withdraw(2000);  // 2000원 출금. 현재 잔액: 13000원
console.log(myAccount.getBalance()); // 13000 - public 메서드를 통해 안전하게 잔액 확인

myAccount.withdraw(20000); // 잔액이 부족하거나 유효하지 않은 금액입니다. (내부 로직에 의해 제어)

class Vehicle {
  protected speed: number; // protected 속성
  constructor(initialSpeed: number) {
    this.speed = initialSpeed;
  }

  protected accelerate(amount: number): void { // protected 메서드
    this.speed += amount;
    console.log(`속도 증가: ${this.speed}`);
  }

  public getCurrentSpeed(): number {
    return this.speed; // public 메서드를 통해 간접 접근
  }
}

class Car extends Vehicle {
  private gear: number = 1;

  constructor(initialSpeed: number, initialGear: number) {
    super(initialSpeed); // 부모 클래스(Vehicle)의 생성자 호출
    this.gear = initialGear;
  }

  public drive(): void {
    console.log(`현재 기어: ${this.gear}`);
    this.accelerate(10); // 자식 클래스에서 부모의 protected 메서드 접근 가능
    console.log(`차량이 ${this.speed}km/h로 주행 중입니다.`); // 자식 클래스에서 부모의 protected 속성 접근 가능
  }

  // public 래퍼를 구현하면 외부 호출을 허용할 수 있습니다.
  // public setProtectedSpeed(newSpeed: number) {
  //   this.speed = newSpeed; // 허용: 파생 클래스 내부에서 자신의 protected 멤버에 접근
  // }
}

const myCar = new Car(60, 3);
myCar.drive(); // 현재 기어: 3, 속도 증가: 70, 차량이 70km/h로 주행 중입니다.
console.log(myCar.getCurrentSpeed()); // 70

// console.log(myCar.speed); // Error: 'speed' 속성은 protected이며 'Vehicle' 클래스 및 해당 하위 클래스 내에서만 접근할 수 있습니다.
// myCar.accelerate(20); // Error: 'accelerate' 속성은 protected이며...

class Student {
  // public, private, protected 또는 readonly를 매개변수 앞에 붙이면
  // 해당 매개변수는 자동으로 클래스의 해당 접근 제어자를 가진 속성으로 선언되고 초기화됩니다.
  constructor(
    public studentId: string, // public 속성으로 선언
    private _studentName: string, // private 속성으로 선언
    protected grade: number, // protected 속성으로 선언
    readonly entryYear: number // readonly + public 속성으로 선언 (읽기 전용)
  ) {
    // 별도로 this.studentId = studentId; 등을 작성할 필요가 없습니다.
  }

  public getInfo(): string {
    return `ID: ${this.studentId}, 이름: ${this._studentName}, 학년: ${this.grade}`;
  }

  // private _studentName에 대한 getter
  get studentName(): string {
    return this._studentName;
  }
}

const s1 = new Student("S001", "김민수", 3, 2022);
console.log(s1.studentId); // S001 (public)
console.log(s1.getInfo()); // ID: S001, 이름: 김민수, 학년: 3

// console.log(s1._studentName); // Error: private
// console.log(s1.grade); // Error: protected

s1.studentId = "S002"; // public이므로 변경 가능
// s1.entryYear = 2023; // Error: readonly이므로 변경 불가

class WholeWonAccount {
  private balance: number;
  constructor(initial: number) {
    if (!Number.isSafeInteger(initial) || initial < 0) {
      throw new RangeError('초기 잔액은 안전한 0 이상의 정수');
    }
    this.balance = initial;
  }
  deposit(amount: number): void {
    const next = this.balance + amount;
    if (!Number.isSafeInteger(amount) || amount <= 0 || !Number.isSafeInteger(next)) {
      throw new RangeError('입금과 결과 잔액은 안전한 정수');
    }
    this.balance = next;
  }
  getBalance(): number { return this.balance; }
}
const wholeAccount = new WholeWonAccount(10000);
wholeAccount.deposit(5000);
console.log(wholeAccount.getBalance()); // 15000
// wholeAccount.deposit(Infinity); // 값 검사에서 RangeError, 잔액 변경 전 거절