【Java初心者必見】thisキーワードとは？使い方からsuperとの違いまで徹底解説！

この記事では、Javaのthisの基本的な意味から、実践的な使い方、混同しやすいsuperとの違い、そして初心者が陥りがちな注意点まで、豊富なコード例を交えて丁寧に解説します。

Javaの学習を始めたばかりの方でも、読み終える頃にはthisを自信を持って使いこなせるようになっているでしょう。

Javaのthisとは？

結論：thisは「自分自身」を指すキーワード

Javaにおけるthisとは、一言でいうと「インスタンス自身」を指し示すための特別なキーワードです。

クラスからオブジェクト（インスタンス）を生成した際、そのオブジェクトが自分自身のメンバー（フィールドやメソッド）にアクセスするために使います。

ちょうど、私たちが会話の中で「私」や「自分」と言うのと同じような役割だとイメージすると分かりやすいでしょう。

Javaのthisの基本を理解しよう

ここでは、thisキーワードの核心に迫ります。thisが何を指していて、なぜJavaプログラミングに不可欠なのか、その理由をコードを交えながら見ていきましょう。

• thisが指し示すもの：インスタンス自身
• なぜthisが必要なの？
• thisが使える場所・使えない場所

thisが指し示すもの：インスタンス自身

thisが指し示すのは、メソッドやコンストラクタを呼び出しているオブジェクトそのものです。クラスは設計図であり、その設計図から作られた実体がインスタンスです。

家を建てる状況で例えるなら、クラスは「家の設計図」、インスタンスは「実際に建てられたAさんの家」「Bさんの家」に相当します。
そして、Aさんの家の中で「この家の壁」と言う時の「この家」がthisにあたります。

+-------------------------+
| 設計図: Personクラス    |
|-------------------------|
| String name;            |
| int age;                |
| void introduce(){...}   |
+-------------------------+
          |
          | new Person();
          |
+------------------+     +------------------+
| Aさんのインスタンス |     | Bさんのインスタンス |
|------------------|     |------------------|
| name = "佐藤"    |     | name = "鈴木"    |
| age = 30         |     | age = 25         |
| this -> Aさん自身 |     | this -> Bさん自身 |
+------------------+     +------------------+

上の図のように、インスタンスごとにthisが指す対象は異なります。

なぜthisが必要なの？

thisが最も活躍するのは、フィールド変数とメソッドの引数（ローカル変数）の名前が同じになってしまった時です。

Javaでは、内側のスコープで宣言された変数が優先されます。そのため、thisを使わないと変数を区別できなくなります。

【thisがないと困る例】

class Person {
    String name;

    // コンストラクタ
    Person(String name) {
        // 引数のnameを、フィールドのnameに代入しようとしているが…
        name = name; // どちらも引数のnameを指してしまい、フィールドには値がセットされない
    }

    void printName() {
        System.out.println("名前：" + this.name);
    }
}

// 実行コード
Person p = new Person("山田");
p.printName(); // 名前：null と表示されてしまう

【thisを使って解決した例】

class Person {
    String name;

    // コンストラクタ
    Person(String name) {
        // 「this.name」でフィールド変数を明示する
        this.name = name;
    }

    void printName() {
        System.out.println("名前：" + this.name);
    }
}

// 実行コード
Person p = new Person("山田");
p.printName(); // 名前：山田 と正しく表示される

このように、`this.`を付けることで「インスタンス自身のフィールド」であることをコンパイラに伝え、正しく値を代入できます。

thisが使える場所・使えない場所

Javaのthisキーワードはどこでも使えるわけではありません。使える場所と使えない場所を理解しておくことは、エラーを未然に防ぐ上で非常に重要です。

場所	使用可否	理由
インスタンスメソッド	◯	インスタンスに属するためthisが使える。
コンストラクタ	◯	インスタンス生成時に呼び出されるためthisが使える。
staticメソッド	✕	インスタンスが存在しなくても呼び出せるため、自分自身を指すthisは存在しない。
staticブロック	✕	staticメソッドと同様の理由。

特にstaticなコンテキスト（文脈）ではthisが使えない点は、Javaの基本的なルールとして必ず覚えておきましょう。

Javaのthisを使いこなすための7つの活用法

ここでは、実際のプログラミングでJavaのthisキーワードがどのように使われるのか、代表的な7つのパターンを紹介します。それぞれの使い方をマスターして、コードの品質を高めましょう。

• フィールドとローカル変数を区別する
• 他のコンストラクタを呼び出す (`this()`)
• メソッドを呼び出す (`this.method()`)
• メソッドの引数で自分自身を渡す
• メソッドの戻り値で自分自身を返す
• コンストラクタの引数で自分自身を渡す
• 内部クラスから外部クラスのインスタンスを参照する

フィールドとローカル変数を区別する

最も基本的で頻繁に使われる活用法です。前述の通り、コンストラクタやセッターメソッドで、フィールドと同じ名前の引数を受け取った際に、両者を明確に区別します。

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

    // コンストラクタ
    public User(String name, int age) {
        this.name = name; // フィールドのname = 引数のname
        this.age = age;   // フィールドのage = 引数のage
    }

    // nameのセッターメソッド
    public void setName(String name) {
        this.name = name; // フィールドのname = 引数のname
    }
}

この書き方はJavaの標準的なコーディングスタイルであり、可読性を高める効果があります。

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

コンストラクタの処理が重複する場合、`this()`を使うと別のコンストラクタを呼び出せます。コードの重複を減らし、保守性を向上させるのに役立ちます。

public class Item {
    private String name;
    private int price;
    private int stock;

    // 引数3つのコンストラクタ（メインの処理）
    public Item(String name, int price, int stock) {
        this.name = name;
        this.price = price;
        this.stock = stock;
    }

    // 引数2つのコンストラクタ。在庫(stock)の初期値を0としてメインのコンストラクタを呼び出す
    public Item(String name, int price) {
        this(name, price, 0); // this()で他のコンストラクタを呼び出す
    }

    public void showInfo() {
        System.out.println("商品名：" + name + " / 価格：" + price + "円 / 在庫：" + stock + "個");
    }
}

// 実行コード
Item item1 = new Item("リンゴ", 150, 10);
Item item2 = new Item("ミカン", 120);

item1.showInfo();
item2.showInfo();

【実行結果】

商品名：リンゴ / 価格：150円 / 在庫：10個
商品名：ミカン / 価格：120円 / 在庫：0個

メソッドを呼び出す (`this.method()`)

インスタンス自身の他のメソッドを呼び出す際に`this.`を付けることができます。通常は省略可能ですが、コードの意図を明確にしたい場合に利用されます。

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public void executeAndPrint(int x, int y) {
        // thisを使ってaddメソッドを呼び出す
        int result = this.add(x, y);
        // int result = add(x, y); と省略しても同じ
        System.out.println("計算結果: " + result);
    }
}

明示的に`this.`を付けることで「このクラス内のメソッドを呼び出している」と一目で分かりやすくなります。

メソッドの引数で自分自身を渡す

あるオブジェクトが、別のオブジェクトのメソッドを呼び出す際に、引数として自分自身を渡したい場合があります。この時にthisを使います。

// イベントを処理するクラス
class EventHandler {
    public void handle(EventSource source) {
        System.out.println("イベントが発生しました。発生元: " + source.getName());
    }
}

// イベント発生源となるクラス
class EventSource {
    private String name;
    
    public EventSource(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    // イベントを発生させるメソッド
    public void fireEvent(EventHandler handler) {
        // 引数に自分自身のインスタンス(this)を渡す
        handler.handle(this);
    }
}

// 実行コード
EventHandler handler = new EventHandler();
EventSource button = new EventSource("ログインボタン");
button.fireEvent(handler);

【実行結果】

イベントが発生しました。発生元: ログインボタン

メソッドの戻り値で自分自身を返す

メソッドの戻り値として`this`を返すことで、メソッドを数珠つなぎのように呼び出す「メソッドチェーン」を実現できます。この手法は、オブジェクトの設定を流れるように記述できるビルダパターンなどでよく使われます。

public class Student {
    private String name;
    private int grade;

    public Student setName(String name) {
        this.name = name;
        return this; // 自分自身を返す
    }

    public Student setGrade(int grade) {
        this.grade = grade;
        return this; // 自分自身を返す
    }

    public void showProfile() {
        System.out.println("名前: " + name + ", 学年: " + grade);
    }
}

// 実行コード
Student student = new Student();
student.setName("田中").setGrade(3).showProfile(); // メソッドチェーン

【実行結果】

名前: 田中, 学年: 3

コンストラクタの引数で自分自身を渡す

あるオブジェクトを生成する際に、生成元のオブジェクトをコンストラクタに渡したい場合に使います。親子関係や関連を持つオブジェクトを生成する際に便利です。

// 親クラス
class Parent {
    public Parent() {
        // 子クラスのインスタンスを生成し、コンストラクタに自分自身(this)を渡す
        Child child = new Child(this);
        child.greet();
    }
    
    public String getParentName() {
        return "親オブジェクト";
    }
}

// 子クラス
class Child {
    private Parent parent;

    public Child(Parent parent) {
        this.parent = parent;
    }
    
    public void greet() {
        System.out.println("こんにちは、私は" + parent.getParentName() + "の子です。");
    }
}

// 実行コード
new Parent();

【実行結果】

こんにちは、私は親オブジェクトの子です。

内部クラスから外部クラスのインスタンスを参照する

Javaにはクラスの中にクラスを定義する「内部クラス（インナークラス）」という仕組みがあります。

内部クラスの中から、それを含む外部クラスのインスタンスを参照したい場合に`外部クラス名.this`という特別な構文を使います。

public class Outer {
    private String outerField = "外部クラスのフィールド";

    class Inner {
        private String innerField = "内部クラスのフィールド";

        public void printFields() {
            // 内部クラスのフィールドにアクセス
            System.out.println(this.innerField);
            // 外部クラスのフィールドにアクセス
            System.out.println(Outer.this.outerField);
        }
    }
}

// 実行コード
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.printFields();

【実行結果】

内部クラスのフィールド
外部クラスのフィールド

「this」と「super」の違いは？Javaの継承を理解しよう

Javaの継承を学ぶと、thisとよく似た`super`というキーワードが登場します。両者は役割が異なるため、ここで違いを明確に整理しておきましょう。

• 参照する対象の違い
• コンストラクタ呼び出しの違い (`this()` vs `super()`)
• メソッド呼び出しの違い

参照する対象の違い

thisとsuperの最も大きな違いは、参照する対象です。この違いを理解することが、両者を使い分ける第一歩となります。

キーワード	参照対象	説明
this	自分自身のインスタンス	現在のオブジェクトそのものを指します。
super	親クラス（スーパークラス）のインスタンス部分	自分自身のインスタンスの中にある、親クラスから継承した部分を指します。

コンストラクタ呼び出しの違い (`this()` vs `super()`)

コンストラクタを呼び出す際の`this()`と`super()`も、明確な違いがあります。

`this()`は同じクラス内の別のコンストラクタを呼び出すのに対し、`super()`は親クラスのコンストラクタを呼び出します。

子クラスのコンストラクタでは、最初に親クラスのコンストラクタを呼び出す必要があります。明示的に`super()`を書かない場合、コンパイラが自動的に引数なしの`super();`を挿入します。

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

// 子クラス
class Dog extends Animal {
    Dog(String name) {
        // 親クラスのコンストラクタを呼び出す
        super(name);
        System.out.println("Dogクラスのコンストラクタが呼ばれました。");
    }
}

// 実行コード
Dog myDog = new Dog("ポチ");

【実行結果】

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

なお、`this()`と`super()`は同時に使うことはできません。どちらもコンストラクタの先頭に記述する必要があるためです。

メソッド呼び出しの違い

メソッドを呼び出す際にも、`this`と`super`は使い分けられます。

親クラスと子クラスで同じ名前のメソッドを定義（オーバーライド）している場合、`super.メソッド名()`と記述することで、親クラスのメソッドを意図的に呼び出すことができます。

// 親クラス
class Person {
    public void greet() {
        System.out.println("私は人間です。");
    }
}

// 子クラス
class Employee extends Person {
    @Override
    public void greet() {
        // 親クラスのgreetメソッドを呼び出す
        super.greet();
        // 子クラス独自の処理を追加
        System.out.println("そして、会社員です。");
    }
}

// 実行コード
Employee emp = new Employee();
emp.greet();

【実行結果】

私は人間です。
そして、会社員です。

まとめ

この記事では、Javaのthisキーワードについて、その基本的な意味から活用法、superとの違いまでを詳しく解説しました。

• thisは「インスタンス自身」を指す参照である
• フィールドと引数の区別が最も基本的な使い方
• `this()`でコンストラクタを呼び出し、コードの重複を防げる
• `return this;`でメソッドチェーンを実現できる
• superは親クラスを指すキーワードで、thisとは役割が違う

thisを正しく理解し使いこなすことは、Javaにおけるオブジェクト指向プログラミングの第一歩と言えます。

最初は少し難しく感じるかもしれませんが、実際にコードを書きながら試していくうちに、自然と身についていくでしょう。