---
type: reference
language: javascript
slug: class/class
title: "class — 作る・継承する・隠す"
title_tag: "JavaScript の class — 継承と private フィールドの使い方"
summary: >
  コンストラクタ、メソッド、getter、静的メンバ、継承、# で始まる非公開フィールドまでを扱います。
  new を忘れると落ちる理由、JSON にすると非公開が消えることも実行して確かめます。
description: >
  # で始まるフィールドは外から読めず、JSON にも出ません。new を忘れると落ちる理由、
  メソッドを取り出すと this が外れる点まで、実行しながら確かめられます。
status: published
difficulty: 3
minutes: 9

versions:
  verified: "Node 24.22.3"
  since: "ES2015"
  deprecated: null
  removed: null

sources:
  - title: "Class Definitions — ECMAScript® 2026 Language Specification"
    url: "https://tc39.es/ecma262/#sec-class-definitions"
  - title: "Private Names — ECMAScript® 2026 Language Specification"
    url: "https://tc39.es/ecma262/#sec-private-names"
  - title: "クラス — MDN"
    url: "https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Classes"

terms: [コンストラクタ, 継承, 静的メンバ, 非公開フィールド]

links:
  related:
    - javascript/why/this-binding
    - javascript/reference/error/error
    - javascript/learn/object/basics

content_updated_at: 2026-09-08
published_at: 2026-09-08
---

`class` は、**同じ形のオブジェクトを作るための型紙**です。

```js run
class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }

  move(dx) {
    this.x += dx;
    return this;
  }
}

const point = new Point(1, 2);

console.log(point);
console.log(point.move(10).x);
```
```output
Point { x: 1, y: 2 }
11
```

`constructor` は `new` したときに1度だけ動きます。
`return this` を返すと、**繋げて呼べます。**

## 中に書けるもの

```js run
class Point {
  x = 0;
  static origin = 'origin';

  constructor(x, y) {
    this.x = x;
    this.y = y;
  }

  get sum() {
    return this.x + this.y;
  }

  static make(n) {
    return new Point(n, n);
  }
}

const point = new Point(1, 2);

console.log(point.sum);
console.log(Point.origin);
console.log(Point.make(3).x);
```
```output
3
origin
3
```

| 書き方 | 何か |
|---|---|
| `x = 0` | フィールド。**作られるたびに設定される** |
| `constructor()` | `new` したときに動く |
| `method()` | メソッド。全部の実体で共有される |
| `get name()` | 呼ばずに読める値（`point.sum`） |
| `static x` / `static m()` | **クラス自体**に付く。実体からは読めない |

[bad:`static` のものは `point.origin` では読めません。] `Point.origin` です。

## `class` は関数

```js run
class Point {}

console.log(typeof Point);
```
```output
function
```

`class` は新しい種類の値ではなく、**関数の書き方のひとつ**です。
ただし `new` なしでは呼べません。

```js bad
class Point {
  constructor(x) {
    this.x = x;
  }
}

Point(1);
```
```output
TypeError: Class constructor Point cannot be invoked without 'new'
```

**`new` を忘れると必ず落ちます。** 静かに `undefined` になったりしません。
[dim:古い `function` で書いた擬似クラスでは落ちず、`this` がグローバルを指してしまいました。`class` はそれを防いでいます。]

## 継承する

```js run
class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    return `${this.name}が鳴く`;
  }
}

class Dog extends Animal {
  speak() {
    return `${super.speak()}（ワン）`;
  }
}

const dog = new Dog('ポチ');

console.log(dog.speak());
console.log(dog instanceof Dog, dog instanceof Animal);
```
```output
ポチが鳴く（ワン）
true true
```

`super.speak()` で**元のメソッドを呼べます。**
`extends` した側は、両方の `instanceof` に当てはまります。

[bad:`constructor` を書くなら、`this` を触る前に `super()` を呼ぶ必要があります。]

エラーを継承する形は、実務でいちばん使います。
→ [Error と try / catch / finally / throw](/ja/javascript/reference/error/error/)

## 外から触れないものを作る

`#` で始まる名前は、**クラスの外から読めません。**

```js run
class Counter {
  #count = 0;

  increment() {
    this.#count++;
    return this.#count;
  }
}

const counter = new Counter();

console.log(counter.increment(), counter.increment());
console.log(Object.keys(counter));
console.log(JSON.stringify(counter));
```
```output
1 2
[]
{}
```

**`Object.keys()` にも `JSON.stringify()` にも出ません。**

隠したい値には向きますが、[bad:保存したい値を `#` にすると消えます]。
JSON にしたいものは `#` にしないでください。

外から読もうとすると、**実行前に構文として弾かれます。**

[dim:`counter.#count` と書くとその場で `SyntaxError` になるので、このページでは実行例にできません。閉包で隠す方法もあります。→ スコープと閉包]

## よくある間違い

### メソッドを取り出して渡す

```js bad
class Counter {
  count = 0;

  increment() {
    this.count++;
    return this.count;
  }
}

const counter = new Counter();
const fn = counter.increment;

try {
  fn();
} catch (error) {
  console.log(error.name);
}
```
```output
TypeError
```

取り出した時点で `this` が外れています。**クラスの中身は strict モード**なので、
`this` は `undefined` になり、`this.count` を読んだところで落ちます。

`bind()` するか、フィールドにアロー関数を入れます。

```js run
class Counter {
  count = 0;
  increment = () => {
    this.count++;
    return this.count;
  };
}

const counter = new Counter();
const fn = counter.increment;

console.log(fn(), fn());
```
```output
1 2
```

[dim:フィールドに入れたアロー関数は、実体ごとに1つずつ作られます。数が多いと無駄になるので、必要なときだけにしてください。]
→ [なぜ this は呼び方で変わるのか](/ja/javascript/why/this-binding/)

### 何でもクラスにする

**状態を持たないなら、関数で足ります。**

```js run
class MathUtil {
  static double(n) {
    return n * 2;
  }
}

const double = (n) => n * 2;

console.log(MathUtil.double(3), double(3));
```
```output
6 6
```

`static` だけのクラスは、**関数を入れる箱にしかなっていません。**
クラスを使うのは、[key:状態と、それを触る手続きを組にしたい]ときです。

### JSON から戻すとクラスでなくなる

```js run
class Point {
  constructor(x) {
    this.x = x;
  }

  double() {
    return this.x * 2;
  }
}

const restored = JSON.parse(JSON.stringify(new Point(2)));

console.log(restored);
console.log(restored instanceof Point);
console.log(typeof restored.double);
```
```output
{ x: 2 }
false
undefined
```

**メソッドは復元されません。** 素のオブジェクトになります。
戻したいなら、`new Point(restored.x)` のように作り直してください。

## まとめ

- `class` は**関数の書き方のひとつ**。`new` なしでは呼べない
- `static` はクラス自体に付く。**実体からは読めない**
- `extends` と `super` で受け継ぐ。`instanceof` は両方に当たる
- **`#` で始まる名前は外から読めず、`JSON.stringify()` にも出ない**
- メソッドを取り出すと `this` が外れる
- **状態を持たないならクラスにしない**
- JSON から戻したものはクラスではない
