クラスとオブジェクト指向の基本

class User {
  // プロパティ
  id: number;
  name: string;
  email: string;

  // コンストラクタ（インスタンス生成時に呼ばれる）
  constructor(id: number, name: string, email: string) {
    this.id = id;
    this.name = name;
    this.email = email;
  }

  // メソッド
  greet(): string {
    return `こんにちは、${this.name}です`;
  }

  // メソッド
  getDisplayName(): string {
    return `${this.name} <${this.email}>`;
  }
}

// インスタンスの作成
const user = new User(1, "田中太郎", "tanaka@example.com");
console.log(user.greet());          // "こんにちは、田中太郎です"
console.log(user.getDisplayName()); // "田中太郎 <tanaka@example.com>"

// TypeScript の省略構文
class User {
  constructor(
    public id: number,
    public name: string,
    public email: string
  ) {}

  greet(): string {
    return `こんにちは、${this.name}です`;
  }
}
// public をつけると自動的にプロパティが定義・初期化される

class BankAccount {
  public readonly accountNumber: string;
  private balance: number;

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

  // public: 外部から呼び出せる
  public deposit(amount: number): void {
    this.validateAmount(amount);
    this.balance += amount;
  }

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

  public getBalance(): number {
    return this.balance;
  }

  // private: クラス内部でのみ使用
  private validateAmount(amount: number): void {
    if (amount <= 0) {
      throw new Error("金額は正の数でなければなりません");
    }
  }
}

const account = new BankAccount("1234-5678", 10000);
account.deposit(5000);
console.log(account.getBalance()); // 15000
// account.balance = 999999;       // エラー！ private はアクセス不可
// account.accountNumber = "xxx";   // エラー！ readonly は変更不可

// 基底クラス（親クラス）
class Shape {
  constructor(
    public color: string
  ) {}

  describe(): string {
    return `${this.color}の図形`;
  }
}

// 派生クラス（子クラス）
class Circle extends Shape {
  constructor(
    color: string,
    public radius: number
  ) {
    super(color); // 親のコンストラクタを呼び出す
  }

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

  // メソッドのオーバーライド
  describe(): string {
    return `${this.color}の円（半径: ${this.radius}）`;
  }
}

class Rectangle extends Shape {
  constructor(
    color: string,
    public width: number,
    public height: number
  ) {
    super(color);
  }

  area(): number {
    return this.width * this.height;
  }

  describe(): string {
    return `${this.color}の四角形（${this.width}x${this.height}）`;
  }
}

const circle = new Circle("赤", 5);
console.log(circle.describe()); // "赤の円（半径: 5）"
console.log(circle.area());     // 78.54...

const rect = new Rectangle("青", 3, 4);
console.log(rect.describe()); // "青の四角形（3x4）"
console.log(rect.area());     // 12

// インターフェース（契約）
interface Serializable {
  toJSON(): string;
}

interface Validatable {
  validate(): string[];
}

// 複数のインターフェースを実装
class Product implements Serializable, Validatable {
  constructor(
    public id: number,
    public name: string,
    public price: number
  ) {}

  toJSON(): string {
    return JSON.stringify({ id: this.id, name: this.name, price: this.price });
  }

  validate(): string[] {
    const errors: string[] = [];
    if (!this.name) errors.push("名前は必須です");
    if (this.price < 0) errors.push("価格は0以上にしてください");
    return errors;
  }
}

class TaskApiClient {
  private baseUrl: string;
  private headers: Record<string, string>;

  constructor(baseUrl: string, authToken?: string) {
    this.baseUrl = baseUrl;
    this.headers = {
      "Content-Type": "application/json",
    };
    if (authToken) {
      this.headers["Authorization"] = `Bearer ${authToken}`;
    }
  }

  private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
    const response = await fetch(`${this.baseUrl}${endpoint}`, {
      ...options,
      headers: { ...this.headers, ...options.headers as Record<string, string> },
    });

    if (!response.ok) {
      throw new Error(`API Error: ${response.status}`);
    }

    if (response.status === 204) {
      return undefined as T;
    }

    return response.json();
  }

  // CRUD メソッド
  async getTasks(): Promise<Task[]> {
    return this.request<Task[]>("/tasks");
  }

  async getTask(id: number): Promise<Task> {
    return this.request<Task>(`/tasks/${id}`);
  }

  async createTask(input: CreateTaskInput): Promise<Task> {
    return this.request<Task>("/tasks", {
      method: "POST",
      body: JSON.stringify(input),
    });
  }

  async updateTask(id: number, input: UpdateTaskInput): Promise<Task> {
    return this.request<Task>(`/tasks/${id}`, {
      method: "PATCH",
      body: JSON.stringify(input),
    });
  }

  async deleteTask(id: number): Promise<void> {
    await this.request<void>(`/tasks/${id}`, {
      method: "DELETE",
    });
  }
}

// 使用例
const client = new TaskApiClient("https://api.example.com", "my-auth-token");
const tasks = await client.getTasks();
const newTask = await client.createTask({ title: "勉強する" });