プログラミングのクラスとは？設計の基礎から継承・実務での活用法まで解説

// ⭕ クラス（設計図）の定義
class Taiyaki {
  // プロパティ（たい焼きの状態・データ）
  taste: string;

  constructor(taste: string) {
    this.taste = taste; // インスタンス化するときに中身（味）を決める
  }

  // メソッド（たい焼きの振る舞い・処理）
  showTaste(): void {
    console.log(`このたい焼きの中身は ${this.taste} です。`);
  }
}

// ❌ 初心者がやりがちなミス
// Taiyaki.showTaste(); // 🚨 エラー：設計図のままでは呼び出せない！

// ⭕ 正しい使い方：new を使ってインスタンス（実体）を生成する
const taiyakiAnko = new Taiyaki("あんこ");
const taiyakiCream = new Taiyaki("カスタード");

// インスタンス（オブジェクト）に対して処理を呼び出す
taiyakiAnko.showTaste();  // 出力: このたい焼きの中身は あんこ です。
taiyakiCream.showTaste(); // 出力: このたい焼きの中身は カスタード です。

// ⭕ 適切なサイズに設計されたクラスの例（銀行口座の管理）
class BankAccount {
  private balance: number = 0; // 外部から直接書き換えられないよう保護（カプセル化）

  // 預金するメソッド
  deposit(amount: number): void {
    if (amount > 0) {
      this.balance += amount;
    }
  }

  // 残高を確認するメソッド
  getBalance(): number {
    return this.balance;
  }
}

const myAccount = new BankAccount();
myAccount.deposit(5000); // 正当なルート（メソッド）を通してのみデータを変更できる

// ❌ 外部から直接書き換えようとするとエラーになるため安全
// myAccount.balance = -10000; // 🚨 エラー: プロパティ 'balance' はプライベートであり、クラス 'BankAccount' 内でのみアクセス可能です。
console.log(`現在の残高: ${myAccount.getBalance()}円`); // 出力: 現在の残高: 5000円

// 1️⃣ 【クラスを使わない場合】（構造体/型定義 + 関数の組み合わせ）
interface UserType {
  name: string;
  age: number;
}

// 処理は完全に外側の関数として独立している
function celebrateBirthday(user: UserType): UserType {
  return { ...user, age: user.age + 1 }; // 新しいオブジェクトを返す（データと処理がバラバラ）
}


// 2️⃣ 【クラスを使う場合】（データと処理を一体化）
class UserClass {
  constructor(public name: string, public age: number) {}

  // 処理（メソッド）がデータ（プロパティ）に直接紐付いている
  celebrateBirthday(): void {
    this.age += 1; // 自分自身の状態を変更できる
  }
}

// 💡 どちらの書き方にもメリット・デメリットがあります。
// 状態をカプセル化して厳密に管理したい場合は2️⃣（クラス）、
// データを不変（イミュータブル）に保ち、テストを簡単にしたい場合は1️⃣（関数型）が実務で選ばれます。

// ⭕ クラスの宣言（名前の頭文字は大文字にするのがルールです）
class Smartphone {
  // 1. プロパティ（変数：データ・状態）
  batteryLevel: number = 100; // 初期値として100を代入
  modelName: string = "iPhone";

  // 2. メソッド（関数：処理・振る舞い）
  charge(): void {
    // ❌ よくあるミス： batteryLevel = 100; とそのまま書いてしまう
    // ⭕ 正しい書き方： this. を付けて「自身のプロパティ」であることを明示する
    this.batteryLevel = 100;
    console.log(`${this.modelName}の充電が完了しました。`);
  }
}

// ❌ 初心者が書きがちな冗長な書き方（昔のJavaScriptに近い書き方）
class UserOld {
  name: string; // ①プロパティを宣言して
  age: number;

  constructor(name: string, age: number) {
    this.name = name; // ②受け取った引数を代入する（記述が重複している）
    this.age = age;
  }
}

// ⭕ TypeScriptの実務で標準となる「省略記法（スマートな書き方）」
class UserNew {
  // constructorの引数に public などを付けるだけで、プロパティ宣言と代入が自動で行われる！
  constructor(public name: string, public age: number) {
    // 中身は空っぽでOK（裏側で this.name = name が実行されています）
  }

  introduce(): void {
    console.log(`私は${this.name}、${this.age}歳です。`);
  }
}

const user1 = new UserNew("田中", 25);
user1.introduce(); // 出力: 私は田中、25歳です。

// カートに入れる商品の型定義
interface Product {
  name: string;
  price: number;
}

class ShoppingCart {
  // プロパティ：カートの中身（初期値は空の配列）
  private items: Product[] = []; 

  // コンストラクタ：今回は初期化時に特別なデータが不要なので省略可能です
  // constructor() {} 

  // ⭕ 実務のテクニック：メソッドを「アロー関数」で定義する
  // アロー関数にすることで、どこから呼び出されても `this` が必ずこのクラス自身を指すようになります（thisの固定化）
  addItem = (item: Product): void => {
    this.items.push(item);
    console.log(`${item.name} をカートに追加しました。`);
  };

  // 合計金額を計算するメソッド
  getTotalPrice = (): number => {
    // reduce関数を使って、配列内の price をすべて足し合わせる
    return this.items.reduce((total, item) => total + item.price, 0);
  };
}

// --- 実際にクラスを使ってみる ---

// 1. クラスからインスタンス（実体）を生成
const myCart = new ShoppingCart();

// 2. メソッドを呼び出してデータを操作
myCart.addItem({ name: "TypeScript入門書", price: 3000 });
myCart.addItem({ name: "高級キーボード", price: 15000 });

// 3. 結果を取得
console.log(`現在の合計金額は ${myCart.getTotalPrice()} 円です。`);
// 出力: 
// TypeScript入門書 をカートに追加しました。
// 高級キーボード をカートに追加しました。
// 現在の合計金額は 18000 円です。

// ❌ items は private なので、外から勝手に操作（破壊）される心配はありません
// myCart.items = []; // 🚨 エラー: プロパティ 'items' はプライベートです。

// ⭕ 大元となるクラス（親クラス）
class User {
  constructor(public name: string, public email: string) {}

  login(): void {
    console.log(`${this.name} がログインしました。`);
  }
}

// ⭕ 継承を使って新しいクラスを作る（子クラス）
// `extends User` と書くことで、Userのプロパティとメソッドを全て引き継ぐ！
class AdminUser extends User {
  // AdminUser独自のメソッドを追加
  deleteAccount(targetName: string): void {
    console.log(`管理者権限で ${targetName} のアカウントを削除しました。`);
  }
}

// AdminUserのインスタンスを作成
const admin1 = new AdminUser("田中", "tanaka@example.com");

// 親クラス（User）から引き継いだメソッドがそのまま使える！
admin1.login(); // 出力: 田中 がログインしました。

// もちろん独自のメソッドも使える！
admin1.deleteAccount("スパムユーザー"); 

// スーパークラス（親クラス）
class Character {
  constructor(public name: string, public hp: number) {}

  attack(): void {
    console.log(`${this.name} の基本攻撃！`);
  }
}

// サブクラス（子クラス）
class Wizard extends Character {
  // 子クラス独自のプロパティ（魔力: mp）を追加したい場合
  constructor(name: string, hp: number, public mp: number) {
    // 🚨 【最重要】子クラスでconstructorを書く場合は、必ず一番最初に super() を呼ぶ！
    // これにより、親クラスの constructor(name, hp) が実行されて準備が整う
    super(name, hp);
    
    // ❌ super() より前に this.mp = mp; などを書くとコンパイルエラーになります
  }

  // ⭕ メソッドの「オーバーライド（上書き）」
  // 親と同じ名前のメソッドを書くと、子クラス専用の処理に上書き（カスタマイズ）できる
  attack(): void {
    if (this.mp >= 10) {
      this.mp -= 10;
      console.log(`${this.name} は魔法を唱えた！（残りMP: ${this.mp}）`);
    } else {
      // super.メソッド名() で、親クラスの元のメソッドを呼び出すことも可能！
      console.log("MPが足りない！");
      super.attack(); 
    }
  }
}

const gandalf = new Wizard("ガンダルフ", 100, 50);

// Wizardクラスで上書き（オーバーライド）された攻撃が出る
gandalf.attack(); // 出力: ガンダルフ は魔法を唱えた！（残りMP: 40）

// ❌ 初心者がやりがちな悪い命名ルール（小文字始まり、動詞）
class calculatePrice {
  // ...
}
// これだと関数（キャメルケース＆動詞）に見えてしまい、new する時に違和感がすごい
const calc = new calculatePrice(); 


// ⭕ 実務での正しい命名ルール（大文字始まり、名詞）
// 「価格計算機」という【モノ】としてパスカルケースで命名する
class PriceCalculator {
  // メソッド（処理）には動詞を使う
  calculate(price: number): number {
    return price * 1.1;
  }
}

// クラス名が大文字始まりの名詞であるため、new して実体を作るのが自然に読める
const calculator = new PriceCalculator();
const total = calculator.calculate(1000);

// ❌ 悪いクラス名（何でも入る「Manager」や「Data」）
class UserManager {
  // ユーザーの作成、ログイン処理、メール送信、果ては商品のお気に入り登録まで...
  // どんどん機能が追加され、誰にも全貌が把握できない巨大なクラスに成長してしまう
}

// ⭕ 良いクラス名（役割が1つに限定された具体的な名前）
// 「ユーザーを登録（作成）するためのクラス」だと一目でわかる
class UserCreator {
  createUser(name: string): void { /* ... */ }
}

// 「ユーザーの認証（ログイン・ログアウト）だけを担当するクラス」
class UserAuthenticator {
  login(): void { /* ... */ }
  logout(): void { /* ... */ }
}

// 「ユーザーへの通知（メール等）だけを担当するクラス」
class UserNotifier {
  sendWelcomeEmail(): void { /* ... */ }
}

// --- 実務での使用イメージ ---
// それぞれのクラスが小さく独立しているため、テストや仕様変更が圧倒的に楽になる
const auth = new UserAuthenticator();
auth.login();

// ❌ 悪いクラス分け：処理（動詞）を中心にクラスを作ってしまっている
class BattleSystem {
  // プレイヤーと敵のデータ、攻撃の計算などを全部1箇所で管理しようとしている
  playerHp: number = 100;
  enemyHp: number = 50;

  playerAttack(weaponDamage: number): void {
    this.enemyHp -= weaponDamage;
  }
}

// ⭕ 良いクラス分け：名詞（モノ）を中心に分割し、責任を分散させる
// 1. 武器クラス
class Weapon {
  constructor(public name: string, public damage: number) {}
}

// 2. キャラクタークラス（プレイヤーも敵もこれをベースにできる）
class Character {
  constructor(public name: string, public hp: number) {}

  // キャラクター自身が「攻撃される」振る舞いを持つ
  takeDamage(amount: number): void {
    this.hp -= amount;
    console.log(`${this.name} は ${amount} のダメージを受けた！残りHP: ${this.hp}`);
  }
}

// クラスを組み合わせて使う（Weaponクラスのデータを、Characterクラスに作用させる）
const sword = new Weapon("鉄の剣", 15);
const slime = new Character("スライム", 50);

slime.takeDamage(sword.damage); // 出力: スライム は 15 のダメージを受けた！残りHP: 35

// --- クラス図をTypeScriptのコードに落とし込む例 ---

// 【クラス図の記述イメージ】
// -----------------------------
// |        Item (Interface)   | <- まず共通の「型」を決める
// -----------------------------
// | + name: string            |
// | + use(): void             |
// -----------------------------
//            △ (実装/implements)
// -----------------------------
// |        Potion (Class)     | <- クラス図の設計通りにコードを書く
// -----------------------------
// | - healAmount: number      |
// -----------------------------
// | + use(): void             |
// -----------------------------

// 1. インターフェース（クラスの必須ルールを定めた設計書）
interface Item {
  name: string;
  use(): void;
}

// 2. クラス図に基づいて Potion クラスを実装（implements）
class Potion implements Item {
  // `+` は public, `-` は private を表す（クラス図の書き方ルール）
  public name: string;
  private healAmount: number;

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

  public use(): void {
    console.log(`${this.name} を使った！HPが ${this.healAmount} 回復した！`);
  }
}

const redPotion = new Potion("赤い薬", 30);
redPotion.use();

// ❌ 最悪のアンチパターン：神クラス（God Class）
class GameManagerGod {
  // あらゆるデータを1箇所に詰め込んでいる
  playerScore: number = 0;
  enemyList: string[] = [];
  databaseConnection: boolean = true;
  isSoundMuted: boolean = false;

  // あらゆる処理を1つのクラスでやろうとしている（数千行になる未来が見える）
  updateScore(): void { /* ... */ }
  spawnEnemy(): void { /* ... */ }
  saveToDatabase(): void { /* ... */ }
  playBgm(): void { /* ... */ }
}

// ⭕ 実務での正しい設計：役割ごとに小さなクラスに分割する（単一責任の原則）
class ScoreManager {
  private score: number = 0;
  addScore(points: number): void {
    this.score += points;
    console.log(`スコア追加: ${points} (合計: ${this.score})`);
  }
}

class EnemySpawner {
  spawn(enemyType: string): void {
    console.log(`${enemyType} が出現した！`);
  }
}

class AudioController {
  play(trackName: string): void {
    console.log(`BGM再生: ${trackName}`);
  }
}

// 必要な時に、必要なクラス（部品）だけを呼び出して使う
const scoreManager = new ScoreManager();
const enemySpawner = new EnemySpawner();

enemySpawner.spawn("ゴブリン");
scoreManager.addScore(100);

// ❌ 悪いサービスクラスの例（状態を持ってしまっている）
class BadPaymentService {
  // 🚨 サービスが直接データを持っているため、複数回呼ばれるとバグる危険がある
  private amount: number = 0; 

  processPayment(price: number) {
    this.amount += price;
    console.log(`${this.amount}円を決済しました。`);
  }
}

// ⭕ 良いサービスクラスの例（状態を持たない・ステートレス）
// 必要なデータはすべて「引数」として受け取る
class PaymentService {
  // 決済処理という「振る舞い」だけを提供する
  processPayment(userId: string, price: number): boolean {
    console.log(`ユーザー[${userId}]の ${price} 円の決済処理を開始します...`);
    // 外部の決済APIなどを叩く処理がここに入る
    console.log("決済完了！");
    return true; 
  }
}

// 実務での使い方（インスタンス化して処理を委譲する）
const paymentService = new PaymentService();
paymentService.processPayment("user_123", 5000);

// ⭕ 実務で役立つラッパークラスの例（localStorage を使いやすく安全に包む）
class StorageWrapper {
  // 保存する処理（オブジェクトを自動で文字列のJSONに変換して包み込む）
  setItem(key: string, value: any): void {
    try {
      const stringValue = JSON.stringify(value);
      localStorage.setItem(key, stringValue);
    } catch (error) {
      console.error("保存に失敗しました", error);
    }
  }

  // 取り出す処理（文字列のJSONを自動で元のオブジェクトに戻す）
  getItem<T>(key: string): T | null {
    const item = localStorage.getItem(key);
    if (!item) return null;

    try {
      return JSON.parse(item) as T; // TypeScriptのジェネリクスを使って型を復元
    } catch (error) {
      console.error("データの読み込みに失敗しました", error);
      return null;
    }
  }
}

// --- ラッパークラスの使用例 ---
const myStorage = new StorageWrapper();

// 複雑なオブジェクトもそのまま渡すだけで安全に保存できる（内部の面倒なJSON変換は隠蔽されている）
const userSettings = { theme: "dark", notifications: true };
myStorage.setItem("settings", userSettings);

// 取り出す時も、元の型（オブジェクト）として綺麗に返ってくる
const loadedSettings = myStorage.getItem<{ theme: string; notifications: boolean }>("settings");
if (loadedSettings) {
  console.log(`現在のテーマ: ${loadedSettings.theme}`); // 出力: 現在のテーマ: dark
}