Javaのポリモーフィズム(多態性)は、同じメソッド呼び出しで、変数に入っている実際の型ごとに違う処理が動く仕組みです。
shape.area() と1行書けば、中身が円なら円の面積、四角なら四角の面積が計算されます。呼び出す側は相手の型を知らなくて済みます。
ただ、「同じ呼び出しで違う処理」と覚えただけだと、オーバーロードの選ばれ方やstaticメソッドの動きで手が止まります。どちらも「いつ、どの型を見て決まるか」を押さえれば説明がつく話なので、全コードを手元の javac で実行した出力付きで確かめていきます。
この記事でわかること
- ポリモーフィズムの定義と、「宣言された型」「実際の型」の見分け方
- オーバーライドは実行時、オーバーロードはコンパイル時に決まる理由(実行結果付き)
- インターフェースと抽象クラスで書く実例、if/instanceof の分岐を置き換える前後
- sealed とパターンマッチの switch(Java 21)との使い分け
- static メソッド・フィールドの隠蔽、コンストラクタ内の呼び出し、@Override を付ける理由
コードは OpenJDK 23.0.1 の javac に --release 21 を付けてコンパイルし、実行して確認しました。Java 21 の言語仕様の範囲で動くコードです。
PARTS LIST /目次
Javaのポリモーフィズムとは?同じ呼び出しで違う処理が動く仕組み
ポリモーフィズムとは、ひとつの呼び出し方に対して、受け取ったオブジェクトの実際の型ごとに別の実装が選ばれる性質です。日本語では多態性・多相性と訳されます。Javaではクラスの継承(extends)とインターフェースの実装(implements)で実現します。
動きそのものは数行のコードで確かめられます。むしろ大事なのは、1つの変数に「宣言された型」と「実際の型」の2つがあることです。オーバーロードの選ばれ方も、staticメソッドの隠蔽も、結局はこの2つのどちらを見ているかの違いにすぎません。
多態性を最小のコードで動かす
最小の例は、インターフェース1つと実装クラス2つで書けます。Shape を実装した Circle と Square を同じリストに入れ、ループの中では s.area() だけを呼びます。
import java.util.List;
interface Shape {
double area();
}
class Circle implements Shape {
private final double r;
Circle(double r) { this.r = r; }
@Override
public double area() { return Math.PI * r * r; }
}
class Square implements Shape {
private final double side;
Square(double side) { this.side = side; }
@Override
public double area() { return side * side; }
}
public class Main {
public static void main(String[] args) {
List<Shape> shapes = List.of(new Circle(1), new Square(2));
for (Shape s : shapes) {
// 呼び出しは s.area() の1種類だけ
System.out.printf("%s: %.2f%n", s.getClass().getSimpleName(), s.area());
}
}
}
実行結果は次のとおりです。
Circle: 3.14
Square: 4.00
ループの中に「円なら」「四角なら」の分岐はありません。それでも型ごとに正しい計算が動いています。三角形を足したくなったら Triangle implements Shape を1つ書くだけで、ループ側は1文字も変わりません。
「宣言された型」と「実際の型」を分けて考える
Shape s = new Circle(1); という1行には、型が2つ出てきます。左の Shape が変数の宣言された型(コンパイル時の型)、右の Circle が実際に作られたオブジェクトの型(実行時の型)です。
同じ1行に出てくる2つの型
s に対して呼べるのは Shape が持つメソッドだけです。Circle に radius() を足しても、s.radius() はコンパイルエラーになります。一方で s.area() を呼んだときに動く中身は、実行時の Circle が決めます。
この表の「何に効くか」の列が、記事の後半でそのまま答えになります。迷ったらここへ戻ってきてください。
ポリモーフィズムの3つの種類
「同じ名前で違う型を扱える」性質は、広い意味では3種類に分けられます。ふだん Java で「ポリモーフィズム」と言えば、このうちサブタイプ多相(オーバーライド)を指します。残りの2つも、Java の中で毎日使っています。
ポリモーフィズムの3つの種類
3つを1つのコードに並べると、次のようになります。
import java.util.List;
public class Main {
// オーバーロード(アドホック多相): 引数の型ごとに別のメソッド
static String label(int x) { return "int: " + x; }
static String label(String s) { return "String: " + s; }
// ジェネリクス(パラメトリック多相): 1つのメソッドがどの型でも動く
static <T> T first(List<T> list) { return list.get(0); }
public static void main(String[] args) {
System.out.println(label(42));
System.out.println(label("java"));
String s = first(List.of("a", "b"));
Integer n = first(List.of(1, 2));
System.out.println(s + " / " + n);
// サブタイプ多相: 宣言は Object、動くのは各クラスの toString
List<Object> objs = List.of("text", 10, List.of(1));
for (Object o : objs) {
System.out.println(o.getClass().getSimpleName() + " -> " + o.toString());
}
}
}
int: 42
String: java
a / 1
String -> text
Integer -> 10
List12 -> [1]
最後の行の List12 は、List.of が内部で使っている JDK のクラス名です(公開された API ではないので、JDK の版で変わることがあります)。私たちはこのクラス名を一度も書いていません。それでも toString() を呼べば、そのクラスの実装が [1] と表示してくれます。実際の型を知らないまま正しく動くのが、サブタイプ多相のありがたいところです。
ジェネリクスの書き方は「Javaジェネリクス入門」で扱っています。この記事では、以降サブタイプ多相とオーバーロードの2つに絞って、選ばれ方の違いを追います。
オブジェクト指向の3要素の中での位置
ポリモーフィズムは、カプセル化・継承と並ぶオブジェクト指向の3要素の1つとして紹介されます。3つは独立した部品というより、順番に積み上がる関係です。
- カプセル化で、データと処理をクラスの中にまとめる
- 継承やインターフェースで、複数のクラスに共通の型を与える
- ポリモーフィズムで、その共通の型を通して呼び出し、中身はクラスごとに任せる
3要素の全体像とそれぞれの入門的な説明は「Javaオブジェクト指向とは?3大要素の仕組み」にまとめています。この記事はそこから一歩進んで、「どのメソッドが選ばれるか」の規則と、実務で踏みやすい落とし穴に絞ります。
オーバーライドとオーバーロードの違いは「決まるタイミング」
オーバーライドとオーバーロードは名前が似ていて、入門書でも並べて説明されます。違いを一言で言うと、オーバーライドは実行時に実際の型で決まり、オーバーロードはコンパイル時に宣言された型で決まります。
Javaの言語仕様(JLS 15.12)では、メソッド呼び出しは2段階で処理されます。コンパイル時に「どのシグネチャ(メソッド名と引数の型の並び)を呼ぶか」を決め、実行時に「そのシグネチャの実装をどのクラスから探すか」を決めます。オーバーロードは前半、オーバーライドは後半の話です。
flowchart TD
A["a.meet(b) を呼ぶ"] --> B["コンパイル時<br/>a と b の宣言された型で<br/>シグネチャを1つに決める"]
B --> C["実行時<br/>a の実際のクラスから<br/>そのシグネチャの実装を探す"]
C --> D["見つかった実装を実行"]
オーバーライドは実行時に実際の型で決まる
オーバーライドは、親クラスやインターフェースと同じシグネチャのインスタンスメソッドを、子クラスで書き直すことです。JLS 8.4.8.1 の条件の中心は、シグネチャが親のメソッドと一致すること(正確にはサブシグネチャになること)です。インスタンスメソッドがこの条件を満たすと、親のメソッドをオーバーライドします。
実行時の動きは JLS 15.12.4.4 にあります。インスタンスメソッドの呼び出しでは「動的メソッド探索」が行われ、探索は対象オブジェクトの実際のクラスから始まります。最初の Shape の例で Circle.area() が動いたのは、この探索のおかげです。
オーバーライドには守る条件がいくつかあります。JLS 8.4.8.3 の内容を表にしました。
オーバーライドの条件(JLS 8.4.8.3)
オーバーロードはコンパイル時に宣言された型で決まる
オーバーロードは、同じ名前で引数の型や数が違うメソッドを複数並べることです。どれを呼ぶかはコンパイル時に、引数の宣言された型で決まります。中身が何であっても関係ありません。
次のコードでは、print(Object) と print(String) を用意して、同じ文字列 "hello" を3通りの変数から渡しています。
public class Main {
static void print(Object o) { System.out.println("Object版: " + o); }
static void print(String s) { System.out.println("String版: " + s); }
public static void main(String[] args) {
String s = "hello";
Object o = "hello"; // 中身は同じ String
print(s);
print(o);
print((String) o);
}
}
実行結果です。
String版: hello
Object版: hello
String版: hello
2行目に注目してください。o の中身は String なのに、Object版が呼ばれています。コンパイラが見ているのは Object o という宣言だけだからです。キャストで宣言された型を String に変えた3行目は、String版に戻りました。
オーバーロードは中身ではなく宣言された型で選ばれる。オーバーライドと同じ感覚で「実行時に中身を見て選んでくれる」と期待すると、ここで裏切られます。
両方が混ざると何が起きるか
オーバーライドとオーバーロードが同じクラスにあると、2段階の処理がはっきり見えます。Animal に meet(Animal) と meet(Dog) を用意し、Dog で両方をオーバーライドします。
class Animal {
String meet(Animal other) { return "Animal と Animal"; }
String meet(Dog other) { return "Animal と Dog"; }
}
class Dog extends Animal {
@Override
String meet(Animal other) { return "Dog と Animal"; }
@Override
String meet(Dog other) { return "Dog と Dog"; }
}
public class Main {
static void num(long x) { System.out.println("long版"); }
static void num(Integer x) { System.out.println("Integer版"); }
public static void main(String[] args) {
Animal a = new Dog(); // 実際の型は Dog
Animal b = new Dog(); // 実際の型は Dog だが、宣言は Animal
System.out.println(a.meet(b));
System.out.println(a.meet((Dog) b));
num(10); // int を渡す
}
}
Dog と Animal
Dog と Dog
long版
1行目は「Dog と Dog」にはなりません。コンパイル時に b の宣言された型 Animal を見て meet(Animal) が選ばれ、実行時に a の実際の型 Dog から meet(Animal) の実装が探されたからです。前半を「Dog」にしたのはオーバーライド、後半を「Animal」にしたのはオーバーロードの規則です。
3行目の num(10) も、知らないと外す問題です。JLS 15.12.2 では、オーバーロードの候補探しを3段階で行います。1段階目はボクシング(int から Integer への自動変換)も可変長引数も使わずに探し、見つかればそこで終わります。int から long への拡大変換は1段階目で使えるので、Integer 版まで進まずに long 版が選ばれました。
引数の実際の型ごとに処理を変えたくて、同じ名前のメソッドを型違いで並べる書き方は、引数を親の型の変数で渡した瞬間に崩れます。上の a.meet(b) のように、呼ばれるのは宣言された型に合うメソッドだけです。
実際の型で処理を変えたいなら、処理をそのクラス自身に持たせてオーバーライドするか、後で紹介するパターンマッチの switch で型を調べます。
インターフェースで書くポリモーフィズムの実例
実務でいちばんよく見るポリモーフィズムは、インターフェースを通した呼び出しです。クラスの継承と違って、無関係なクラス同士にも共通の型を与えられます。1つのクラスが複数のインターフェースを実装することもできます。
ここでは支払い方法の切り替えを例にします。呼び出す側が実装クラスの名前を一度も書かずに済むところを見てください。
支払い方法をインターフェースで切り替える
PaymentMethod に「名前」と「手数料」の2つを約束させ、クレジットカード・コンビニ払い・銀行振込の3クラスで実装します。レシートを作る Checkout は PaymentMethod しか知りません。
import java.util.List;
interface PaymentMethod {
String name();
int fee(int amount); // 手数料(円)
}
class CreditCard implements PaymentMethod {
@Override public String name() { return "クレジットカード"; }
@Override public int fee(int amount) { return 0; }
}
class ConvenienceStore implements PaymentMethod {
@Override public String name() { return "コンビニ払い"; }
@Override public int fee(int amount) { return amount >= 10_000 ? 0 : 220; }
}
class BankTransfer implements PaymentMethod {
@Override public String name() { return "銀行振込"; }
@Override public int fee(int amount) { return 330; }
}
class Checkout {
// Checkout は PaymentMethod しか知らない
String receipt(int amount, PaymentMethod method) {
int total = amount + method.fee(amount);
return String.format("%s: 商品 %,d円 + 手数料 %,d円 = %,d円",
method.name(), amount, method.fee(amount), total);
}
}
public class Main {
public static void main(String[] args) {
Checkout checkout = new Checkout();
List<PaymentMethod> methods =
List.of(new CreditCard(), new ConvenienceStore(), new BankTransfer());
for (PaymentMethod m : methods) {
System.out.println(checkout.receipt(3_000, m));
}
}
}
クレジットカード: 商品 3,000円 + 手数料 0円 = 3,000円
コンビニ払い: 商品 3,000円 + 手数料 220円 = 3,220円
銀行振込: 商品 3,000円 + 手数料 330円 = 3,330円
手数料の金額は説明用の仮の値です。ポイントは、QRコード決済を足すときに Checkout を開かなくていいことです。新しいクラスを1つ書いて渡せば、レシートの組み立ては今のまま動きます。
List<String> list = new ArrayList<>() も同じ仕組み
自分でインターフェースを書いたことがなくても、ポリモーフィズムはもう使っています。List<String> list = new ArrayList<>(); がその例です。
宣言された型は List、実際の型は ArrayList です。list.add("a") で動くのは ArrayList の add で、あとで new LinkedList<>() に差し替えても list を使う側のコードは変わりません。メソッドの引数や戻り値を List で書く習慣は、この差し替えやすさを残すためのものです。
Spring Boot でサービスやリポジトリをインターフェース型のフィールドで受けるのも同じ考え方です。テストでは本物の代わりにモックの実装を渡せます。
インターフェースの構文(default・staticメソッド、関数型インターフェース、ラムダ式との組み合わせ)は、別の記事で詳しく扱っています。
抽象クラスで書くポリモーフィズムの実例
抽象クラスは、共通の処理を持ちながら、一部だけを子クラスに任せたいときに使います。インターフェースと違ってフィールドやコンストラクタを持てるので、「手順の骨組みは親が持ち、中身は子が書く」形と相性がいい道具です。
ここではレポート出力を例に、親が手順を固定し、子が中身を埋める書き方を見ます。デザインパターンでは Template Method と呼ばれる形です。
共通の手順を親に置くテンプレートメソッド
Report の render() は、ヘッダー・本文・フッターの順に組み立てる手順を持ちます。final を付けて、子クラスが順番を変えられないようにしました。
abstract class Report {
// 手順は親が決める。final にして順番を変えさせない
public final String render() {
return header() + "\n" + body() + "\n" + footer();
}
protected String header() { return "== " + title() + " =="; }
protected String footer() { return "-- end --"; }
protected abstract String title();
protected abstract String body();
}
class SalesReport extends Report {
@Override protected String title() { return "売上"; }
@Override protected String body() { return "今月: 120件"; }
}
class ErrorReport extends Report {
@Override protected String title() { return "エラー"; }
@Override protected String body() { return "WARN 3件 / ERROR 1件"; }
@Override protected String footer() { return "-- 要確認 --"; }
}
public class Main {
public static void main(String[] args) {
Report[] reports = { new SalesReport(), new ErrorReport() };
for (Report r : reports) {
System.out.println(r.render());
}
}
}
== 売上 ==
今月: 120件
-- end --
== エラー ==
WARN 3件 / ERROR 1件
-- 要確認 --
render() は親クラスに1つしかないのに、中で呼ぶ title() や body() は子クラスのものが動いています。親のメソッドの中から呼んだ場合でも、動的メソッド探索は this の実際のクラスから始まるからです。ErrorReport だけ footer() を上書きした結果も、そのまま出力に出ています。
インターフェースと抽象クラスの選び方
どちらでもポリモーフィズムは書けます。迷ったら、まずインターフェースで書き、共通の状態や処理が本当に必要になってから抽象クラスを検討する順番が無難です。
ポリモーフィズムの受け皿としての比較
抽象クラスの構文や、default メソッドが入ってから両者の境界がどう変わったかは「Java抽象クラスとは?インターフェースとの違い」で扱っています。継承そのもの(extends・super・多重継承できない理由)は「Java extendsの使い方」が入口です。
if/instanceofの分岐をポリモーフィズムに置き換える
ポリモーフィズムがいちばん効くのは、型ごとの if 文や instanceof の分岐が何か所にも散らばったコードです。分岐を各クラスのメソッドに移すと、型を足すたびに直す場所が1か所になります。
通知の送信を例に、置き換える前と後を並べます。どちらも同じ出力になることを確かめてから、何が変わったかを見ます。
Before:型ごとの分岐が増えていくコード
メール・Slack・SMS の3種類を、Object で受けて instanceof で振り分けています。Java 16 からの instanceof Mail m の書き方(パターンマッチ)を使っているので、キャストは省けています。
class Mail { String to; Mail(String to) { this.to = to; } }
class Slack { String channel; Slack(String c) { this.channel = c; } }
class Sms { String phone; Sms(String p) { this.phone = p; } }
public class Before {
static String send(Object n) {
if (n instanceof Mail m) {
return "メール送信: " + m.to;
} else if (n instanceof Slack s) {
return "Slack投稿: #" + s.channel;
} else if (n instanceof Sms s) {
return "SMS送信: " + s.phone;
}
throw new IllegalArgumentException("未対応: " + n.getClass());
}
public static void main(String[] args) {
Object[] list = { new Mail("tom@example.com"), new Slack("dev"), new Sms("090-0000-0000") };
for (Object n : list) {
System.out.println(send(n));
}
}
}
メール送信: tom@example.com
Slack投稿: #dev
SMS送信: 090-0000-0000
動きはします。困るのは、LINE 通知を足したときです。send の分岐に足し忘れてもコンパイルは通り、実行して初めて IllegalArgumentException が出ます。「送信前のチェック」「ログ出力」のように同じ分岐を持つメソッドが3つあれば、3か所とも直す必要があります。
After:各クラスに処理を持たせる
Notifier インターフェースに send() を約束させ、送り方の違いは各クラスの中に書きます。
import java.util.List;
interface Notifier {
String send();
}
class MailNotifier implements Notifier {
private final String to;
MailNotifier(String to) { this.to = to; }
@Override public String send() { return "メール送信: " + to; }
}
class SlackNotifier implements Notifier {
private final String channel;
SlackNotifier(String channel) { this.channel = channel; }
@Override public String send() { return "Slack投稿: #" + channel; }
}
class SmsNotifier implements Notifier {
private final String phone;
SmsNotifier(String phone) { this.phone = phone; }
@Override public String send() { return "SMS送信: " + phone; }
}
public class After {
public static void main(String[] args) {
List<Notifier> list = List.of(
new MailNotifier("tom@example.com"),
new SlackNotifier("dev"),
new SmsNotifier("090-0000-0000"));
for (Notifier n : list) {
System.out.println(n.send()); // 分岐が消えた
}
}
}
メール送信: tom@example.com
Slack投稿: #dev
SMS送信: 090-0000-0000
出力は Before と同じです。変わったのは、型を足したときの直し方です。
Before(instanceof の分岐)
LINE を足すと、分岐を持つメソッドを全部探して直す。足し忘れはコンパイルで見つからず、実行時の例外で気づく。
After(ポリモーフィズム)
LineNotifier を1クラス書くだけ。send() を書き忘れると implements の時点でコンパイルエラーになる。
置き換えないほうがよい場面
何でもクラスに移せばいいわけでもありません。次のような場面では、分岐のまま残すほうが読みやすいことがあります。
- 分岐が1か所にしかなく、今後も型が増える見込みがない
- 分岐の対象が
Stringやintの値で、型ではない(この場合は switch や enum の出番) - 対象のクラスが外部ライブラリのもので、メソッドを足せない
- 処理の種類のほうが頻繁に増える(次の節の sealed と switch が向いている)
継承を深くしすぎたり、1つの分岐のためにインターフェースを3つ作ったりすると、今度は「処理がどこにあるか探せない」問題が出ます。過剰設計を避ける考え方は「Javaデザインパターン入門|過剰設計しない5選」にも書きました。
オブジェクト指向が「わからない」状態から抜けられたのは、本の説明を読み返したときではありませんでした。簡単なアプリで、実際にクラスを設計してみたときです。
Java Silver の勉強でも同じで、本を読み込むだけでは身につかず、1回目は55%で不合格でした。問題集を3周やり直して、2回目は82%で合格しています。この記事のコードも、読むより一度コピーして動かしたほうが早いはずです。宣言の型を1つ書き換えて、出力がどう変わるかを見るだけでも感覚が違います。
sealedとパターンマッチのswitch(Java 21)との使い分け
Java 21 では、パターンマッチの switch(JEP 441)が正式な機能になりました。Java 17 で正式になった sealed(JEP 409)と組み合わせると、「型ごとの分岐」をコンパイラに漏れなくチェックさせられます。
すると、前の節で「分岐は避けよう」と書いた話と矛盾するように見えます。実際には、2つは得意な変更の向きが逆です。どちらを選ぶかは、今後「型」と「処理」のどちらが増えるかで決めます。
sealed interface+record+switchの書き方
Shape を sealed にして、実装できる型を Circle・Rect・Triangle の3つに限定します。データは record で持ち、面積の計算は Shape の外の switch に書きます。
import java.util.List;
sealed interface Shape permits Circle, Rect, Triangle {}
record Circle(double r) implements Shape {}
record Rect(double w, double h) implements Shape {}
record Triangle(double base, double height) implements Shape {}
public class Main {
// 処理は Shape の外に置き、型ごとに switch で分ける
static double area(Shape s) {
return switch (s) {
case Circle c -> Math.PI * c.r() * c.r();
case Rect r -> r.w() * r.h();
case Triangle t -> t.base() * t.height() / 2;
}; // sealed なので default が要らない
}
static String describe(Shape s) {
return switch (s) {
case Circle c when c.r() > 10 -> "大きな円";
case Circle c -> "円";
case Rect r -> r.w() == r.h() ? "正方形" : "長方形";
case Triangle t -> "三角形";
};
}
public static void main(String[] args) {
List<Shape> shapes = List.of(new Circle(1), new Circle(20), new Rect(2, 2), new Triangle(3, 4));
for (Shape s : shapes) {
System.out.printf("%s: %.2f%n", describe(s), area(s));
}
}
}
円: 3.14
大きな円: 1256.64
正方形: 4.00
三角形: 6.00
ここで permits に Hexagon を足し、record Hexagon(double side) implements Shape {} を書いてコンパイルすると、switch の側で止まります。
Main.java:13: エラー: switch式がすべての可能な入力値をカバーしていません
return switch (s) {
^
Main.java:21: エラー: switch式がすべての可能な入力値をカバーしていません
return switch (s) {
^
エラー2個
Before の instanceof 版では実行時の例外だった「足し忘れ」が、コンパイルエラーに変わりました。when で条件を付けた case(ガード)が書けるのも、オーバーライドにはない便利さです。switch 式そのものの書き方(アロー構文や yield)は「Javaのswitch文」に、record は「Javaのrecordとは?」にまとめています。
「型が増える」か「処理が増える」かで選ぶ
ポリモーフィズムとパターンマッチの switch は、どちらも「型ごとに違う処理」を書く道具です。違うのは、処理をどこに置くかです。
変更の向きで選ぶ
支払い方法の例は、今後も種類が増えるのでポリモーフィズムが向いています。図形の例は、種類はほぼ固定で「面積」「周の長さ」「表示名」と処理のほうが増えていくので、sealed と switch が向いています。

迷ったら「来月、足されそうなのはクラスとメソッドのどっち?」と考えると決めやすくなります。答えがクラスならオーバーライド、メソッドなら switch。両方増えそうなら、たぶんまだ設計が固まっていない合図です。
ポリモーフィズムの落とし穴4つ
オーバーライドされると思っていたのに、されない。そんな場面が Java には少なくとも4つあります。どれもコンパイルは通るか、通ったように見えるので、出力を見て初めて気づく種類のバグです。
4つとも、最初の節の表で「宣言された型」の列に入っていたものです。実際の型で選ばれるのは、オーバーライドされたインスタンスメソッドだけです。
staticメソッドはオーバーライドされず隠蔽される
子クラスで親と同じシグネチャの static メソッドを書くと、オーバーライドではなく隠蔽(hiding)になります。JLS 8.4.8.2 の規則で、どちらが呼ばれるかはコンパイル時の型で決まります。
class Parent {
static String who() { return "Parent.who"; }
String name = "Parent.name";
String hello() { return "Parent.hello"; }
}
class Child extends Parent {
static String who() { return "Child.who"; } // 隠蔽(オーバーライドではない)
String name = "Child.name"; // フィールドも隠蔽
@Override
String hello() { return "Child.hello"; }
}
public class Main {
public static void main(String[] args) {
Parent p = new Child();
System.out.println(p.hello()); // インスタンスメソッド
System.out.println(p.who()); // static メソッド(警告が出る書き方)
System.out.println(p.name); // フィールド
System.out.println(((Child) p).name);
}
}
Child.hello
Parent.who
Parent.name
Child.name
p の中身は同じ Child なのに、hello() だけが Child 版です。p.who() は Parent.who() と書いたのと同じ意味です。
javac -Xlint:all を付けてコンパイルすると、p.who() の行で「static メソッドは式ではなく型名Parentで修飾する必要があります」という警告が出ました。static メソッドは Parent.who() のように型名で呼ぶ習慣にしておけば、誤解の入り口がなくなります。なお、Child.who() に @Override を付けると「staticメソッドは@Overrideで注釈付けすることはできません」というコンパイルエラーになりました。
フィールドも実際の型では選ばれない
同じコードの3行目と4行目がフィールドの例です。p.name は Parent.name、Child にキャストすると Child.name が出ました。
JLS 8.3 では、子クラスが親と同じ名前のフィールドを宣言すると、親のフィールドを隠すと定めています。フィールドにはオーバーライドがなく、どちらを読むかは宣言された型で決まります。インスタンスの中には name が2つ並んで存在している状態です。
対策は単純で、子クラスで親と同じ名前のフィールドを宣言しないことです。フィールドを private にしてメソッド経由で読ませておけば、メソッド側はオーバーライドできるので、この問題自体が起きません。データを隠して外から直接触らせない設計(カプセル化)が、ここでも効いてきます。
コンストラクタからオーバーライドされるメソッドを呼ぶ
親のコンストラクタの中でオーバーライドできるメソッドを呼ぶと、子クラスのフィールドが初期化される前に子の実装が動きます。
class Base {
Base() {
init(); // 親のコンストラクタからオーバーライドされるメソッドを呼ぶ
}
void init() { System.out.println("Base.init"); }
}
class Sub extends Base {
private final String label = "設定済み";
private String path = "/tmp/app";
@Override
void init() {
System.out.println("Sub.init: label=" + label + ", path=" + path);
}
}
public class Main {
public static void main(String[] args) {
new Sub();
}
}
Sub.init: label=設定済み, path=null
path が null になりました。new Sub() では、先に Base のコンストラクタが動き、その後で Sub のフィールドに初期値が入ります。init() は動的メソッド探索で Sub 版が選ばれるので、初期値が入る前の path を読んでしまいます。
label だけ値が入っているのは、final で文字列リテラルを代入したフィールドがコンパイル時の定数として扱われ、値が埋め込まれたためです。試しに final を外して実行すると、label=null, path=null になりました。たまたま動く行と動かない行が混ざるので、余計に原因を探しにくいバグです。コンストラクタからは、private か final のメソッドだけを呼ぶようにします。
@Overrideを付けないと別メソッドが増える
@Override は、「このメソッドは親のメソッドをオーバーライドしている」とコンパイラに確かめさせる注釈です。JLS 9.6.4.4 では、付けたメソッドが実際にはオーバーライドしていなければコンパイルエラーにすると決めています。付けなくても動きますが、付けないと綴りや引数の型の間違いが素通りします。
まず、toString の s を小文字にした例です。@Override を付けてコンパイルすると止まります。
class User {
private final String name;
User(String name) { this.name = name; }
@Override
public String tostring() { // toString の s を小文字にしてしまった
return "User(" + name + ")";
}
}
public class Main {
public static void main(String[] args) {
System.out.println(new User("tom"));
}
}
Main.java:5: エラー: メソッドはスーパータイプのメソッドをオーバーライドまたは実装しません
@Override
^
エラー1個
@Override の行を消すとコンパイルは通り、User@2a139a55 のような出力になります(@ 以降の値は実行ごとに変わります)。tostring() という新しいメソッドが1つ増えただけで、toString() は Object のままだからです。
もっと気づきにくいのが、引数の型を間違えた equals です。
import java.util.HashSet;
import java.util.Set;
class Point {
final int x, y;
Point(int x, int y) { this.x = x; this.y = y; }
// 引数を Point にしてしまった。Object.equals(Object) のオーバーロードになる
public boolean equals(Point other) {
return other != null && x == other.x && y == other.y;
}
@Override
public int hashCode() { return 31 * x + y; }
}
public class Main {
public static void main(String[] args) {
Point a = new Point(1, 2);
Point b = new Point(1, 2);
Object ob = b;
System.out.println(a.equals(b)); // Point 版が選ばれる
System.out.println(a.equals(ob)); // Object 版が選ばれる
Set<Point> set = new HashSet<>();
set.add(a);
System.out.println(set.contains(b));
}
}
true
false
false
a.equals(b) は true なのに、HashSet の contains は false を返しました。HashSet の中では相手を Object として受け取って equals(Object) を呼ぶので、オーバーロードの規則どおり、自分で書いた equals(Point) は選ばれません。
この equals に @Override を付けていれば、tostring と同じエラーで書いた瞬間に止まっていました。引数を Object にして中で型を確かめる形に直すのが正解です。オーバーライドのつもりで書くメソッドには、毎回 @Override を付けておくのがいちばん安い保険です。
メモ
インターフェースのメソッドを実装するときにも @Override を付けられます。この記事の PaymentMethod や Notifier の実装クラスでも、すべての実装メソッドに付けています。
よくある質問
Javaのポリモーフィズムについて、つまずきやすい点を質問の形でまとめました。どれも本文のコードで確かめた内容です。細かい根拠は各見出しの本文もあわせて見てください。
Q1. Javaのポリモーフィズムとは何ですか?
A1. 同じメソッド呼び出しで、変数に入っているオブジェクトの実際の型ごとに違う処理が動く仕組みです。多態性とも呼びます。Javaでは継承とインターフェースを使い、子クラスや実装クラスがメソッドをオーバーライドすることで実現します。
Q2. オーバーライドとオーバーロードの違いは何ですか?
A2. オーバーライドは親と同じシグネチャのメソッドを子クラスで書き直すことで、実行時に実際の型を見て選ばれます。オーバーロードは同じ名前で引数の型や数が違うメソッドを並べることで、コンパイル時に引数の宣言された型を見て選ばれます。
Q3. staticメソッドはオーバーライドできますか?
A3. できません。子クラスで同じシグネチャの static メソッドを書くと隠蔽になり、どちらが呼ばれるかは変数の宣言された型で決まります。static メソッドは Parent.who() のように型名で呼ぶと誤解を防げます。
Q4. @Overrideは付けないとどうなりますか?
A4. オーバーライドが正しく書けていれば、付けなくても動きます。ただし綴りや引数の型を間違えると、エラーにならずに別のメソッドが増えるだけになります。付けておけば、オーバーライドになっていないときにコンパイルエラーで教えてくれます。
Q5. インターフェースと抽象クラスのどちらでポリモーフィズムを書けばいいですか?
A5. まずはインターフェースで書くのが無難です。1クラスで複数実装でき、無関係なクラスにも共通の型を与えられます。フィールドやコンストラクタを共有したい、手順の骨組みを親に持たせたい場合に抽象クラスを選びます。
Q6. instanceofで型を調べて分岐するのは悪い書き方ですか?
A6. 悪いとは限りません。型ごとの分岐が何か所にも散らばるなら、処理を各クラスに移すポリモーフィズムが向いています。型の種類が決まっていて処理のほうが増えるなら、Java 21 の sealed とパターンマッチの switch が合います。分岐の漏れをコンパイラが見つけてくれます。
Q7. ポリモーフィズムとアップキャストの関係は?
A7. Shape s = new Circle(1); のように子の型のオブジェクトを親の型の変数に入れることをアップキャストと呼びます。ポリモーフィズムはアップキャストした変数でメソッドを呼んだときに、実際の型の実装が動く性質です。アップキャストとダウンキャストの詳細はJavaのキャスト完全ガイドにまとめています。
Javaのポリモーフィズムを使いこなす3つの判断基準
冒頭の s.area() の1行に戻ります。あの1行で動く中身を決めているのは、実際の型でした。一方で、どのシグネチャを呼ぶか、static メソッドやフィールドがどれを指すかは、宣言された型が決めています。
この記事の判断基準
- 実際の型で選ばれるのは、オーバーライドされたインスタンスメソッドだけ。オーバーロード・static メソッド・フィールドは宣言された型で決まる
- 型が増えるならポリモーフィズム、処理が増えるなら sealed とパターンマッチの switch
- オーバーライドのつもりのメソッドには @Override を付け、コンストラクタからはオーバーライドできるメソッドを呼ばない
if と instanceof の分岐を見かけたら、「クラスに移すか、switch のまま閉じるか」を考える場面です。どちらが正しいかはコードによって変わります。決め手は毎回、手元のコードで「来月増えるもの」です。
1行目の出力が「Dog と Dog」に変わります。宣言の型を1か所変えただけで選ばれるメソッドが変わる理由を説明できれば、オーバーロードとオーバーライドの区別はもう大丈夫です。
続きを追う:X(@Tom_Java_Tech) / RSS
途中経過は、また書きます。

