キーワード this と super について

Java のキーワードの this, super に関する内容です。

• インスタンスメソッド内の this
• コンストラクタ内の this
• インナークラス内の this
• this をキャストする
• super について

インスタンスメソッドはオブジェクトの振る舞いとしてそれぞれのオブジェクトに属するものなので、インスタンスメソッドの実行時には必ずそのメソッドを実行しているオブジェクトが存在します。 インスタンスメソッド内の this はこのメソッドを実行しているオブジェクトの参照を表します。 実行時になるまで分からない実行オブジェクトの参照をソースコードにおいて this で表し、実行時には this を実行オブジェクトの参照に置き換えたり、単純名でのインスタンス変数やインスタンスメソッドへのアクセスを実行オブジェクトに対して行うことで、それぞれのオブジェクトの振る舞いの違いを１つのメソッド定義で実現しています。 このような動作を実現するためにインスタンスメソッドの実行時には JVM 内部では引数と共に実行オブジェクトの参照も渡されています。 (単純名でのインスタンス変数やインスタンスメソッドへのアクセスはインナークラスの場合には外側のクラスのインスタンスに対するアクセスとなる場合がありますが、それに関しては後述しています)

下はインスタンスメソッド内の this が実行オブジェクトの参照に置き換えられる事を確認するプログラムです。

public class Test {
    public Test getReference() {
        return this;
    }

    public static void main(String[] args) {
        Test test1 = new Test();
        Test test2 = new Test();
        System.out.println(test1 == test2);
        System.out.println(test1 == test1.getReference());
        System.out.println(test2 == test2.getReference());
    }
}

false
true
true

main メソッドでは下のように Test オブジェクトとその Test オブジェクトの getReference メソッド内の this の参照を比較しています。

    test1 == test1.getReference()

    public Test getReference() {
        return this;
    }

    test2.getReference()

次に単純名によるインスタンス変数やインスタンスメソッドへのアクセスと this を使って限定した場合のアクセスについて触れたいと思います。 オブジェクトは状態と振る舞いを持ち、状態はそのオブジェクトのクラスと Object クラスまでたどったすべての上位クラスに宣言されているインスタンス変数 (パッケージアクセスや private 指定されているものも含む) の値であり、それぞれのオブジェクトごとにそれらの変数の値を格納する為の領域を保持しています。 振る舞いの方はインスタンスメソッドを実行した際の動作を指します。 よってインスタンス変数はいずれかのオブジェクトに属しており、 インスタンスメソッドもいずれかのオブジェクトの振る舞いとして実行されます。 そのためにインスタンス変数やインスタンスメソッドにアクセスする為にはアクセス対象のオブジェクトを指定する必要があります。 インスタンスメソッドの場合にはこのアクセス対象のオブジェクトがメソッドの実行オブジェクトになります。 これらのアクセス対象となるオブジェクトの指定は参照型の変数、あるいはオブジェクトを表す式とそれに続くドットで行います。

        String foo = "foo";
        String sub = foo.substring(1);
        sub = new String("bar").substring(1);
        int pointX = new java.awt.Point(10, 20).x;

インナークラスのインスタンスの場合には外側のクラスのインスタンスの変数やメソッドに単純名でアクセスできます。 この為インナークラスのインスタンスのインスタンスメソッド内における単純名によるインスタンス変数やインスタンスメソッドへのアクセスは実行オブジェクトに対するアクセスとは限りません。 この場合にアクセス対象となるオブジェクトの決定はコンパイル時に行われます。

Test#getReference はインスタンスメソッドの戻り値として this を使っている例でしたが、下の Square クラスはそれ以外の this の使用例です。

public class Square {
    private int width;

    public int getWidth() {
        return width;
    }
    public void setWidth(int width) {
        this.width = width;
    }
    public int getArea() {
        int width = getWidth();
        return width * width;
    }
}

getArea メソッドではローカル変数 width が宣言されているのでこのメソッド内の width はすべてインスタンス変数ではなく、ローカル変数の方の width になります。

Square クラスはトップクラスなのでインスタンスメソッド内における単純名による変数やメソッドへのアクセスはすべて実行オブジェクトに対して行われます。 よってこれらの単純名の前には "this." を付けられます。 Square クラスで可能な限り this を明示すると以下のようになります。

public class Square {
    private int width;

    public int getWidth() {
        return this.width;
    }
    public void setWidth(int width) {
        this.width = width;
    }
    public int getArea() {
        int width = this.getWidth();
        return width * width;
    }
}

this は下のように synchronized ブロックでモニタとして使用される事もあります。

    synchronized (this) {
       ...
    }

    this();

public class Sub extends Super {
    private int value = this.show(1);
    {
        this.value = this.show(2);
        this.value2 = this.show(3);
    }
    private int value2 = this.show(4);

    public Sub() {
        this(5);
        System.out.println("Sub#constructor()");
    }
    public Sub(int value) {
        System.out.println("Sub#constructor(int)");
        this.value = this.show(value);
    }

    private int show(int value) {
        System.out.println("called show : " + value);
        return value;
    }
}

public class Super {
    public Super() {
        System.out.println("Super#constructor()");
    }
}

public class Main {
    public static void main(String[] args) {
        new Sub();
    }
}

Super#constructor()
called show : 1
called show : 2
called show : 3
called show : 4
Sub#constructor(int)
called show : 5
Sub#constructor()

    public static void main(String[] args) {
        new Sub();
    }

    public Sub() {
        this(5);
        System.out.println("Sub#constructor()");
    }

    public Sub(int value) {
        System.out.println("Sub#constructor(int)");
        this.value = show(value);
    }

    public Super() {
        System.out.println("Super#constructor()");
    }

Super#constructor()

    private int value = this.show(1);
    {
        this.value = this.show(2);
        this.value2 = this.show(3);
    }
    private int value2 = this.show(4);

called show : 1

called show : 2
called show : 3

called show : 4

        System.out.println("Sub#constructor(int)");
        this.value = show(value);

Sub#constructor(int)

called show : 5

Sub#constructor()

    private int value;
    private int value2;
    public Sub() {
        this(5);
        System.out.println("Sub#constructor()");
    }
    public Sub(int value) {
        this.value = this.show(1);
        this.value = this.show(2);
        this.value2 = this.show(3);
        this.value2 = this.show(4);
        System.out.println("Sub#constructor(int)");
        this.value = this.show(value);
    }

ここまでコンストラクタ内からオーバーロードされている別のコンストラクタを呼び出す際の this とインスタンスメソッドやコンストラクタを実行しているオブジェクトの参照を表す this を紹介しました。 このインスタンスメソッドやコンストラクタを実行しているオブジェクトの参照を表す方の this はクラスを明示する事ができます。

public class Foo {
    private int value;
    public Foo(int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
}

public class Foo {
    private int value;
    public Foo(int value) {
        this.value = value;
    }
    public int getValue() {
        return this.value;
    }
}

public class Foo {
    private int value;
    public Foo(int value) {
        Foo.this.value = value;
    }
    public int getValue() {
        return Foo.this.value;
    }
}

インナークラス (内部クラス) に関しては Java言語規定 第3版 8.1.3 (日本語訳) において以下のように定義されています。

8.1.3 Inner Classes and Enclosing Instances

An inner class is a nested class that is not explicitly or implicitly declared static.
内部クラス(inner class)は，明示的又は暗黙にstaticと宣言されない入れ子クラスとする。

最初にインナークラスのインスタンスを生成するコードを下の Outer と Outer.Inner クラスを使って紹介します。

public class Outer {
    private int value;
    public Outer(int value) {
        this.value = value;
    }

    class Inner {
        int getValue() {
            return value;
        }
    }
}

Outer outer = new Outer(100);
Outer.Inner inner = outer.new Inner();

public class Outer {
    private int value;
    private Inner inner = this.new Inner();
    public Outer(int value) {
        this.value = value;
    }
    Inner getInner() {
        return this.new Inner();
    }

    class Inner {
        int getValue() {
            return value;
        }
    }
}

        int getValue() {
            return Outer.this.value;
        }

        int getValue() {
            return this.value;
        }

下は Outer.this を明示しなければならない例です。

public class Outer {
    private int value;
    Inner inner = new Inner();
    public void setValue(int value) {
        this.value = value;
    }

    class Inner {
        private int value;
        Inner() {
            value = Outer.this.value;
        }
        int getValue() {
            return value;
        }
        int getOuterValue() {
            return Outer.this.value;
        }
        Outer getOuter() {
            return Outer.this;
        }
    }
}

public class Outer {
    private int value;
    Inner inner = Outer.this.new Inner();
    public void setValue(int value) {
        Outer.this.value = value;
    }

    class Inner {
        private int value;
        Inner() {
            Inner.this.value = Outer.this.value;
        }
        int getValue() {
            return Inner.this.value;
        }
        int getOuterValue() {
            return Outer.this.value;
        }
        Outer getOuter() {
            return Outer.this;
        }
    }
}

インナークラスがいくつ入れ子になっていてもエンクロージングオブジェクトの参照の表現は同じです。

public class Top {
    class Middle {
        class Bottom {
            Top getTop() {
                return Top.this;
            }
            Middle getMiddle() {
                return Middle.this;
            }
            Bottom getBottom() {
                return this;
            }
        }
    }
}

インナークラス以外、つまりトップクラス、ネストされたクラスで static 宣言しているクラス、インターフェイスにネストされたクラス、 static ブロックまたは static メソッド内のローカルクラスや匿名クラス、クラス変数初期化子における匿名クラスのインスタンスはエンクロージングオブジェクトを持ちません。 インスタンスメソッド、コンストラクタ、インスタンス初期化子内のローカルクラスや匿名クラス、あるいはインスタンス変数初期化子における匿名クラスのインスタンスはインスタンスメソッドやコンストラクタを実行しているオブジェクトをエンクロージングオブジェクトとして内部的に保持します。 ローカルクラスや匿名クラスにおけるエンクロージングオブジェクトの参照の表現もクラスにネストされたインナークラスと同じです。

---

this をキャストする

スーパークラスとサブクラスに同名の変数が存在する場合に this をキャストする必要が生じる場合があります。

オブジェクトはそのオブジェクトのクラスと Object クラスまでたどったすべてのスーパークラスのインスタンス変数の値を保持していますが、スーパークラスとサブクラスに同じ名前のフィールドが存在することや、あるクラスのフィールド名と実装しているインターフェイスに宣言されているフィールド名との重複などは許されています。 スーパークラスの private フィールドなどは通常ドキュメントに記述はありませんし、ソースコードが無ければその存在が分かりませんのでフィールド名の重複が起きてしまうのは仕方のない事と言えると思います。 ただし同じクラス内での重複した名前のフィールドの宣言は型や static 、非 static に関わらずコンパイルエラーとなります。

スーパークラスとサブクラスで同名のフィールドの存在を許可している以上それらを区別する手段が用意されているはずです。 オブジェクトを通したフィールドアクセスではコンパイル時のオブジェクトの型によって アクセスするフィールドが変わってきます。 あるクラスとそのスーパークラスで重複したフィールド名が存在する場合にはアクセスしたい方のフィールドを宣言したクラスをコンパイル時の型にすることでフィールドを限定できます。 以下はコンパイル時のオブジェクトの型とアクセスするフィールドの決定に関するプログラムです。

public class First {
    protected int value = 1;
}

public class Second extends First {
    protected int value = 2;
}

public class Third extends Second {
    protected int value = 3;
}

public class Main {
    static First toFirst(Second second) {
        System.out.println(second.value);
        return second;
    }

    public static void main(String[] args) {
        Third third = new Third();
        Second second = third;
        First first = third;

        System.out.println(third.value + "  " +
                           second.value + "  " +
                           first.value);

        System.out.println(third.value + "  " +
                           ((Second)third).value + "  " +
                           ((First)third).value);

        System.out.println(toFirst(third).value);
    }
}

実行結果は以下です。

3  2  1
3  2  1
2
1

First, Second, Third は継承関係にあり、それぞれに value というフィールドが宣言されています。 よって Third クラスのインスタンスは First で宣言した value と Second で宣言した value と Third で宣言した value の 3 つの value というフィールドを保持します。 main メソッドでは Third オブジェクトのコンパイル時の型を変更することでこれら３つのフィールドの値を取得しています。 オブジェクトのコンパイル時の型とはソースコードに記述されている静的な型で変数や仮引数、戻り値の型、あるいはキャスト演算子でキャストされた型などです。

順に main のコードを追っていきます。

        Third third = new Third();

まずThird クラスのインスタンスを生成しています。 Third 型のローカル変数 third が保持する Third オブジェクトは状態として以下のように３つの value の値を保持しています。 ( ) 内は value を宣言したクラスです。



次に Second 型のローカル変数 second と First 型のローカル変数 first を宣言し third が保持している Third オブジェクトの参照を代入しています。

        Second second = third;
        First first = third;

そしてそれらの変数を通してフィールドの値を取得して標準出力に出力します。

        System.out.println(third.value + "  " +
                           second.value + "  " +
                           first.value);

変数を通したアクセスでは変数の型がコンパイル時の型になるので third のコンパイル時の型は Third となり、 second は Second で first は First となり、それらのクラスに宣言されている value の値が取得されるので標準出力に以下が表示されます。

3  2  1

次にキャストによる型の変換ですが

        System.out.println(third.value + "  " +
                           ((Second)third).value + "  " +
                           ((First)third).value);

Third 型の変数 third を Second や First にキャストしていますが、変数に限らずオブジェクトの参照を表す式をキャストしている場合はコンパイラはキャスト後の型をコンパイル時の型とします。 よって (Second)third のコンパイル時の型は Second 型、 (First)third は First 型になるので標準出力に以下が表示されます。

3  2  1

最後はメソッドの戻り値や仮引数の場合です。

        System.out.println(toFirst(third).value);

メソッドの戻り値や仮引数も宣言されている型がコンパイル時の型となります。 toFirst メソッドは

    static First toFirst(Second second) {
        System.out.println(second.value);
        return second;
    }

となっており、まず仮引数の Second 型の second はコンパイル時の型も Second ですから third が参照している Third オブジェクトの持つ Second クラスで宣言された value の値が標準出力に出力されます。

2

そして戻り値の型は First なので toFirst(third) の結果の型は First となるので標準出力に以下が表示されます。

1

this もキャストによってコンパイル時の型を変更できます。
下は this をキャストすることによって、隠蔽しているスーパークラスのフィールドにアクセスしている例です。

public class First {
    protected int value = 1;
}

public class Second extends First {
    protected int value = 2;
}

public class Third extends Second {
    protected int value = 3;

    public void show() {
        System.out.println(value + "  " +
                           ((Second)this).value + "  " +
                           ((First)this).value);
    }

    public void setValue(int value) {
        this.value = value;
    }
    public void setSecondValue(int value) {
        ((Second)this).value = value;
    }
    public void setFirstValue(int value) {
        ((First)this).value = value;
    }
}

public class Main {
    public static void main(String[] args) {
        Third third = new Third();
        third.show();
        third.setValue(30);
        third.setSecondValue(20);
        third.setFirstValue(10);
        third.show();
    }
}

実行結果は以下です。

3  2  1
30  20  10

以上フィールドアクセスにおける this のキャストに関する内容でしたが、クラスを作成する際にアクセス可能な上位クラスのフィールドと同じ名前のフィールドをわざわざ宣言する必要があるケースを思いつきませんでした。 反対にクラス作成者以外の人がそのソースコードを読んだ場合に混乱の原因となり、あまり良いことは無いと思われます。

フィールドアクセスと違い、インスタンスメソッドにアクセスする場合に this をキャストするのは、ほとんどの場合に無意味です。 ポリモーフィズムによりインスタンスメソッドがオーバーライドされている場合にはその上書きしている方のメソッドが実行される為、ほとんどの場合に this をキャストしてコンパイル時の型を変更しても実行されるインスタンスメソッドは同じだからです (static メソッドの場合にはコンパイル時の型で実行するメソッドが変わってきますが static メソッドにはクラス名を使ってアクセスするべきです)。
"ほとんど" というのは例外があるからです。 下のプログラムはその例外のサンプルです。

public class Foo {
    private String getName() {
        return "Foo";
    }

    static class Bar extends Foo {
        public String getName() {
            return "Bar";
        }
        public void show() {
            System.out.println(this.getName() + '\n' +
                               ((Foo)this).getName());
        }
    }

    public static void main(String[] args) {
        Bar bar = new Bar();
        bar.show();
    }
}

Bar
Foo

上の例以外にも同じクラスにネストされた２つのクラスが継承関係にある場合など、 あるトップクラスの宣言内ではどの private メンバにもアクセスできるので同じような現象が起きます。 （フィールドに対するアクセスの例がフィールドアクセスのページにあります）

キーワード super は Object クラスでは使えませんが、それ以外は this と同じ場所で使用可能で、インスタンスメソッドやコンストラクタ、インスタンス初期化子 (初期化ブロック) の中やインスタンス変数初期化子 (インスタンス変数宣言時の右辺の初期化式) の中です。

コンストラクタ内の super() または super(arg1 ...) はスーパークラスのコンストラクタの呼び出しを行います。 スーパークラスのコンストラクタの呼び出しはコンストラクタの最初にしか記述できません。 それ以外の場所ではコンパイルエラーになります。 コンストラクタ内の this でも触れましたが Object 以外のクラスではコンストラクタの一番最初の部分ではそのクラスのオーバーロードされているコンストラクタかスーパークラスのコンストラクタの呼び出しを記述する必要があります。 それらが記述されていないコンストラクタを持つクラスのソースはコンパイルの際にデフォルトコンストラクタの呼び出し

super();

フィールドにアクセスする場合の super は this をスーパークラスの型にキャストするのと等価です。

public class A {
  protected String name = "A";
}

public class B extends A {
    protected String name = "B";
    public void showSuper() {
        System.out.println(((A)this).name + ' ' + super.name);
    }
    public static void main(String[] args) {
        new B().showSuper();
    }
}

A A

ネストされたクラスにおけるエンクロージングオブジェクトに対する super の使い方は以下です。

public class A {
    protected String name = "A";
}

public class B extends A {
    protected String name = "B";
    class C {
        String name = "C";
        public void showName() {
            System.out.println(name + ' ' + B.this.name + ' ' + B.super.name);
        }
    }
    public static void main(String[] args) {
        new B().new C().showName();
    }
}

C B A

super を使ったインスタンスメソッドへのアクセスはフィールドへのアクセスとは違い this をスーパークラスの型にキャストしてインスタンスメソッドの呼び出しを行うのとはまったく異なる結果になります。

public class A {
    protected String getName() {
        return "A";
    }
}

public class B extends A {
    protected String getName() {
        return "B";
    }
    public void showSuper() {
        System.out.println(((A)this).getName());
        System.out.println(super.getName());
    }
}

public class C extends B {
    protected String getName() {
        return "C";
    }
}

public class Main {
    public static void main(String[] args) {
        new C().showSuper();
    }
}

C
A

        System.out.println(((A)this).getName());

        System.out.println(super.getName());

注意が必要なのは super を使ったメソッドアクセスにおいては super が表す型はコンパイル時に決定し、 実行オブジェクトの "オブジェクトのクラス" (実行時の型) は関係ないということです。main は以下のようになっています。

        new C().showSuper();

    public void showSuper() {
        System.out.println(((A)this).getName());
        System.out.println(super.getName());
    }