【Java超入門】コンストラクタとは？を徹底解説！基本から応用まで完全マスター

Javaのコンストラクタは、オブジェクト指向プログラミングを学ぶ上で避けては通れない重要な仕組みです。

しかし、メソッドと何が違うのか、なぜ必要なのか、最初は戸惑うことも多いでしょう。

この記事では、Javaのコンストラクタの基本的な役割から、`this()`や`super()`を使った応用的な使い方、現場で役立つ実践テクニックまで、順を追って解説します。

この記事で学べること

• Javaコンストラクタの基本的な役割と書き方
• オーバーロードや継承との関係性
• `this()`と`super()`の正しい使い方
• 現場で役立つ実践的なテクニック
• 初心者が陥りがちなエラーとその解決策

Javaのコンストラクタとは？

ここでは、Javaのコンストラクタが持つ根本的な役割と、よく似たメソッドとの違いを明らかにします。オブジェクトが生成される際に、コンストラクタがいかに重要であるかを理解できます。

• コンストラクタの役割は「初期化」
• メソッドとコンストラクタの違い
• `new`でインスタンス化されるときに呼ばれる

コンストラクタの役割は「初期化」

コンストラクタの役割を一言で表すと、「オブジェクトを生成し、使えるように初期化するための特別な処理」です。

例えば、家の設計図（クラス）から実際の家（オブジェクト）を建てる時を想像してください。
ただ家を建てるだけでなく、電気や水道を通し、家具を配置して初めて住める状態になります。

この「住める状態にする」作業が、プログラミングにおける初期化であり、その役割を担うのがコンストラクタなのです。

コンストラクタがないと、中身が空っぽのオブジェクトができてしまい、正しく動作しません。

メソッドとコンストラクタの違い

コンストラクタはメソッドと形が似ていますが、明確な違いが存在します。
主な違いは、目的・名前のルール・戻り値の有無の3点です。

項目	コンストラクタ	メソッド
目的	オブジェクトの生成と初期化	オブジェクトの振る舞い（処理）
名前	クラス名と完全に同じ	自由な名前（動詞が推奨される）
戻り値	ない（voidも書かない）	ある（voidも含む）

`new`でインスタンス化されるときに呼ばれる

コンストラクタは、プログラマが直接呼び出すものではありません。
`new`キーワードを使ってクラスのインスタンス（オブジェクト）を生成する時に、自動的に呼び出される仕組みになっています。

`User user = new User();` というコードは、`User`クラスのコンストラクタを呼び出して、新しい`user`オブジェクトを生成・初期化しているのです。

Javaコンストラクタの基本ルール

ここでは、Javaコンストラクタを記述する上での基本的な構文と、絶対に守るべき重要なルールを学びます。正しい書き方をマスターすることが、エラーを防ぐ第一歩です。

• 基本の書き方とサンプルコード
• 絶対に守るべき2つのルール

基本の書き方とサンプルコード

コンストラクタの基本的な構文は以下の通りです。
`アクセス修飾子 クラス名(引数リスト) { 初期化処理 }`

実際のコードで見てみましょう。

public class User {
    String name;
    int age;

    // これがUserクラスのコンストラクタ
    public User(String n, int a) {
        System.out.println("コンストラクタが呼ばれました");
        this.name = n; // nameフィールドを引数nで初期化
        this.age = a;  // ageフィールドを引数aで初期化
    }

    public void introduce() {
        System.out.println("私の名前は" + this.name + "、" + this.age + "歳です。");
    }
}

// 実行用クラス
public class Main {
    public static void main(String[] args) {
        // new演算子でインスタンス化するとコンストラクタが呼ばれる
        User user = new User("Taro", 25);
        user.introduce();
    }
}

実行結果

コンストラクタが呼ばれました
私の名前はTaro、25歳です。

絶対に守るべき2つのルール

コンストラクタを書く際には、絶対に守らなければならない2つのルールがあります。

1. コンストラクタ名はクラス名と完全に一致させる
2. 戻り値は絶対に書かない（`void`もNG）

もし戻り値を書いてしまうと、Javaはそれをコンストラクタではなく、ただのメソッドとして認識してしまいます。大文字・小文字も含めてクラス名と完全に同じ名前にする必要がある点も注意しましょう。

インスタンス化の流れを見てみます。

[1. mainメソッドで new User() を実行]
         |
         V
[2. メモリ上にUserオブジェクトの領域が確保される]
         |
         V
[3. Userクラスのコンストラクタが自動的に呼ばれる]
   - フィールドの初期化処理が実行される
   - (nameに"Taro", ageに25がセットされる)
         |
         V
[4. 初期化済みのオブジェクトが変数userに代入される]

Javaコンストラクタの基本パターン3種類

ここでは、Javaで使われるコンストラクタの基本的な3つのパターンを紹介します。状況に応じてどのコンストラクタを使うべきか判断できるようになります。

• ① デフォルトコンストラクタ（自動で作成される）
• ② 引数なしコンストラクタ（自分で定義する）
• ③ 引数ありコンストラクタ（値を渡して初期化）

① デフォルトコンストラクタ（自動で作成される）

プログラマがコンストラクタを一つも定義しなかった場合、Javaコンパイラが自動的に引数なしのコンストラクタを追加します。

これをデフォルトコンストラクタと呼びます。

中身は空っぽで、特に処理は行いません。
今まで意識せずに `new` でオブジェクトを生成できていたのは、このデフォルトコンストラクタのおかげです。

public class Item {
    String name;

    // コンストラクタを何も書かない
    // コンパイラが以下を自動で追加する
    // public Item() {
    // }
}

// Mainクラス
Item item = new Item(); // エラーにならない

② 引数なしコンストラクタ（自分で定義する）

デフォルトコンストラクタと似ていますが、プログラマが意図的に引数なしのコンストラクタを定義するパターンです。

固定の初期値でオブジェクトを生成したい場合などに使われます。

public class Player {
    String name;
    int hp;

    // 引数なしコンストラクタ
    public Player() {
        this.name = "勇者"; // 固定の初期値を設定
        this.hp = 100;    // 固定の初期値を設定
    }
}

// Mainクラス
Player player = new Player(); // nameは"勇者"、hpは100で生成される

③ 引数ありコンストラクタ（値を渡して初期化）

最もよく使われるパターンです。
`new` でインスタンスを生成する際に、引数で値を渡し、その値を使ってフィールドを初期化します。
これにより、オブジェクトごとに異なる状態を持つインスタンスを柔軟に生成できます。

public class Monster {
    String name;
    int hp;

    // 引数ありコンストラクタ
    public Monster(String name, int hp) {
        this.name = name;
        this.hp = hp;
    }
}

// Mainクラス
Monster slime = new Monster("スライム", 50);
Monster dragon = new Monster("ドラゴン", 1000);

このように、同じ`Monster`クラスから、異なる名前とHPを持つインスタンスを簡単に作り分けられます。

もっと便利に！コンストラクタのオーバーロードを使いこなそう

ここでは、コンストラクタを複数定義する「オーバーロード」というテクニックと、関連する`this()`の使い方を解説します。コードの重複を減らし、より柔軟なオブジェクト生成を実現する方法がわかります。

• オーバーロードとは？
• `this()`で他のコンストラク-タを呼び出す
• オーバーロードでコードを整理する具体例

オーバーロードとは？

オーバーロードとは、同じクラス内に、同じ名前で引数の型・数・順番が異なるメソッドやコンストラクタを複数定義できる仕組みです。

例えば、ジュースの自動販売機を思い浮かべてください。

ボタンを押すという行為は同じでも、どのボタンを押すか（引数）によって、出てくるジュース（結果）が異なります。

オーバーロードも同様に、同じ `new` という操作でも、渡す引数によってオブジェクトの初期状態を変えることができます。

`this()`で他のコンストラクタを呼び出す

オーバーロードを使うと、初期化処理が似通ったコンストラクタが複数できてしまうことがあります。
その際にコードの重複を避けるために使うのが`this()`です。

`this()`を使うと、一つのコンストラクタから同じクラスの別のコンストラクタを呼び出すことができます。

ただし、`this()`は必ずコンストラクタの先頭行に記述する必要があります。

オーバーロードでコードを整理する具体例

ユーザ登録を例に、オーバーロードと`this()`を使ったコードを見てみましょう。

public class Member {
    String id;
    String name;
    int point;

    // コンストラクタ1: IDと名前で登録（ポイントは0で初期化）
    public Member(String id, String name) {
        // コンストラクタ2を呼び出す
        this(id, name, 0); 
    }

    // コンストラクタ2: ID, 名前, ポイントで登録（メインの初期化処理）
    public Member(String id, String name, int point) {
        System.out.println("メインのコンストラクタが実行されました");
        this.id = id;
        this.name = name;
        this.point = point;
    }
}

// Mainクラス
public class Main {
    public static void main(String[] args) {
        // コンストラクタ1を呼び出す
        Member member1 = new Member("001", "Sakura"); 
        
        // コンストラクタ2を直接呼び出す
        Member member2 = new Member("002", "Tsubaki", 100);

        System.out.println(member1.id + ": " + member1.point); // 001: 0
        System.out.println(member2.id + ": " + member2.point); // 002: 100
    }
}

実行結果

メインのコンストラクタが実行されました
メインのコンストラクタが実行されました
001: 0
002: 100

`member1`を生成する際、コンストラクタ1が呼ばれ、その内部で`this()`によってコンストラクタ2が呼び出されています。
初期化処理を一つのコンストラクタに集約することで、コードがすっきりし、修正が容易になります。

継承とセットで理解するJavaコンストラクタ

ここでは、オブジェクト指向の重要な概念である「継承」とコンストラクタがどのように連携するかを学びます。`super()`キーワードを使い、親クラスと子クラスのコンストラクタを正しく連携させる方法を解説します。

• サブクラスからスーパークラスのコンストラクタを呼ぶ
• `super()`の基本的な使い方
• `super()`を省略した場合の動作

サブクラスからスーパークラスのコンストラクタを呼ぶ

Javaでは、サブクラス（子クラス）のインスタンスを生成する際、必ずその前にスーパークラス（親クラス）のコンストラクタが呼び出されるというルールがあります。

子供が生まれるためには親が存在する必要があるのと同じで、サブクラスのオブジェクトが完成するためには、まず土台となるスーパークラスの部分が初期化されている必要があるからです。

`super()`の基本的な使い方

`super()`は、サブクラスのコンストラクタ内から、スーパークラスのコンストラクタを明示的に呼び出すために使います。
`this()`と同様に、コンストラクタの先頭行に記述する必要があります。

// 親クラス
class Animal {
    String name;

    Animal(String name) {
        System.out.println("Animalコンストラクタが呼ばれました");
        this.name = name;
    }
}

// 子クラス
class Dog extends Animal {
    String type;

    Dog(String name, String type) {
        // super()で親クラスのコンストラクタを呼び出す
        super(name); 
        System.out.println("Dogコンストラクタが呼ばれました");
        this.type = type;
    }
}

// Mainクラス
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("ポチ", "柴犬");
    }
}

実行結果

Animalコンストラクタが呼ばれました
Dogコンストラクタが呼ばれました

スーパークラスのコンストラクタが先に呼ばれていることがわかります。
もしスーパークラスに引数ありのコンストラクタしかない場合、サブクラスは`super()`でそれを呼び出すことが必須となり、忘れるとコンパイルエラーになります。

`super()`を省略した場合の動作

サブクラスのコンストラクタで`super()`の呼び出しを省略した場合、コンパイラは自動的にスーパークラスの引数なしコンストラクタを呼び出す `super();` を先頭行に挿入します。

もし、スーパークラスに引数なしのコンストラクタが存在しない場合はコンパイルエラーとなるため、注意が必要です。

Javaコンストラクタを活かすための7つの実践テクニック

ここでは、基本的な使い方から一歩進んで、より品質の高いコードを書くための実践的なテクニックを紹介します。

現場で使われる設計思想に触れることで、コンストラクタの理解がさらに深まります。

テクニック1：不変（Immutable）なオブジェクトを作る

不変（Immutable）オブジェクトとは、一度インスタンスを生成したら、その状態（フィールドの値）を変更できないオブジェクトのことです。

コンストラクタですべてのフィールドを初期化し、値を変更するためのsetterメソッドを用意しないことで実現できます。フィールドに`final`修飾子を付けると、より意図が明確になります。

不変オブジェクトには、複数の処理から同時にアクセスされても状態が壊れない（スレッドセーフである）という大きなメリットがあり、安全で予測しやすいプログラムを作る上で非常に有効な手法です。

public final class Point { // クラスもfinalにすることが多い
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    // getterのみでsetterは用意しない
    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }
}

テクニック2：引数のバリデーションを行う

コンストラクタに渡される引数が、必ずしも適切な値であるとは限りません。

例えば、年齢に負の数が設定されたり、必須の名前にnullが設定されたりすると、オブジェクトが不正な状態になってしまい、後の処理で予期せぬエラーを引き起こす原因になります。

コンストラクタの内部で引数の値をチェック（バリデーション）し、不正な値であれば例外をスローすることで、不正な状態のオブジェクトが生成されることを未然に防ぎます。

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        // 名前のnullチェック
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("名前は必須です。");
        }
        // 年齢のチェック
        if (age < 0) {
            throw new IllegalArgumentException("年齢は0以上である必要があります。");
        }
        this.name = name;
        this.age = age;
    }
}

テクニック3：privateコンストラクタを活用する

コンストラクタに`private`修飾子を付けると、クラスの外部から`new`を使ってインスタンスを生成できなくなります。

この特性を利用する代表的なデザインパターンが「シングルトンパターン」です。アプリケーション全体でインスタンスが一つしか存在しないことを保証したい場合に使われます。

また、`Math`クラスのように、静的（static）なメソッドや定数のみで構成され、インスタンス化する必要がない「ユーティリティクラス」でも、インスタンス化を禁止する目的で`private`コンストラクタが用いられます。

// シングルトンパターンの例
public class AppSettings {
    // 唯一のインスタンスを保持するstaticなフィールド
    private static final AppSettings instance = new AppSettings();

    // コンストラクタをprivateにする
    private AppSettings() {
        // 初期化処理...
    }

    // 唯一のインスタンスを取得するためのstaticメソッド
    public static AppSettings getInstance() {
        return instance;
    }
}

テクニック4：コピーコンストラクタを用意する

コピーコンストラクタは、同じクラスの別のインスタンスを引数として受け取り、そのインスタンスが持つフィールド値を自分のフィールドにコピーするコンストラクタです。

既存のオブジェクトと全く同じ状態を持つ新しいオブジェクトを安全に作成できます。

単にオブジェクト変数を代入 (`CopiedObj = originalObj`) するだけでは、オブジェクトの実体は一つで参照（メモリ上の住所）がコピーされるだけなので、片方を変更するともう一方も変わってしまいます。コピーコンストラクタは、この問題を解決します。

public class Mail {
    private String to;
    private String title;

    public Mail(String to, String title) {
        this.to = to;
        this.title = title;
    }

    // コピーコンストラクタ
    public Mail(Mail original) {
        this.to = original.to;
        this.title = original.title;
    }

    // ... getterやsetterなど
}

// 使い方
Mail draft = new Mail("test@example.com", "下書き");
Mail sendMail = new Mail(draft); // draftオブジェクトを複製して新しいインスタンスを生成

テクニック5：ビルダーパターンを検討する

必須項目と任意項目が多く、引数が5個も6個もあるコンストラクタは、引数の順番を間違えやすく、非常に可読性が低くなります。この問題は「テレスコーピングコンストラクタ問題」として知られています。

ビルダーパターンは、この問題を解決するためのデザインパターンです。設定用の内部クラス（Builder）を使い、メソッドチェーンで直感的に値を設定してから、最後に`build()`メソッドでインスタンスを生成します。

どのフィールドに何をセットしているかが一目瞭然で、必須項目だけを設定することも簡単です。このパターンは、有名な書籍『Effective Java』（Joshua Bloch著）でも強く推奨されています。

public class UserProfile {
    private final String userId; // 必須
    private final String nickname; // 必須
    private final int age; // 任意
    private final String address; // 任意

    // コンストラクタはprivateで、Builderからのみ呼ばれる
    private UserProfile(Builder builder) {
        this.userId = builder.userId;
        this.nickname = builder.nickname;
        this.age = builder.age;
        this.address = builder.address;
    }

    // 静的な内部クラスとしてBuilderを定義
    public static class Builder {
        private final String userId; // 必須
        private final String nickname; // 必須
        private int age = 0; // 任意項目はデフォルト値を持つ
        private String address = "";

        public Builder(String userId, String nickname) {
            this.userId = userId;
            this.nickname = nickname;
        }

        public Builder age(int age) {
            this.age = age;
            return this; // メソッドチェーンのために 자신を返す
        }

        public Builder address(String address) {
            this.address = address;
            return this;
        }

        public UserProfile build() {
            return new UserProfile(this);
        }
    }
}

// 使い方
UserProfile user = new UserProfile.Builder("001", "Hana")
                                .age(30)
                                .address("Tokyo")
                                .build();

テクニック6：コンストラクタ内で重い処理を避ける

コンストラクタは、あくまでフィールドの初期化という軽量な処理に専念させるべきです。
データベース接続、ファイル読み込み、ネットワーク通信といった時間のかかる「重い処理」をコンストラクタ内で行うべきではありません。

なぜなら、`new`でインスタンスを生成するたびに処理待ちが発生し、アプリケーション全体のパフォーマンスが低下する原因になるからです。また、テストコードを書く際にも、データベースなどの外部環境への依存が生まれてしまい、テストが困難になります。

このような重い処理は、専用の初期化メソッド（`init()`など）や、インスタンス生成そのものを専門に行う「ファクトリメソッド」や「ファクトリクラス」に分離するのが良い設計です。

テクニック7：Javaレコードを活用する

Java 14から正式に導入されたレコード（record）は、不変なデータを保持することだけを目的としたクラスを簡潔に記述するための仕組みです。
レコードを定義すると、コンパイラが自動的に以下のものを生成してくれます。

• すべてのフィールドを引数に持つpublicなコンストラクタ
• 各フィールドのgetterメソッド（`フィールド名()`という名前）
• `equals()`, `hashCode()`, `toString()`メソッド

従来、手作業で書いていた大量の定型コードが不要になり、コードの可読性が劇的に向上します。

// 従来のクラスでの書き方
public final class Car {
    private final String name;
    private final int speed;

    public Car(String name, int speed) {
        this.name = name;
        this.speed = speed;
    }
    // equals(), hashCode(), toString(), getter... が必要
}

// レコードでの書き方
public record CarRecord(String name, int speed) {
    // これだけで上のクラスとほぼ同等の機能を持つ
}

// 使い方
CarRecord car = new CarRecord("MyCar", 100);
System.out.println(car.name()); // "MyCar"
System.out.println(car); // CarRecord[name=MyCar, speed=100]

JavaコンストラクタのQ&A

ここでは、Javaコンストラクタを学習する上で多くの人が疑問に思う点や、遭遇しやすいエラーについてQ&A形式で解説します。つまずきやすいポイントを事前に知ることで、スムーズな学習につながります。

• Q1. コンストラクタとsetterの違いは？
• Q2. `this()`と`super()`は同時に使える？
• Q3. コンストラクタが見つからないエラーの原因は？

Q1. コンストラクタとsetterの違いは？

A. 役割が異なります。コンストラクタは「必須項目の初期設定」、setterは「任意項目の後からの変更」です。

コンストラクタは、そのオブジェクトが存在するために最低限必要な情報を設定するために使います。一度設定したら変更しない（または変更すべきでない）値の初期化に適しています。
一方、setterメソッドは、オブジェクトが生成された後で、その状態（フィールド値）を変更するために使います。

Q2. `this()`と`super()`は同時に使える？

A. いいえ、同時に一つのコンストラクタ内では使えません。

`this()`も`super()`も、どちらもコンストラクタの先頭行に記述しなければならないというルールがあります。
したがって、両方を同時に記述することは構文上不可能です。

Q3. コンストラクタが見つからないエラーの原因は？

A. 主に2つの原因が考えられます。

`No such constructor` のようなエラーが出た場合、以下の点をチェックしてみてください。

1. 呼び出し時の引数の型や数が、定義したコンストラクタと一致していない。
   例えば、`new User("Taro")` と呼び出しているのに、定義されているのが `User(String name, int age)` だけ、といったケースです。
2. 引数ありコンストラクタを定義したことで、デフォルトコンストラクタがなくなった。
   引数ありコンストラクタを自作したのに、別の場所で引数なしの `new User()` を呼び出そうとするとエラーになります。

まとめ：Javaコンストラクタはオブジェクト指向の第一歩！

この記事では、Javaのコンストラクタについて、その基本的な役割から実践的な使い方までを解説しました。

• コンストラクタの役割は、オブジェクトの初期化
• クラス名と同じ名前で、戻り値がないのがルール
• オーバーロードで柔軟なインスタンス生成が可能になる
• `this()`は自クラス、`super()`は親クラスのコンストラクタを呼ぶ
• コンストラクタを正しく使うことが、品質の高いコードにつながる

コンストラクタは、オブジェクトがどのように「生まれる」かを定義する、オブジェクト指向プログラミングの根幹をなす仕組みです。

この仕組みをしっかり理解することが、Javaプログラミングをマスターするための重要な土台となります。