Javaのsuperとは？thisとの違いから使い方まで徹底解説！

この記事で学べること

• superキーワードの基本的な役割
• super()とsuper. の明確な使い分け
• 図解で理解するthisとの違い
• 実践的なsuperの使い方7選
• よくあるエラーの原因と解決策

Javaのsuperとは？

ここでは、Javaの継承における`super`キーワードの基本的な役割と、なぜ`super`が必要なのかを解説します。オブジェクト指向の土台となる考え方を、まずはしっかり押さえましょう。

• そもそもJavaの「継承」とは？
• `super`を一言でいうと「親クラスへのアクセス手段」
• なぜ`super`が必要なの？

そもそもJavaの「継承」とは？

Javaにおける継承とは、あるクラス（子クラス）が別のクラス（親クラス）の性質（フィールドやメソッド）を引き継ぐ仕組みのことです。

例えば、「車」クラスを親として、「トラック」クラスを子クラスとして作ると、トラックは車が持つ「走る」「止まる」といった基本的な機能をそのまま受け継げます。

継承を使うことで、コードの重複を減らし、プログラムの保守性を高めるメリットがあります。

// 親クラス
class Car {
    void run() {
        System.out.println("車が走ります。");
    }
}

// 子クラスが親クラスを継承
class Truck extends Car {
    // Carクラスのrun()メソッドをそのまま使える
}

`super`を一言でいうと「親クラスへのアクセス手段」

`super`キーワードは、子クラスの中から、継承元である親クラスのメンバ（コンストラクタ、フィールド、メソッド）にアクセスするための特別な参照です。

先ほどの例で、子クラスである「トラック」から、親クラスである「車」の機能を使いたい場合に`super`が登場します。

子クラスが独自の機能を追加したり、親クラスの機能を少し変更したりするときに、親クラスの元々の機能へアクセスする橋渡し役を担うのです。

なぜ`super`が必要なの？

子クラスで親クラスと同じ名前のメソッドを定義（オーバーライド）した場合、子クラス内でそのメソッド名を呼び出すと、子クラス自身のメソッドが呼び出されます。

しかし、「親クラスのオリジナルの動きも実行したい」という場面はよくあります。

そんなときに`super`を使えば、子クラスの中から親クラスのメソッドを明確に指定して呼び出すことが可能になります。

`super`がないと、隠れてしまった親クラスのメンバにアクセスする手段がなくなってしまうのです。

Javaのsuperの基本的な2つの使い方

`super`キーワードには、大きく分けて2つの使い方があります。コンストラクタを呼び出す使い方と、フィールドやメソッドにアクセスする使い方です。それぞれの役割と書き方を、サンプルコードを見ながら確認していきましょう。

• 1. 親クラスのコンストラクタを呼び出す`super()`
• 2. 親クラスのフィールドやメソッドにアクセスする`super.`

1. 親クラスのコンストラクタを呼び出す`super()`

子クラスのインスタンスが作られるとき、その内部では必ず親クラスのコンストラクタが先に呼び出されます。

`super()`は、子クラスのコンストラクタ内から、親クラスのコンストラクタを明示的に呼び出すために使います。

特に、親クラスに引数付きのコンストラクタしかない場合、子クラスは`super()`を使って適切な値を渡して呼び出す必要があります。

`super()`はコンストラクタの先頭に記述しなくてはならない、というルールがあります。

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

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

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

// 実行コード
public class Main {
    public static void main(String[] args) {
        PremiumUser user = new PremiumUser("Taro");
        System.out.println("ユーザー名: " + user.name);
    }
}

実行結果：

親クラス(User)のコンストラクタが呼ばれました。
子クラス(PremiumUser)のコンストラクタが呼ばれました。
ユーザー名: Taro

2. 親クラスのフィールドやメソッドにアクセスする`super.`

子クラスで親クラスのメソッドをオーバーライド（上書き）した際に、親クラスの元のメソッドを呼び出したい場合に`super.メソッド名()`という形式で使います。

また、親クラスと子クラスで同じ名前のフィールドを持つ場合も、`super.フィールド名`と書くことで親クラスのフィールドにアクセスできます。

// 親クラス
class Animal {
    String name = "動物";

    void cry() {
        System.out.println("動物の鳴き声");
    }
}

// 子クラス
class Dog extends Animal {
    String name = "犬"; // 親クラスと同じ名前のフィールド

    // 親クラスのcryメソッドをオーバーライド
    @Override
    void cry() {
        // super. で親クラスのメソッドを呼び出す
        super.cry(); 
        System.out.println("ワン！");
    }

    void printNames() {
        // this.name は自クラスのフィールドを指す
        System.out.println("子クラスのname: " + this.name);
        // super.name は親クラスのフィールドを指す
        System.out.println("親クラスのname: " + super.name);
    }
}

// 実行コード
public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.cry();
        myDog.printNames();
    }
}

実行結果：

動物の鳴き声
ワン！
子クラスのname: 犬
親クラスのname: 動物

Javaのsuperとthisの違いを徹底比較

`super`と`this`はどちらも参照を表すキーワードですが、その指し示す先が異なります。

この違いを理解することが、オブジェクト指向プログラミングの第一歩です。図解と表で、両者の違いを明確に整理しましょう。

• `super()` vs `this()`：呼び出すコンストラクタの違い
• `super.` vs `this.`：アクセスするインスタンスの違い
• 結局、何を指しているの？

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

`super()`と`this()`は、どちらもコンストラクタの先頭で使われる点は似ていますが、呼び出す対象が全く異なります。

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

1つのコンストラクタ内で、`super()`と`this()`を同時に使うことはできません。

キーワード	呼び出し対象	主な用途
super()	親クラスのコンストラクタ	親クラスの初期化処理を行う
this()	自クラスの他のコンストラクタ	コンストラクタの処理を共通化する

`super.` vs `this.`：アクセスするインスタンスの違い

`super.`と`this.`は、メンバ（フィールドやメソッド）にアクセスする際に使います。

`this`は自分自身のインスタンスを指しますが、`super`は自分自身のインスタンスを通じて親クラスのメンバにアクセスするためのものです。

少し難しい表現ですが、「`super`は親インスタンスそのものではない」という点を覚えておきましょう。

【インスタンスのイメージ】

+----------------------------+
| Dogインスタンス (自分自身) |  <-- this が指す場所
| +------------------------+ |
| | name = "犬"            | |
| | cry() { ... }          | |
| +------------------------+ |
|                            |
|  (内部に親クラスの情報を持つ)  |
| +------------------------+ |
| | Animal部分             | |  <-- super はここへアクセスする
| |  name = "動物"         | |
| |  cry() { ... }         | |
| +------------------------+ |
+----------------------------+

結局、何を指しているの？

まとめると、`this`と`super`が指し示す対象は以下の通りです。

• `this`: 今、自分がいるインスタンスそのもの。
• `super`: 今、自分がいるインスタンスの中にある、親クラスから引き継いだ部分。

この根本的な違いを理解すれば、どちらを使うべきか迷うことがなくなります。

特に、継承やオーバーライドを多用するフレームワークを使った開発では、この区別が非常に重要になります。

Javaのsuperが活躍する！便利な使い方7選

ここでは、`super`キーワードが実際の開発でどのように役立つのか、具体的なシーンを紹介します。`super`を使いこなすことで、より柔軟で効率的なコードが書けるようになります。

• 親クラスのメソッドをオーバーライドしつつ再利用する
• 親クラスのコンストラクタに引数を渡して初期化する
• メソッド名が被っても親クラスの処理を明確に呼び出す
• デフォルトコンストラクタがない親クラスを継承する
• 汎用的な処理を親クラスにまとめてコードをスッキリさせる
• 抽象クラスの処理を具体クラスで活用する
• フレームワーク利用時に基底クラスの機能を拡張する

親クラスのメソッドをオーバーライドしつつ再利用する

オーバーライドは、親クラスのメソッドを子クラスで再定義する機能です。
しかし、完全に置き換えるのではなく「親クラスの処理に、少しだけ独自の処理を追加したい」というケースが頻繁にあります。

`super.メソッド名()`を使えば、親クラスの処理を呼び出し、その前後に子クラス独自の処理を追加できます。

class Parent {
    void process() {
        System.out.println("親の共通処理");
    }
}

class Child extends Parent {
    @Override
    void process() {
        System.out.println("【子の独自処理：前】");
        super.process(); // 親の処理を呼び出す
        System.out.println("【子の独自処理：後】");
    }
}

親クラスのコンストラクタに引数を渡して初期化する

親クラスが名前やIDなど、インスタンス作成時に必須の情報をコンストラクタで受け取る設計になっている場合、子クラスは`super()`を使ってその情報を親クラスに渡さなければいけません。

これにより、親クラスのフィールドを正しく初期化できます。

class Product {
    int price;
    Product(int price) { // 引数付きコンストラクタ
        this.price = price;
    }
}

class Book extends Product {
    String title;
    Book(String title, int price) {
        super(price); // 親に価格情報を渡す
        this.title = title;
    }
}

メソッド名が被っても親クラスの処理を明確に呼び出す

意図的なオーバーライドではなくても、親クラスと子クラスでたまたま同じ名前のメソッドが定義されることがあります。

このような状況で、子クラスの中から親クラスのメソッドを呼び出したい場合、`super.`が役立ちます。

`super.`を使うことで、たとえ名前が同じでも、親クラスのバージョンを明確に指定して実行できます。

// 親クラス
class Document {
    public void print() {
        System.out.println("ドキュメントを標準出力します。");
    }
}

// 子クラス
class HtmlDocument extends Document {
    // 親クラスにもあるprintメソッド
    public void print() {
        System.out.println("<html>...</html>");
    }

    public void printAsStandard() {
        // このクラスのprint()を呼び出すなら this.print()
        // 親クラスのprint()を呼び出すなら super.print()
        System.out.println("--- 親クラスの機能で印刷します ---");
        super.print();
    }
}

// 実行コード
public class Main {
    public static void main(String[] args) {
        HtmlDocument doc = new HtmlDocument();
        doc.print(); // 子クラスのprintが呼ばれる
        doc.printAsStandard(); // 明示的に親クラスのprintを呼ぶ
    }
}

実行結果：

<html>...</html>
--- 親クラスの機能で印刷します ---
ドキュメントを標準出力します。

デフォルトコンストラクタがない親クラスを継承する

Javaでは、子クラスのコンストラクタから何も記述しないと、コンパイラが自動で引数なしの`super()`を挿入します。

しかし、親クラスが引数付きのコンストラクタしか持たず、引数なしのコンストラクタ（デフォルトコンストラクタ）がない場合、この自動挿入された`super()`は呼び出し先を見つけられずコンパイルエラーとなります。

このエラーを解決するには、子クラスのコンストラクタで、親クラスが持つ引数付きコンストラクタを`super(...)`で明示的に呼び出す必要があります。

// 親クラス：IDが必須で、デフォルトコンストラクタがない
class Item {
    private String id;
    public Item(String id) {
        if (id == null) {
            throw new IllegalArgumentException("IDは必須です。");
        }
        this.id = id;
    }
}

// 子クラス
class DetailedItem extends Item {
    private String description;

    // NG例：これだとコンパイルエラーになる
    // public DetailedItem(String description) {
    //     this.description = description;
    // }

    // OK例：super()で親のコンストラクタを明示的に呼び出す
    public DetailedItem(String id, String description) {
        super(id); // 親クラスのコンストラクタにIDを渡す
        this.description = description;
    }
}

汎用的な処理を親クラスにまとめてコードをスッキリさせる

複数の子クラスで共通して利用する機能がある場合、その処理を親クラスにメソッドとして実装しておくと、コードの再利用性が高まります。これはオブジェクト指向における「Don't Repeat Yourself (DRY)」の原則にも繋がります。

子クラスは`super.`経由でその共通機能を呼び出すだけでよく、コードの重複を防ぎ、保守性を向上させます。

// 親クラス：ログ出力の共通機能を持つ
abstract class Task {
    // 共通のログ機能
    protected void log(String message) {
        System.out.println("[LOG] " + message);
    }
    
    // 実行内容は子クラスで定義する
    public abstract void execute();
}

// 子クラスA
class FileExportTask extends Task {
    @Override
    public void execute() {
        super.log("ファイルエクスポートを開始します。"); // 親の共通機能を呼び出し
        // ...エクスポート処理...
        super.log("ファイルエクスポートが完了しました。");
    }
}

// 子クラスB
class DataImportTask extends Task {
    @Override
    public void execute() {
        super.log("データインポートを開始します。"); // 親の共通機能を呼び出し
        // ...インポート処理...
        super.log("データインポートが完了しました。");
    }
}

抽象クラスの処理を具体クラスで活用する

抽象クラスは、全ての処理を子クラスに任せる（抽象メソッド）だけでなく、一部の処理を実装済み（具象メソッド）にしておくこともできます。

この実装済みの処理を、子クラスでオーバーライドする際に再利用したい場合に`super.`が役立ちます。

抽象クラスが提供するデフォルトの振る舞いを活かしつつ、子クラスで機能を追加・拡張する際に便利です。

// 抽象クラス：計算の骨格を定義
abstract class NumberProcessor {
    // 実装済みの具象メソッド
    public void process(int num) {
        System.out.println("入力値: " + num);
        // この後の具体的な処理は子クラスに任せる
    }
}

// 具体クラス
class SquareProcessor extends NumberProcessor {
    // 親の具象メソッドをオーバーライド
    @Override
    public void process(int num) {
        super.process(num); // 親クラスの処理（入力値の表示）を再利用
        int result = num * num;
        System.out.println("二乗した結果: " + result); // 子クラス独自の処理を追加
    }
}

フレームワーク利用時に基底クラスの機能を拡張する

WebアプリケーションやAndroidアプリ開発で使われるフレームワークでは、フレームワークが用意したクラス（基底クラス）を継承して、独自の機能を作り込むことが頻繁にあります。

フレームワークの基底クラスのメソッドには、画面の描画準備や初期化など、見えないところで重要な処理が含まれています。

メソッドをオーバーライドする際には、最初に`super.メソッド名()`を呼び出して基底クラスの重要な処理を必ず実行し、その後に独自の処理を記述するのが定石です。

例えば、Androidアプリ開発では`Activity`クラスを継承しますが、`onCreate`メソッドでは必ず親の`onCreate`を呼び出します。

// Androidアプリ開発の例（擬似コード）
class AppCompatActivity {
    // 画面の初期化など重要な処理が内部で行われている
    protected void onCreate(Object savedInstanceState) {
        // ...フレームワークの重要な初期化処理...
    }
}

class MyCustomActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Object savedInstanceState) {
        // ★最初に必ず親クラスのメソッドを呼び出す★
        // これを忘れると、アプリが正しく動作しなくなる可能性がある
        super.onCreate(savedInstanceState);

        // その後に、自分で行いたい画面設定などを記述する
        // setContentView(R.layout.activity_main);
        System.out.println("独自の初期化処理を実行しました。");
    }
}

このルールを守らないと、フレームワークが期待する動作が行われず、原因不明のエラーに繋がることがあります。

要注意！Javaのsuperでよくあるエラーと解決策

`super`は便利ですが、使い方を間違えるとコンパイルエラーの原因になります。ここでは、初心者が遭遇しやすい`super`関連のエラーと、その解決策を解説します。エラーメッセージの意味を理解すれば、もう怖くありません。

• エラー1: "Constructor call must be the first statement in a constructor"
• エラー2: "Cannot use super in a static context"
• エラー3: 親クラスにデフォルトコンストラクタがない場合のエラー

エラー1: "Constructor call must be the first statement in a constructor"

このエラーは、「コンストラクタの呼び出しは、コンストラクタの最初の文でなければならない」という意味です。

`super()`や`this()`は、コンストラクタ内の他のどの処理よりも先に、1行目に記述する必要があります。

NGな例：

class Child extends Parent {
    Child() {
        System.out.println("子の処理");
        super(); // エラー！super()は先頭に書く必要がある
    }
}

OKな例：

class Child extends Parent {
    Child() {
        super(); // OK！先頭に記述
        System.out.println("子の処理");
    }
}

エラー2: "Cannot use super in a static context"

このエラーは、「静的（static）なコンテキストでsuperは使えない」という意味です。
`super`はインスタンスに属する親クラスのメンバにアクセスするためのものなので、インスタンスの存在を前提としない`static`メソッド内では使えません。

`super`はインスタンスメソッドやコンストラクタの中から使いましょう。

NGな例：

class Child extends Parent {
    public static void myStaticMethod() {
        // エラー！staticメソッド内ではsuperを使えない
        super.someMethod(); 
    }
}

エラー3: 親クラスにデフォルトコンストラクタがない場合のエラー

子クラスのコンストラクタで`super()`を明示的に呼び出さない場合、コンパイラが自動的に引数なしの`super()`を挿入します。

このとき、もし親クラスに引数なしのコンストラクタ（デフォルトコンストラクタ）が存在しないと、コンパイルエラーになります。

解決策は、子クラスのコンストラクタから、親クラスに存在する引数付きのコンストラクタを`super(...)`で明示的に呼び出すことです。

class Parent {
    // 引数付きコンストラクタしかない
    Parent(String name) { }
}

class Child extends Parent {
    // コンストラクタを定義しないと、裏で引数なしのsuper()が呼ばれてエラーになる

    // 解決策：明示的に親のコンストラクタを呼ぶ
    Child() {
        super("dummy"); // これでエラーを回避できる
    }
}

まとめ

今回はJavaの`super`キーワードについて、基本的な使い方から`this`との違い、実践的な活用法まで詳しく解説しました。

• `super`は子クラスから親クラスのメンバにアクセスするためのキーワード
• `super()`は親クラスのコンストラクタを呼び出す
• `super.`は親クラスのフィールドやメソッドにアクセスする
• `this`が自インスタンスを指すのに対し、`super`は親クラスのメンバへのアクセス手段
• オーバーライドしたメソッド内で親の処理を再利用するのが典型的な使い方

`super`を正しく使いこなすことは、Javaの強力な機能である継承を最大限に活用することに繋がります。

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

この記事を参考に、ぜひ`super`を使ったプログラミングに挑戦してみてください。