この記事では、当社 の新人エンジニア研修の参考にJava8を解説します。
前回はインスタンスの活用について解説しました。
今回は継承（拡張）について解説します。
継承はとても巧妙な仕組みです。
ただし、少し直感的に分かりにくいところがあります。
手続き指向のプログラムではソースコードをざっと読めばどのような処理をしているかが一目瞭然なのですが、
オブジェクト指向では一見、自分のクラスが持っていないメソッドを使うことができたりするのです。
そのあたりのところ今回はお話ししたいと思います。
１．すべてのクラスのスーパークラスObject
今までにこの研修ではいくつかのクラスが出てきました。
などがありましたね。
いずれもAPIを参照すると上部に以下のように記述されています。
クラスSystem
- java.lang.Object
- java.lang.System
この記述が言わんとしているのはSystemクラスにはObjectクラスというスーパークラス（親クラス）がいますよ、ということです。
そして、親の持っているフィールドやメソッドはサブクラス（子クラス）が使うことができるのです。
しかし、その逆はありません。
これが継承です。
親の持っているものを子供は使える。
子供の持っているものを親は使えない。
なんだか身につまされませんか？
Objectクラスはその名の通り”モノ”を表すクラスです。
ObjectクラスはJavaのすべてのクラスのスーパークラスなのです。
Objectクラスには例えばequalsメソッドが定義されていますね。
したがってすべてのクラスでequalsメソッドが使えるのです。
※ただし、オーバーライドという仕組みによりスーパークラスの処理内容とサブクラスの処理の内容が違う場合がある。（後述）
２．継承（拡張）とは
このような、すでにあるクラスのフィールドやメソッドを新しいクラスが引き継ぐことを継承といいます。
英語ではinheritanceで継承や相続といった意味があります。
継承を使うことで機能の拡張ができることから拡張と呼ばれることもあります。
拡張は英語でextendです。
この継承の仕組みは皆さんも利用することが可能です。
ただし、何でもかんでもクラス間に継承関係をつくってフィールドやメソッドを取り込めばよいかというとそれは違います。
そこには論理的必然性が必要になります。
そうでないと体系がこんがらがってしまいます。
継承関係を作る際の基準としては、
サブクラスは一種のスーパークラスである
と言えるかどうかが重要です。
例えば、
車は一種の乗り物です。
飛行機は一種の乗り物です。
船は一種の乗り物です。
乗り物は車、飛行機、船のスーパークラスです。
サブクラスは一種のスーパークラスであるというのを簡潔に「is-a」関係といいますので覚えておいてください。
A car is a Vehicle.
An airplane is a Vehicle.
A ship is a Vehicle.
というわけですね。
スーパークラスには共通のメソッドを定義して、サブクラスにそれを拡張できるようにします。
共通のメソッドの例としては、例えば、
前に進む
止まる
人を乗せる
等が考えられるでしょう。
皆さんも身の回りで継承関係が作れそうなオブジェクトの例を考えてみてください。
親子関係を宣言するにはextendsというキーワードを使用します。
extendsという英語には拡張するという意味があります。
※なお、Objectクラスのみはextendsキーワードなしに継承されます。すべてのクラスが自動的にObjectクラスのサブクラスや孫クラスになることが保証されています。
以下のサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
package chap10; class Employee { int id; String name; } class Engineer extends Employee { String skill; } public class Example1 { public static void main(String[] args) { Engineer se = new Engineer(); se.id = 1; se.name = "imai"; se.skill = "Java"; System.out.println("I'm " + se.name + ". I'm a Java programmer."); } } |
＜結果＞
| I’m imai. I’m a Java programmer. |
Employeeクラスのフィールドはidとname。
Engineerクラスで宣言したフィールドはskill。
しかし、EngineerクラスはEmployeeクラスをextendsしているため３つのフィールドを持っているのです。
今回のように同一のファイルに親子両方のクラスが書かれていれば良いのですが、
そうでない場合は、ぱっと見はクラスの持っているフィールドやメソッドが分かりにくいですね。
そこで登場するのが以下のようなクラス図というものです。
クラス図ではクラスを四角形で表します。
四角形を３つに区切って、一番上がクラス名、真ん中がフィールド、一番下がメソッドです。
今回の２つのクラスではメソッドがありませんので空欄になっています。
そして、２つのクラスの関連である継承関係を白抜きの実線矢印で表現します。
このクラス図により、Engineerクラスには３つのフィールドがあることが明らかになります。
このあともいろいろなパターンが出てきますのでその都度ご紹介しますね。
継承のメリットは以下の２点です。
１．サブクラスをスーパークラスの変数で扱える
２．サブクラスはスーパークラスの差分だけをプログラミングすればよい。
※これを差分プログラミングといいます。
以下、順に説明します。
３．継承のメリット１ サブクラスをスーパークラスの変数で扱える
Javaでは、すべてのクラスのスーパークラスにはObjectクラスがあるのでした。
つまり、すべてのクラスにはObjectクラスのメソッドがあるということになります。
書いてないけれど使える。
それが継承（拡張）の仕組みでした。
では、Objectクラスを覗いてみることにしましょう。
例えば、IDEでObjectと記述してコントロールキーを押しながらその文字列をクリックしてみてください。
そして以下のようなequalsメソッドが定義されているところを探してください。
| public boolean equals(Object obj) { return (this == obj); } |
※私の環境下では、148行目でした。
これまでの知識でこのメソッドを読み解いてみましょう。
戻り値は true or false の boolean です。
仮引数は Object obj となっています。
これはつまり、Object なら何でもという意味です。
サブクラスをスーパークラスの変数で扱えるからできることですね。
そして、
this =＝ obj
thisというのはこのクラスがインスタンス化したときの自分自身を意味しています。
また、インスタンス化されていない状態でコードが書かれているため名前がなくthisと呼ばれるわけです。
これは参照が同一かどうかを見ているわけですね。
Objectの同一性は参照が同じであるということで判断しているということです。
さらに、Stringクラスでは独自のequalsを定義してそちらを優先させていたというのは７．文字と文字列の扱いでご紹介しました。
例えば以下のサンプルコードを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
class Vehicle { void run(){ System.out.println("I'm running."); } } class Car extends Vehicle{ } public class Example36_2 { public static void main(String[] args) { Vehicle v1 = new Car(); v1.run(); } } |
＜結果＞
| I’m running. |
vehicle(乗り物)クラスとCarクラスがあり、親子関係があります。
車は一種の乗り物と言えますか？
そうですね。
では、車に向かって「乗り物よ！動け！」ということはできるでしょうか？
論理的に間違っているところはありませんね。
そのようなことをしているのが上記のコードの１３，１４行目なのです。
つまり、
１．スーパークラスをスーパークラスの変数で扱える
ということになります。
念のためクラス図も書いておきます。
ただし、次のようなプログラムは実行できませんので注意しましょう。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package chap10; class Vehicle { } class Airplane extends Vehicle { void run() { System.out.println("I'm flying."); } } public class Example3 { public static void main(String[] args) { Vehicle v = new Airplane(); v.run(); } } |
今、乗り物クラスからrunメソッドを取り去りました。
このプログラムは、あたかも「乗り物よ飛べ！」といっているようなものです。
「おれ中身は飛行機だけれど、今は乗り物って呼ばれてるから飛べないんだよな」
という声が聞こえそうですね。
では、一度乗り物型の変数に紐づいた飛行機インスタンスを飛ばすにはどうしたらいいでしょうか？
そんな時は基本型でみたキャストを使います。
ただし、厳密にはインスタンスをキャストしてるのではなく、参照をキャストしてるのですが。
以下のプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 |
package chap10; public class Example4 { public static void main(String[] args) { Vehicle v = new Airplane(); Airplane a = (Airplane) v; a.run(); } } |
＜結果＞
| I’m flying. |
このような型変換ができるということは、この後のStringクラスのequalsメソッドを読み解く際にも必要になりますので、覚えておいてください。
４．継承のメリット２スーパークラスはスーパークラスの差分だけをプログラミングすればよい
このことをStringクラスのequalsメソッドを使って説明しましょう。
以下は、IDEを使って覗いたStringクラスのequalsメソッドです。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { //※1 String anotherString = (String)anObject; //※2 int n = value.length; //※3 if (n == anotherString.value.length) { char v1[] = value; char v2[] = anotherString.value; int i = 0; while (n-- != 0) { if (v1[i] != v2[i]) return false; i++; } return true; } } return false; } |
※私の環境では976行目でした。
※1 instanceofは、名前の通りanObjectがStringのインスタンスかどうかを判定する演算子です。
※2 キャストを使っています。
※3 valueは、インスタンスの文字列が格納されているcharの配列（の変数）です。
※余談ですが、APIのメソッドはいずれも短いですね、このequalsメソッドがかなり長く感じられるほどです。このように一つ一つのメソッドは適切な短さを保つようにしてください。適切なメソッド名が付けられなくなったら要注意です。
４行目までは Object クラスと同じ（趣旨）ですが、そこから下が違いますね。
まだ学んでいないことが使ってありますが、char型の配列で一文字ずつ比較して、同じ文字列かどうかを判定しているのがお分かりになりますか？
Stringクラスのところで同一性と同値性のお話をしました。
同一性は、複数の変数が同じインスタンスを参照していて同じ、という意味。
同値性は、複数の変数が同じインスタンスを参照していなくても、同じ値を持っていて同じ、という意味。
でした。
Stringのequalメソッドは同値性のチェックというのはこういうことだったのですね。
そもそも、何をもって同じとするかは非常に難しい問題です。
私とあなたは同じでしょうか？
もちろん人間という点では同じですが、年齢、性別、身長体重など違っていることは多いと思います。
したがってクラスごとにequalメソッドの内容は書き換えることができるのです。
equalメソッドの例で明らかなように、スーパークラスでスーパークラスのメソッドを変更することができます。
これをオーバーライドと言います。
英語ではover（上に）ride（載）せるということで優先させるという意味です。
スーパークラスのオーバーライドされたメソッドが上書き（overwrite）されてしまったわけではないので気をつけてください。
したがってスーパークラスのメソッドをサブクラスから呼び出すことも可能です。
また、オーバーロード（多重定義：引数の数や型が異なり名前が同じメソッドを宣言すること）と名前が似ているので注意してください。
５．メソッドのオーバーライド
先のコードを少し書き換えてみましょう。
runメソッドをオーバーライドしてみます。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
class Vehicle { void run(){ System.out.println("I'm running."); } } class Car extends Vehicle{ void run(){ System.out.println("I'm driving."); } } public class Example36_2 { public static void main(String[] args) { Vehicle v1 = new Car(); v1.run(); } } |
＜結果＞
| I’m driving. |
では、このことがどのように役立つのでしょうか？
それは、乗り物の変数ですべての種類の乗り物（車、飛行機、船）が扱えるということです。
次のようなプログラムが書けるということになります。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
class Vehicle { void run(){ System.out.println("I'm running."); } } class Car extends Vehicle{ void run(){ System.out.println("I'm driving."); } } class Airplane extends Vehicle{ void run(){ System.out.println("I'm flying."); } } class Ship extends Vehicle{ void run(){ System.out.println("I'm sailing."); } } public class Example36_2 { public static void main(String[] args) { Vehicle[] vs = {new Car(), new Airplane(), new Ship(), new Car(), new Airplane()}; for (Vehicle v : vs) { v.run(); } } } |
＜結果＞
|
1 2 3 4 5 |
I'm driving. I'm flying. I'm sailing. I'm driving. I'm flying. |
今回のように「v.run()」という同じ命令にもかかわらず、インスタンスごとに違った処理を実行しました。
このようなオブジェクト指向の仕組みをポリモーフィズム（多態性）といいます。
次に、オリジナルなequalsメソッドの実装を試してみましょう。
自転車クラスを考えます。
この自転車クラスは防犯登録番号（registryNumber）が同じなら、同一であると判断するとします。
先ほどのStringクラスのequalsメソッドを参考にしてみました。
他の乗り物クラスでもequalsメソッドを持つことを想定し、汎用性を考えて仮引数を(Vehicle aVehicle)としてみました。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
package chap10; class Bicycle extends Vehicle { int registryNumber; public Bicycle(int registryNumber) { this.registryNumber = registryNumber; } public boolean equals(Vehicle aVehicle) { if (this == aVehicle) { return true; } if (aVehicle instanceof Bicycle) { Bicycle anotherBicycle = (Bicycle) aVehicle; return this.registryNumber == anotherBicycle.registryNumber; } return false; } @Override public int hashCode() { //※ return this.registryNumber; } } public class Example7 { public static void main(String[] args) { Bicycle bi1 = new Bicycle(1234); Bicycle bi2 = new Bicycle(1235); Bicycle bi3 = new Bicycle(1234); System.out.println(bi1.equals(bi2)); System.out.println(bi1.equals(bi3)); bi2 = bi1; System.out.println(bi1.equals(bi2)); } } |
※ここで一見無関係に見えるhashCodeをオーバーライドしてることを不思議に思う人もいるかもしれません。実は、equalsメソッドをオーバーライドしたときにはhashCodeメソッドもオーバーライドしないと、後に学ぶHashMap、HashSetで使った際に深刻なバグを生む可能性があるのです。ちなみにこのハッシュ値はいわゆる情報セキュリティなどで出てくるハッシュ値のような一方向性や不可逆性といったことまでは要求されませんから単純に防犯登録番号を返す仕様としています。
＜結果＞
| false true true |
この例のようにメソッドの仮引数をスーパークラスにすることで、サブクラスの実引数を受け取れるようにしておくことをポリモーフィズムを使ったメソッドの引数設計と呼ぶことがあります。
６．ポリモーフィズムのメリット
ここで、ポリモーフィズムを使わずにコーディングしたとします。
何が不都合なのでしょうか？
ポリモーフィズムを使わない場合は、クラスの種類に応じて呼び出すインスタンスメソッドが変わります。
そのためif文などで処理を分岐させる必要があります。
クラスの種類に応じてというところは、instanceof演算子を使えばいいです。
こんな風になりますね。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
class RacingCar { void run() { System.out.println("I'm driving."); } } class Paraglider { void run() { System.out.println("I'm flying."); } } class Yacht { void run() { System.out.println("I'm sailing."); } } public class Example36_2 { public static void main(String[] args) { Object[] vs = {new RacingCar(), new Paraglider(), new RacingCar(), new RacingCar(), new Paraglider(), new Object()}; for (Object v : vs) { if (v instanceof RacingCar) { RacingCar c = (RacingCar) v; c.run(); } else if (v instanceof Paraglider) { Paraglider p = (Paraglider) v; p.run(); } else if (v instanceof Yacht) { Yacht y = (Yacht) v; y.run(); } else { System.out.println("想定していないクラスです"); } } } } |
＜結果＞
|
I’m driving. |
コード量は増えるものの何とかできました。
しかし、ここで新たにYachtクラスを作るとします。
|
1 2 3 4 5 6 |
class Yacht { void run() { System.out.println("I'm sailing."); } } |
すると、mainメソッドの中まで書き換える必要が出てきてしまうのです。
ポリモーフィズムを使った場合は乗り物の種類が増えてもmainメソッドの中身を書き換えなくて済みました。
今回は簡単なコードなので良いのですが、もっと複雑なコードで、しかも、mainメソッドの処理が現在現役で使われているクラスだったとします。
今動いているプログラムをいじるというのはとても勇気のいることです。
というわけで、ポリモーフィズムを利用するのです。
Javaのプログラムを書いていてif文やswitch文を多用していたら、そこに不吉なにおいを嗅ぎ取ってくださいね。
７．toStringメソッド
では、ここで初心に戻って以下のプログラムを実行してみてください。
|
1 2 3 4 5 6 |
public class Example36_5 { public static void main(String[] args) { Bicycle bi = new Bicycle(1234); System.out.println(bi); } } |
＜結果＞
| Bicycle@15db9742 |
＠の前がクラス名、後ろがハッシュコードと呼ばれる１６進数です。
このとき、例えば、printlnメソッドを使い防犯登録番号を表示させることはできるのでしょうか？
上記の表示を以下のように変えたいとします。
| 私の防犯登録番号は、1234 |
では、IDEでprintlnメソッドの定義をさかのぼりましょう。
|
1 2 3 4 5 6 7 |
public void println(Object x) { String s = String.valueOf(x); synchronized (this) { print(s); newLine(); } } |
クラスは、PrintStreamクラスです。
２行目でStringクラスのvalueOfというクラスメソッドを使っています。これは、xが参照する様々なオブジェクトを、String型に変換するメソッドです。
※ちなみに、printメソッドとnewLineメソッドも見えていますね。
※synchronized (this) という記述は排他制御のためです。このsynchronizedブロックで囲まれた２行は、1インスタンスごとに必ず1つのスレッドからしか実行されないため、同時アクセスによって矛盾した表示がされないことが保証されています。
では、IDEでvalueOfメソッドの定義をさかのぼりましょう。飛び先のクラスはStringです。
|
1 2 3 |
public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); } |
obj == nullでnull判定をして、nullであれば文字列”null”を、そうでなければ、toStringメソッドを呼んでいます。
では、IDEでtoStringメソッドの定義をさかのぼりましょう。
|
1 2 3 |
public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); } |
クラスはObjectクラスです。
ここでやっとご本尊（？）らしき記述と対面することができました。
では、このtoStringメソッドをオーバーライドしたらどうなるでしょうか？
オリジナルも文字表現で標準出力できそうですね。
やってみましょう！
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
class Bicycle2 extends Vehicle { int registryNumber; public Bicycle2(int registryNumber) { this.registryNumber = registryNumber; } public String toString() { return "私の防犯登録番号は、" + this.registryNumber; } } public class Example36_6 { public static void main(String[] args) { Bicycle2 bi = new Bicycle2(1234); System.out.println(bi); } } |
＜結果＞
| 私の防犯登録番号は、1234 |
なお、オリジナルなクラスを作成したらtoStringメソッドをオーバーライドするというのは半ば常識となっています。
そうすることでデバッグ時に表示が分かりやすくなるからです。
ただし、toStringメソッドで取得したデータを使いまわすようなプログラムは慎むべきです。
フィールドの値を取得する用途には、後でお話しするアクセサメソッドを使いましょう。
ちなみに、ここまで来たらhashCodeメソッドの中身も気になっている人もいることでしょう。
試しに定義を確認すると、
| public native int hashCode(); |
となっています。
中身のないメソッドです。
そしてnative修飾子がついています。
英語でも母国語を話せる人をnativeといいますね。
コンピュータの母国語はマシン語です。
マシン語（おそらくはC言語）などで書かれているのでここまでしかJavaでは遡ることはできません。
ちなみに、このハッシュコードは暗号化で出てくるハッシュ関数とは直接の関りはありません。
あのハッシュ関数は元に戻せない一方向性などが求められましたが、Javaのハッシュコードにはそこまで求められていません。
ただ、インスタンスをメモリの中から素早く検索する際などに使われる数値です。
８．継承よりも委譲を選ぶ
先にも述べたとおり、あるクラスのある機能を取り込みたいばかりに、継承を使うというのは悪い設計です。
継承を使うとスーパークラスの変更がサブクラスに及ぶため、クラス間に依存関係が生じてしまうのです。
そんなことをしなくても、他のクラスの機能を取り込むことができます。
その方法を委譲といいます。
次のサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
import java.util.Scanner; public class Example36_8 { public static void main(String[] args) { Pc pc1 = new Pc(); pc1.input(); } } class Pc { Scanner scanner = new Scanner(System.in); void input() { System.out.print("入力してください > "); String input_text = scanner.nextLine(); System.out.println(input_text + "が入力されました"); } } |
<結果>※キーボードからHelloと入力した場合
| 入力してください > Hello Helloが入力されました |
ご覧いただきたいのは13行目です。
Scannerクラスのインスタンスをフィールドにしています。
そうしておいて、このクラスの中のメソッドでScannerクラスのnextLineメソッドを呼び出しています。
このようなクラスの関係を”has-a”の関係といいます。
PcクラスはScannerクラスを持っているという訳ですね。
このときnextLineメソッドを使いたいがためだけにPcクラスがScannerクラスを継承するのは間違いです。（そもそもScannerクラスはfinalで宣言されているため継承できませんが）
樹形図になっているクラスの体系をぐちゃぐちゃにしてしまいます。
”has-a”関係は”is-a”関係のように多重継承の問題や、サブクラスにスーパークラスの不要なフィールドやメソッドまでをも組み込んでしまうという問題を解消することになります。
継承か委譲か迷ったら委譲を使う方が良いということは頭の片隅に置いておいてください。
９．ClassCastException
ここでは、クラスのキャストについて見ていきます。
サブクラスは一種のスーパークラスでした。
しかし、スーパークラスは一種のサブクラスであるとは言えません。
ですからスーパークラスのインスタンスをサブクラスのインスタンス変数（参照）に代入することはできません。
以下のサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 |
public class Example36_7 { public static void main(String[] args) { Object o = new Object(); String s = new String(); s =(String)o; } } |
＜結果＞
| Exception in thread “main” java.lang.ClassCastException: java.lang.Object cannot be cast to java.lang.String |
この時送出されるのがClassCastExceptionという例外です。
オブジェクトは一種の文字列である、とは言えません。
そのためこのようなキャストができないという例外が発生したのでした。
１０．多重継承の禁止
なお、Javaでは、あるクラスが持てるスーパークラスは１つのみです。
これを単一継承といいます。
単一継承であるということは、どのクラスにもスーパークラスは１つだけだということです。
しかし、スーパークラスにはサブクラスが複数いても良いことになります。
それを敷衍すると、クラスの体系は樹形図になります。
例えば、Java８のAPIで確認するとこんな感じです。
一方、複数のスーパークラスを持てる仕組みを多重継承といいます。
例えば、C++言語では多重継承を採用しています。
Javaではなぜ、多重継承を禁止したのでしょうか？
それはこういう訳です。
|
class A{ show(); } class B{ show(); } class C extends A,B{ } |
このようなコードがあった場合に、メインメソッドの中で、
|
C obj1 = new C(); obj1.show(); |
としたらどうなるでしょうか？
このshowメソッドがクラスA由来のものかクラスB由来のものか判断がつきませんね。
そういう訳で、Javaでは多重継承が禁じられているのです。
ただし、後で学ぶインターフェースというものを使うと多重継承的な処理が可能になりますのでお楽しみに。
ここまで理解できたら以下の練習問題を解いてみましょう。
今回は継承（拡張）について見てきました。
スーパークラスの変数で扱えることやポリモーフィズムなど便利そうな仕組みがありましたね。
ただし、「継承は最後の手段」という言葉があります。
Javaは単一継承のため、継承を使ったクラス設計はめったに採用されないと思ってください。
特に新入社員の皆さんはなおさらです。
ただし、継承関係にあるクラスを利用することは多くありますからその仕組みを理解しておくことはとても重要です。
なお、継承されないものとして以下の３つがあることは知っておくとなおよいでしょう。
|
①プライベート宣言されたメンバー ②コンストラクタ（メンバーでないので） ③スタティックメンバー（インスタンスの中に含まれないので） |
次回のテーマはカプセル化です。
これも、オブジェクト指向特有のテーマです。
さらに、継承よりも身近に使われるテクニックです。
カプセル化を使ってより頑強なクラスを作っていきましょう。
JavaSE8の解説に戻る
