【TypeScript入門】基本的なクラスの使い方10選！コードを用いて徹底解説

// クラスの基本 (プロパティ,メソッド,コンストラクタ)
// this = オブジェクト自身のメンバ / メンバ = プロパティ&メソッド
// new = インスタンス(コピー)を生成する

class Person {
  // プロパティの定義
  name: string;
  age: number;

  // コンストラクタ化(再利用したいプロパティを指定)
  constructor(name: string, age: number) {
    // 引数で受け取った値をPersonクラスのプロパティに指定
    this.name = name;
    this.age = age;
  }

  // メソッドの定義
  profile() {
    return `名前: ${this.name}, 年齢: ${this.age}`;
  }

}

// [Personオブジェクト]の内容を[変数teru]にコピーしている
let teru = new Person("テル",20);
console.log(teru.profile());  

// アクセス修飾子(public,private,protected) = プロパティに対しての参照を制約する

class Person {
  public name: string; //参照可
  private age: number; //参照不可(元のクラス内ではOK)
  protected nationality: string; //参照不可(元のクラス内と継承先のクラス内はOK)

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

  profile(): string {
    return `名前: ${this.name}, 年齢: ${this.age}, 国籍: ${this.nationality}`;
  }
}

// 継承(クラスの内容を引き継ぐ)
class Alien extends Person {
  constructor(name: string, age: number, nationality: string) {
    super(name, age, nationality); //親クラスと同名のメンバを呼び出す
  }
  profile(): string {
    return `名前: ${this.name}, 年齢: ${this.age}, 国籍: ${this.nationality}`; //[this.age]は[private]なので参照できない(エラー発生)
  }
}

let teru = new Person("テル", 25, "日本");
console.log(teru.name);
console.log(taro.age); //[private]なので参照できない(エラー発生)
console.log(taro.nationality); //[protected]なので参照できない(エラー発生)
console.log(teru.profile());

// TypeScriptの裏技機能
// アクセス修飾子をコンストラクタの引数に定義すると、自動で初期化処理を行なってくれる
class Person {
  constructor(public name: string, protected age: number) {}
}

const teru = new Person("テル", 20);
console.log(teru.name);

class CreditCard {
  private _owner: string;
  private _password: number;
  constructor(owner: string, password: number) {
    this._owner = owner;
    this._password = password;
  }
  // getter(参照可にするメソッド)
  get owner() {
    return this._owner;
  }
  // setter(変更可にするメソッド)
  set password(password: number) {
    this._password = password;
  }
  print() {
    return `パスワード: ${this._password}`;
  }
}

// プロパティを「参照」できる
let card = new CreditCard("テル", 123456789);
console.log(card.owner);

// プロパティを「変更」できる(参照はできないからクラス内で行う)
card.password = 987654321;
console.log(card.print()); //実行結果： パスワード: 987654321

// プロパティを読み取り専用のものにする
class CreditCard {
  constructor(public readonly owner: string) {}
}
let card = new CreditCard("テル");
console.log(card.owner);

// クラスのメンバを静的なものにする
class Greeting {
  static name: string = "テル";
  static age: number = 20;

  static hello() {
    return `こんにちは、${this.name}さん!`;
  }
}

// staticの場合、インスタンス化はできない(エラー発生)
let greeting = new Greeting();
console.log(greeting.name);

// staticの場合、直接クラスのメンバを参照できる
console.log(Greeting.name);
console.log(Greeting.hello());

// 同じ名前のクラスは同一ファイルには作成できない
// しかし、名前空間を使えば、1つ上の階層を作れる (同じ名前のクラスを作成できる)

namespace Japan {
  export namespace Tokyo {
    export class ShinJyuku {
      constructor(public name: string) {}
    }
  }
  export namespace Osaka {
    export class Umeda {
      constructor(public name: string) {}
    }
  }
}

const shinjyuku = new Japan.Tokyo.ShinJyuku("新宿");
console.log(shinjyuku.name);

const umeda = new Japan.Osaka.Umeda("梅田");
console.log(umeda.name);

// 継承(クラスの内容を引き継ぐ)
// super = 親クラスの同名のメンバを呼び出す

class Animal {
  public name: string;
  constructor(name: string) {
    this.name = name;
  }
  run(): string {
    return "I can run";
  }
}

class Dog extends Animal {
  public speed: number;
  constructor(name: string, speed: number) {
    super(name); //親クラスで既に初期化処理している
    this.speed = speed; //Dogクラスで追加したから、ここで初期化処理する
  }
  run(): string {
    const message = super.run();
    return `${message} ${this.speed}km/h.`;
  }
}

let animal = new Animal("アニマル");
console.log(animal.run()); //実行結果：　I can run

let dog = new Dog("ドッグ", 30);
console.log(dog.run()); //実行結果： I can run 30km/h.

// 継承した際に必須項目に設定する(実装漏れを防げる)

abstract class Animal { //抽象クラス
  abstract cry(): string; //抽象メソッド
}

class Dog extends Animal {
  cry() {
    return "bow wow!";
  }
}


let dog = new Dog();
console.log(dog.cry());

// TypeScriptは単一のクラスしか継承できない
// しかし、インターフェースで複数のクラスを継承するようなことはできる

// インターフェース(あらかじめ型を定義できるもの)
interface Goten {
  kamehameha(): void; //シグネチャ
}
interface Tranks {
  galickhou(): void;
}

class Gotenks implements Goten, Tranks {
  kamehameha(): void {
    console.log("かめはめ波!!!");
  }
  galickhou(): void {
    console.log("ギャリック砲!!!");
  }
}

const gotenks = new Gotenks();
gotenks.kamehameha();