TypeScript：クラスとアクセス修飾子

出力 == ノートPC：128,000円

constructor(public name: string, public price: number) {} と書くだけでプロパティが作られる。

class Product {
  constructor(
    public name: string,
    public price: number
  ) {}
}

const p = new Product("ノートPC", 128000);

console.log(`${p.name}：${p.price.toLocaleString()}円`);

this.name = name; を書く必要がない。修飾子を付けるだけでプロパティの宣言と代入が自動で行われる——TypeScript特有の便利な記法。

解答 == B

TypeScriptの型チェックはいつ行われるか。

B

JS14の # は実行時エラーだったが、private は書いた時点で分かる。エディタ上で赤線が引かれるので、実行する前に気づける。

出力 == 128000

private price: number とし、getPrice(): number { return this.price; } を作る。

class Product {
  constructor(private price: number) {}

  getPrice(): number {
    return this.price;
  }
}

console.log(new Product(128000).getPrice());

private にすると、外部からの直接アクセスを禁じられる。取り出す手段をメソッドに限定することで、値の扱い方をクラスが管理できる。

class Config {
  constructor(____ apiUrl: string) {}
}

const c = new Config("https://example.com");
console.log(c.apiUrl);

出力 == https://example.com

「読み取り専用」を表す8文字のキーワード。

readonly

readonly は読めるが変更できない。c.apiUrl = "別のURL" と書くとエラーになるので、設定値の書き換え事故を防げる。

解答 == B

abstract は「必ず実装せよ」という指示。

B

実装漏れが構造的に防げる。「このクラスを継承するなら、この処理は必ず用意すること」という約束を、型として強制できる。

出力 == 1500

private balance: number とし、get balance() は名前が衝突するので内部は別名にするか # を使う。

class Account {
  #balance: number;

  constructor(initial: number) {
    this.#balance = initial;
  }

  get balance(): number {
    return this.#balance;
  }

  deposit(amount: number): void {
    this.#balance += amount;
  }
}

const account = new Account(1000);
account.deposit(500);

console.log(account.balance);

getter の名前とプロパティ名が衝突するので # を使っている。JS14で学んだプライベートフィールドが、ここでも役立つ。

interface Printable {
  print(): string;
}

class Item ____ Printable {
  constructor(private name: string) {}
  print(): string {
    return `[${this.name}]`;
  }
}

console.log(new Item("A").print());

出力 == [A]

「実装する」を意味する10文字のキーワード。

implements

implements は「この型の要求を満たす」という宣言。print を書き忘れればエラーになるので、実装漏れが防げる。

解答 == B

TypeScript特有の省略記法。

B

プロパティの宣言と代入が同時に行われる。name: string; と this.name = name; の2行を書かずに済む。

出力 == 面積：314

abstract class Shape { abstract area(): number; describe(): string {...} } と書く。

abstract class Shape {
  abstract area(): number;

  describe(): string {
    return `面積：${this.area()}`;
  }
}

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

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

console.log(new Circle(10).describe());

共通処理は親に、固有の計算は子に。describe は area の中身を知らないまま呼び出せる——これがJS14で学んだポリモーフィズム。

出力 == 3

static count = 0; と static increment() を定義する。インスタンス化せずに使える。

class Counter {
  static count = 0;

  static increment(): number {
    return ++Counter.count;
  }
}

Counter.increment();
Counter.increment();
Counter.increment();

console.log(Counter.count);

static はクラス全体で共有される。インスタンスごとではなく、クラスに1つだけ存在する値になる。

出力2行が完全一致

withTax は Math.round(this.price * 1.1) を返す。

class Product {
  constructor(
    public readonly id: number,
    public name: string,
    private price: number
  ) {}

  withTax(): number {
    return Math.round(this.price * 1.1);
  }
}

const items = [
  new Product(1, "ノートPC", 128000),
  new Product(2, "マウス", 3200),
];

for (const item of items) {
  console.log(`${item.name}：${item.withTax().toLocaleString()}円`);
}

3つの修飾子を使い分けている。id は変えられず、name は自由に読み書きでき、price は外から触れない——それぞれの性質に応じた保護をかけている。

出力2行が完全一致

throw new Error(...) を使い、呼び出し側で try/catch する（JS10）。

class Account {
  #balance: number;

  constructor(initial: number) {
    this.#balance = initial;
  }

  get balance(): number {
    return this.#balance;
  }

  withdraw(amount: number): void {
    if (amount > this.#balance) {
      throw new Error("残高が不足しています");
    }
    this.#balance -= amount;
  }
}

const account = new Account(10000);

account.withdraw(3000);
console.log(`残高：${account.balance.toLocaleString()}円`);

try {
  account.withdraw(99999);
} catch (e) {
  console.log(`エラー：${e instanceof Error ? e.message : "不明"}`);
}

catch で受け取る値は unknown 型（TypeScriptの厳格な仕様）。e.message と直接書けないので、e instanceof Error で確認してから使う——TS09の型ガードがここで必要になる。

出力2行。円：314.0 / 長方形：20.0

abstract に area() と name を持たせる。配列の型は Shape[]。

abstract class Shape {
  abstract readonly label: string;
  abstract area(): number;
}

class Circle extends Shape {
  readonly label = "円";
  constructor(private radius: number) {
    super();
  }
  area(): number {
    return this.radius ** 2 * 3.14;
  }
}

class Rectangle extends Shape {
  readonly label = "長方形";
  constructor(private width: number, private height: number) {
    super();
  }
  area(): number {
    return this.width * this.height;
  }
}

const shapes: Shape[] = [new Circle(10), new Rectangle(5, 4)];

for (const s of shapes) {
  console.log(`${s.label}：${s.area().toFixed(1)}`);
}

Shape[] として扱えるのがポリモーフィズムの本質。ループの中では円か長方形かを気にせず、同じ書き方で処理できる。

出力2行が完全一致

配列の型を Printable[] にすると、異なるクラスを同じ配列に入れられる。

interface Printable {
  print(): string;
}

class Product implements Printable {
  constructor(private name: string) {}
  print(): string {
    return `[商品] ${this.name}`;
  }
}

class Customer implements Printable {
  constructor(private name: string) {}
  print(): string {
    return `[顧客] ${this.name}`;
  }
}

const items: Printable[] = [
  new Product("ノートPC"),
  new Customer("田中商事"),
];

for (const item of items) {
  console.log(item.print());
}

継承関係が無くても、同じインターフェースを実装していれば同じ配列に入れられる。「何であるか」ではなく「何ができるか」で型を揃える考え方。

出力3行が完全一致

private items: Product[] = []; を持ち、メソッドで操作する。totalValue は price * stock の合計。

type Product = { name: string; price: number; stock: number };

class Inventory {
  private items: Product[] = [];

  add(item: Product): void {
    this.items.push(item);
  }

  get count(): number {
    return this.items.length;
  }

  findByName(name: string): Product | undefined {
    return this.items.find((i) => i.name === name);
  }

  totalValue(): number {
    return this.items.reduce((sum, i) => sum + i.price * i.stock, 0);
  }
}

const inv = new Inventory();
inv.add({ name: "ノートPC", price: 128000, stock: 1 });
inv.add({ name: "マウス", price: 3200, stock: 42 });

console.log(`登録${inv.count}件`);

const found = inv.findByName("マウス");
console.log(
  found ? `${found.name}：${found.price.toLocaleString()}円` : "該当なし"
);

console.log(`総額：${inv.totalValue().toLocaleString()}円`);

配列を private にすることで、外部から直接 push されない。追加は必ず add を通るので、将来「重複チェック」などの処理を足したくなったら1箇所直すだけで済む。