TypeScriptのクラス入門
class・constructor・継承の基本

class User {
  // ① プロパティの型宣言（先頭にまとめて書く）
  id:    number;

  name:  string;

  email: string;


  // ② constructor で初期化
  constructor(id: number, name: string, email: string) {
    this.id    = id;
    this.name  = name;
    this.email = email;
  }

  // ③ メソッドにも戻り値の型を付ける
  greet(): string {
    return `こんにちは、${this.name}さん（ID: ${this.id}）`;
  }

  toString(): string {
    return `[User] ${this.name} <${this.email}>`;
  }
}

const alice = new User(1, "Alice", "alice@example.com");
console.log(alice.greet());    // → こんにちは、Aliceさん（ID: 1）
console.log(alice.toString()); // → [User] Alice <alice@example.com>

class BankAccount {
  public  owner:   string;   // 外部からアクセスOK
  private balance: number;   // クラス内部のみ

  constructor(owner: string, initialBalance: number) {
    this.owner   = owner;
    this.balance = initialBalance;
  }

  // public メソッドを通じて private な残高を操作する
  public deposit(amount: number): void {
    if (amount <= 0) throw new Error("入金額は0より大きい値にしてください");
    this.balance += amount;
  }

  public withdraw(amount: number): void {
    if (amount > this.balance) throw new Error("残高不足です");
    this.balance -= amount;
  }

  // 残高は「見る」だけできる getter
  public getBalance(): number {
    return this.balance;
  }
}

const account = new BankAccount("Alice", 10000);
account.deposit(5000);
account.withdraw(3000);
console.log(account.owner);         // → Alice
console.log(account.getBalance());   // → 12000

// private プロパティへの直接アクセスはエラー
console.log(account.balance); // エラー: 'balance' は private プロパティ

class Animal {
  // protected: 子クラスからもアクセスできる
  constructor(protected name: string) {}

  move(distance: number = 0): void {
    console.log(`${this.name} が ${distance}m 移動した`);
  }

  toString(): string {
    return `Animal(${this.name})`;
  }
}

class Dog extends Animal {
  constructor(name: string, private breed: string) {
    super(name); // 親クラスのコンストラクタを呼ぶ（必須）
  }

  bark(): void {
    console.log(`${this.name}（${this.breed}）: ワンワン！`);
  }

  // 親メソッドをオーバーライド
  override move(distance: number = 0): void {
    console.log(`${this.name} が走って ${distance}m 移動した`);
  }
}

class Bird extends Animal {
  constructor(name: string) {
    super(name);
  }

  fly(altitude: number): void {
    console.log(`${this.name} が ${altitude}m の高さを飛んでいる`);
  }
}

const dog  = new Dog("ポチ", "柴犬");
const bird = new Bird("ピーコ");

dog.bark();        // → ポチ（柴犬）: ワンワン！
dog.move(20);      // → ポチ が走って 20m 移動した（オーバーライド後）
bird.fly(100);     // → ピーコ が 100m の高さを飛んでいる
bird.move(10);     // → ピーコ が 10m 移動した（親クラスのまま）

// 「通知を送る」という契約（インターフェース）
interface Notifier {
  send(to: string, message: string): void;
  name: string;
}

// メール通知の実装
class EmailNotifier implements Notifier {
  name = "Email";

  send(to: string, message: string): void {
    console.log(`[Email → ${to}] ${message}`);
  }
}

// Slack 通知の実装
class SlackNotifier implements Notifier {
  name = "Slack";

  send(to: string, message: string): void {
    console.log(`[Slack → #${to}] ${message}`);
  }
}

// interface 型で受け取れば、実装の詳細に依存しない
function notifyAll(notifiers: Notifier[], message: string): void {
  notifiers.forEach((n) => {
    n.send("admin", `[${n.name}] ${message}`);
  });
}

notifyAll(
  [new EmailNotifier(), new SlackNotifier()],
  "デプロイが完了しました"
);

// implements を付けても必要なメソッドがないとエラー
class BrokenNotifier implements Notifier {
  name = "Broken";
  // send メソッドがない → コンパイルエラー

}