클래스와 타입 — public, private, abstract, implements

class User {
  public name: string;          // 어디서든 접근 가능 (기본값)
  private password: string;     // 클래스 내부에서만 접근 가능
  protected email: string;      // 클래스와 상속받은 클래스에서 접근 가능
  readonly id: number;          // 읽기 전용 — 생성자에서만 할당

  constructor(name: string, password: string, email: string) {
    this.id = Date.now();
    this.name = name;
    this.password = password;
    this.email = email;
  }

  // private 메서드
  private hashPassword(): string {
    return `hashed_${this.password}`;
  }

  // public 메서드 (기본값)
  getProfile(): string {
    return `${this.name} (${this.email})`;
  }
}

const user = new User('홍길동', '1234', 'hong@test.com');
user.name;           // OK
// user.password;    // ❌ Error — private
// user.email;       // ❌ Error — protected
// user.id = 999;    // ❌ Error — readonly

// 간결한 방식
class User {
  constructor(
    public name: string,
    private password: string,
    protected email: string,
    readonly id: number = Date.now(),
  ) {}
}

// 위와 동일한 긴 방식
class UserLong {
  public name: string;
  private password: string;
  protected email: string;
  readonly id: number;

  constructor(name: string, password: string, email: string) {
    this.name = name;
    this.password = password;
    this.email = email;
    this.id = Date.now();
  }
}

class Example {
  private tsPrivate: string = 'TS private';  // 컴파일 타임만 보호
  #jsPrivate: string = 'JS private';         // 런타임에서도 보호
}

const ex = new Example();
// 둘 다 직접 접근 불가이지만...
// (ex as any).tsPrivate; // ⚠️ 런타임에서 접근 가능 (any로 우회)
// (ex as any).#jsPrivate; // ❌ 진짜 접근 불가 (SyntaxError)

interface Printable {
  print(): void;
}

interface Serializable {
  serialize(): string;
}

// 여러 인터페이스를 동시에 구현
class Document implements Printable, Serializable {
  constructor(private content: string) {}

  print(): void {
    console.log(this.content);
  }

  serialize(): string {
    return JSON.stringify({ content: this.content });
  }
}

// 인터페이스를 만족하지 않으면 에러
// class BadDoc implements Printable {
//   // Error: Property 'print' is missing
// }

interface HasName {
  name: string;
}

class Person implements HasName {
  // implements는 타입을 "부여"하는 게 아니라 "검사"만 함
  name: string; // 직접 선언해야 함

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

abstract class Shape {
  abstract area(): number;     // 반드시 구현해야 할 메서드
  abstract perimeter(): number;

  // 일반 메서드는 구현을 가질 수 있음
  describe(): string {
    return `넓이: ${this.area()}, 둘레: ${this.perimeter()}`;
  }
}

class Circle extends Shape {
  constructor(private radius: number) {
    super();
  }

  area(): number {
    return Math.PI * this.radius ** 2;
  }

  perimeter(): number {
    return 2 * Math.PI * this.radius;
  }
}

// const shape = new Shape(); // ❌ Error — 추상 클래스는 인스턴스화 불가
const circle = new Circle(5);
console.log(circle.describe()); // '넓이: 78.54, 둘레: 31.42'

// interface — 구현 없이 구조만 정의
interface Animal {
  name: string;
  makeSound(): string;
}

// abstract class — 공통 구현을 포함할 수 있음
abstract class AnimalBase {
  constructor(public name: string) {}

  abstract makeSound(): string; // 추상 메서드

  describe(): string {          // 공통 구현
    return `${this.name}: ${this.makeSound()}`;
  }
}

class Dog extends AnimalBase {
  makeSound(): string {
    return '멍멍';
  }
}

class Temperature {
  private _celsius: number;

  constructor(celsius: number) {
    this._celsius = celsius;
  }

  // getter
  get fahrenheit(): number {
    return this._celsius * 9 / 5 + 32;
  }

  // setter
  set fahrenheit(f: number) {
    this._celsius = (f - 32) * 5 / 9;
  }

  get celsius(): number {
    return this._celsius;
  }

  set celsius(c: number) {
    if (c < -273.15) {
      throw new Error('절대 영도 이하는 불가');
    }
    this._celsius = c;
  }
}

const temp = new Temperature(100);
console.log(temp.fahrenheit); // 212
temp.fahrenheit = 32;
console.log(temp.celsius);   // 0

class Point {
  constructor(public x: number, public y: number) {}
}

class Coordinate {
  constructor(public x: number, public y: number) {}
}

// 구조가 같으므로 호환됨
const p: Point = new Coordinate(1, 2); // OK!