この記事では、弊社の新人エンジニア研修の参考にJava8を解説します。
前回はクラスメソッドについて解説しました。
今回はインスタンスの活用について解説します。
いままでは、話をできるだけ単純にするためにインスタンスの話題はできるだけ避けてきました。
しかし、ここからはいよいよオブジェクト指向の本丸、クラスからインスタンスを作成するということについて学んでいきます。
クラスは設計図、インスタンスは設計図から作られた実物のイメージでしたね。
目次
1.オブジェクト指向とは何だったか？
Objectとは、モノのことです。
この記事の１回目でお話ししたように、オブジェクト指向とは他の工業製品と同じように部品を組み合わせることでプログラム全体を作り上げるという考え方でした。
例えば、皆さんがお使いのパソコンも多くの部品から構成されています。
私たちは、それぞれの部品の内部構造を知らなくても、それらを組み合わせて使うことができます。
大多数の人はCPUとメモリの区別も曖昧なままスマホやパソコンを使っています。
それでもパソコンとプリンタをつないで印刷することはできます。
また、それぞれの部品単位でアップデートすることもできます。
例えば、古くなったハードディスクを新しいものに交換する、などといったことができます。
この考え方をプログラムに応用したのがオブジェクト指向です。
つまり、オブジェクトはプログラムの部品です。
そして、オブジェクトの設計図がクラスです。
クラスには、オブジェクトに共通する属性（情報や機能）を定義します。
この設計図をもとに作成した実際の部品がインスタンスです。
人によって言葉の使い方に多少のずれがありますが、この研修では、
| オブジェクト（抽象概念） ＝ クラス（設計図） ＋ インスタンス（具体的なもの） |
という言葉で使い分けています。
単にオブジェクトといった場合には、それがクラスのことを指すこともあれば、インスタンスのことを指すこともあります。
ですからこの原稿ではオブジェクトという言葉の使用は極力避けて、クラスとインスタンスという言葉を使うようにしています。
例えば、今現在あなたが見ているこの画面も、ウインドウというインスタンスの上にメニューというインスタンスが乗っていて、クリックの情報を受け取るインスタンスがある、という風になっているというと少しはイメージの助けになりますでしょうか？
論より証拠、以下のプログラムを実行していただくとお分かりただけると思います。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package chap09; import javax.swing.JFrame; public class Example00 { public static void main(String[] args) { JFrame frame = new JFrame(); frame.setSize(1000, 500); frame.setVisible(true); } } |
例えばウインドウサイズを変更したいときどこをいじれば良いか分かりますか？
これは比喩的な表現ですが、パソコンクラスというものを作ったとして、あなたや隣の人の机に乗っている具体的なパソコンがインスタンスです。
新入社員クラスがあったとして、あなたやあなたの隣の人がそのインスタンスです。
例えば新入社員の皆さんで名簿を作ったとします。
名簿の項目はクラスに当たります。
そして一人一人の行はインスタンスです。
クラスとインスタンスを名簿に例えると
2.フィールドを持ったクラスの宣言
例えば、新人エンジニアのクラスを作成してみましょう。
話を単純化するために社員番号と名前だけを持っているとします。
|
1 2 3 4 5 6 7 |
package chap09; class NewEngineer1 { int id; String name; } |
このクラスを実行しようとすると、「mainメソッドがありません」といったメッセージが表示され実行できません。
それでもこれで立派にクラスを宣言できました。
NewEngineer1クラスは二つの情報idとnameを持っています。
これらの情報を総称してフィールド（field）と呼ぶのでした。
では、さっそく一人のエンジニアを誕生させてみましょう。
NewEngineer1クラスを使うExample01というクラスを作成します。
以下のサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 |
package chap09; public class Example01 { public static void main(String[] args) { NewEngineer se1; se1 = new NewEngineer(); System.out.println(se1.id); System.out.println(se1.name); } } |
実行する前に上から順番に解説していきます。
NewEngineer se1;
ここでは、NewEngineer型のローカル変数se1を宣言しています。
いままでも「String str」といった宣言を目にしてきましたが「型 変数名」という同じ形ですね。
se1 = new NewEngineer();
ここで、変数se1に代入して初期化しています。
何を代入したのかというとNewEngineerクラスのインスタンスです。
イメージとしては一人のエンジニアを作り出したわけです。
この時、newという演算子を使っています。
new演算子は配列のところでも出てきましたね。
実は、new演算子はクラスの全てのインスタンスメンバをメモリーにコピーするための演算子です。
また、NewEngineer()というのはコンストラクタというものです。
コンストラクタは文字列のところでも出てきました。
コンストラクタはクラス名と同じ名前のメソッドのようなものです。
コンストラクタ自体の作り方は後で学びます。
ここでは、コンストラクタを利用するには
| new クラス名（実引数）; |
と書くのだということをおさえましょう。
なお、宣言と初期化を１行で書くこともできます。
NewEngineer se1= new NewEngineer();
実行してみます。
＜結果＞
| 0 null |
実は、フィールドは初期値が以下のように決まっているのです。
それに対して、ローカル変数は初期化してから使う必要があったことをここで思い出してください。
| 真偽値 | false |
| 整数型 | 0 |
| 浮動小数点型 | 0.0 |
| 文字型 | \u0000 ※ |
| 参照型 | null |
※ユニコードのNUL（空文字）、nullではない。
では、あたらめてフィールドに値を代入してみます。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package chap09; public class Example02 { public static void main(String[] args) { NewEngineer1 se1; se1 = new NewEngineer1(); se1.id = 1; se1.name = "yamada"; System.out.println(se1.id); System.out.println(se1.name); } } |
＜結果＞
| 1 yamada |
ここで使用したidやnameといったフィールドを個々のインスタンス固有の変数という意味でインスタンス変数（またはインスタンスフィールド）と呼びます。
このあとクラス共通の変数であるクラス変数というのが出てきますのでそれと区別できるようにしましょう。
ここからはローカル変数やクラス変数と区別してインスタンス変数という表現を積極的に使っていきます。
3.メソッドを持ったクラスの宣言
先の新人エンジニアクラスにメソッドを加えたNewEngineer2クラスを作ってみましょう。
NewEngineer1では2つのprintlnメソッドを使ってIDと名前をそれぞれ表示させていましたが、今度は一度にIDと名前を表示するshowメソッドを加えることにします。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package chap09; class NewEngineer2 { int id; String name; void show() { System.out.println("私のIDは" + id + "、名前は" + name + "です。"); } public static void main(String[] args) { NewEngineer2 se2 = new NewEngineer2(); se2.id = 2; se2.name = "tabuchi"; se2.show(); } } |
＜結果＞
| 私のIDは2、名前はtabuchiです。 |
インスタンスメソッドを呼び出すときは、
| 変数名.メソッド名（実引数） |
でしたね。
ちなみに、このように自分で作成したクラスにメインメソッドを書き足して簡易的に実行するとコードを確認しながら実行できて試行錯誤の多い初学者には便利です。
ただし、1つのプロジェクトにエントリーポイントが複数になってしまいます。
納品するプログラムからは削除して下さい。
自クラスの中で自分自身のインスタンスを生成している部分が腑に落ちない方もいらっしゃるかもしれません。
その点に関しては、以下の3つのメモリ領域の図を思い出してください。
メインメソッドは､インスタンスが生成される前にスタティック領域にロードされるのでしたね。
メモリの3つの領域のイメージ
※常にクラスの中にメインメソッドを書くJavaの書き方には多くの人が違和感を持つのか､Javaの後継言語とも目されているKotlinでは､mainメソッドはクラスの外に書きます．
4.インスタンスの生成
上記サンプルプログラムに以下のように書き足して、登場人物を２人にしてみましょう。
※ここには記述されていない先のNewEngineer2クラスを再度利用してインスタンス生成しています。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package chap09; public class Example03 { public static void main(String[] args) { NewEngineer2 yamazaki = new NewEngineer2(); yamazaki.id = 1; yamazaki.name = "yamazaki"; yamazaki.show(); NewEngineer2 imai = new NewEngineer2(); imai.id = 2; imai.name = "imai"; imai.show(); } } |
＜結果＞
| 私のIDは1、名前はyamazakiです。 私のIDは2、名前はimaiです。 |
では、以下のプログラムを実行したら何が表示されるでしょうか？
|
1 2 3 4 5 6 7 8 9 10 11 |
package chap09; public class Example04 { public static void main(String[] args) { NewEngineer2 yamazaki = new NewEngineer2(); yamazaki.id = 1; yamazaki.name = "yamazaki"; System.out.println(yamazaki); } } |
＜結果＞
| chap09.NewEngineer2@7852e922 |
上記のように表示されました。
これは、配列のところで見た参照（クラスの型＠ハッシュ値）ですね。
5.参照型とプリミティブ型
実は、Javaで使用できる変数の型にはプリミティブ型（基本型）と参照型があります。
プリミティブ型の変数には、boolean、int、 doubleなど値そのものが入っています。
一方、参照型の変数には、その名の通りインスタンスへの参照が入っています。
決してインスタンスそのものが入っているわけではありませんので注意しましょう。
| NewEngineer2 yamazaki = new NewEngineer2(); |
と書いたときに、変数yamazakiにはNewEngineerクラスのインスタンスへの参照が代入されているのです。
したがって、一つのインスタンスを２つの参照が指している状態を作ることも可能です。
以下のサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package chap09; public class Example05 { public static void main(String[] args) { NewEngineer2 se1 = new NewEngineer2(); se1.id = 1; se1.name = "yamazaki"; NewEngineer2 se2 = se1; se1.show(); se2.show(); } } |
＜結果＞
| 私のIDは1、名前はyamazakiです。 私のIDは1、名前はyamazakiです。 |
一つのインスタンスを２つの参照が指している状態
6.参照型の配列
参照型の配列を作成することもできます。
以下のサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
package chap09; public class Example06 { public static void main(String[] args) { NewEngineer2[] se = new NewEngineer2[3]; se[0] = new NewEngineer2(); se[1] = new NewEngineer2(); se[2] = new NewEngineer2(); se[0].id = 1; se[0].name = "tabuchi"; se[1].id = 2; se[1].name = "shinohara"; se[2].id = 3; se[2].name = "kokubun"; for (int i = 0; i < se.length; i++) { se[i].show(); } } } |
＜結果＞
| 私のIDは1、名前はtabuchiです。 私のIDは2、名前はshinoharaです。 私のIDは3、名前はkokubunです。 |
ただし、その作られ方には違いがあります。
以下の図のようにプリミティブ型は配列に直接値が格納されるのに対して、オブジェクト型の場合には配列からまた参照をたどった先にインスタンスがあります。
プリミティブ型の配列とオブジェクト型の配列の違い
7.NullPointerException
このとき、起こしがちなミスとして、配列は作ったものの、インスタンスを作り忘れるというものがあります。
例えば、以下のサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
package chap09; public class Example07 { public static void main(String[] args) { NewEngineer2[] se = new NewEngineer2[3]; se[0].id = 1; se[0].name = "tabuchi"; se[1].id = 2; se[1].name = "shinohara"; se[2].id = 3; se[2].name = "kokubun"; for (int i = 0; i < se.length; i++) { se[i].show(); } } } |
＜結果＞
| Exception in thread “main” java.lang.NullPointerException at chap09.Example07.main(Example07.java:7) |
７行目で「NullPointerException」が発生しました。
Pointer（参照）がNull（空）であるというException（例外）です。
※ポインタとはC言語等で使われる参照（のようなもの）です。用語が先祖返りしているのが興味深いですね。
se[0]には何も入っていないのに、その参照を使おうとしたことが原因です。
プリミティブ型では起こりえませんが、参照型の場合は、参照に何も入っていないnullという状態があるのです。
おそらく、これから皆さんが学習を進めていくうえで、一番多く遭遇するのがこのNullPointerExceptionです。
しかも、このNullPointerExceptionは非検査例外といってプログラマの責任で必ず対処しておかなければならない例外なのです。
※例外のところで詳述します。
よって、IDEもチェックしてくれません。
nullは、特別な値で参照型の変数に代入することができます。
|
1 2 3 4 5 6 7 8 9 |
package chap09; public class Example08 { public static void main(String[] args) { NewEngineer2 se = null; System.out.println(se); } } |
＜結果＞
| null |
なお､参照そのものはnullですが、参照先のインスタンスを使って何かをしようとするとNullPointerExceptionの例外が発生します。
以下のサンプルコードを見て下さい。
|
1 2 3 4 5 6 7 8 9 |
package chap09; public class Example09 { public static void main(String[] args) { String str1 = null; System.out.println(str1.length()); } } |
＜結果＞
| Exception in thread “main” java.lang.NullPointerException at chap09.Example09.main(Example09.java:7) |
nullは文字列の”null”とは別物ですし、””（空文字）とも数値の0とも違うものです。
以下のサンプルプログラムを見て下さい。
|
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 |
package chap09; public class Example10 { public static void main(String[] args) { String str1 = null; String str2 = "null"; String str3 = ""; if (str1 == null) { System.out.println("str1はnullです"); } else { System.out.println("str1はnullではありません"); } if (str1 == str2) { System.out.println("str2はnullです"); } else { System.out.println("str2はnullではありません"); } if (str1 == str3) { System.out.println("str3はnullです"); } else { System.out.println("str3はnullではありません"); } } } |
＜結果＞
| str1はnullです str2はnullではありません str3はnullではありません |
ちなみに、Javaにはガーベージコレクション（Garbage collection：ゴミ集め）という機構があり、どこからも参照されなくなったインスタンスはメモリから消去されます。
このガーベージコレクションによりメモリの開放という作業からプログラマは開放さるのです。
この仕組みがない言語では、プログラマが意図的にガーベージコレクションをしてやらないといけません。
そうしないとメモリリーク (memory leak：メモリ漏れ) というエラーが起こり得ます。
今では当たり前の機能ですが、Javaが登場した際にはガーベージコレクションの仕組みを備えていたことも画期的なことでした。
8.参照渡しと値渡し
インスタンスの参照をメソッドの引数として渡すことができます。
引数にインスタンスを渡すことでたくさんのデータを一つの引数で渡すことができるようになります。
例えば、以下のサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package chap09; public class Example11 { static void show(NewEngineer1 se) { System.out.println(se.id + " : " + se.name); } public static void main(String[] args) { NewEngineer1 yamazaki = new NewEngineer1(); yamazaki.id = 1; yamazaki.name = "yamazaki"; NewEngineer1 imai = new NewEngineer1(); imai.id = 2; imai.name = "imai"; show(yamazaki); show(imai); } } |
＜結果＞
| 1 : yamazaki 2 : imai |
この引数の渡し方を参照渡しといいます。
図解すればこんな感じです。
参照渡しの場合のインスタンスは同一のものを指していますから、呼び出し元のインスタンスと呼び出し先のメソッドのインスタンスは同じです。
つまり、メソッド側でインスタンスに変更を加えた場合は、元のインスタンスにも変更が及びます。
その説明をしているのが以下のサンプルプログラムです。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
package chap09; public class Example12 { static void show(NewEngineer1 se) { se.name += "_san"; System.out.println(se.id + " : " + se.name); } public static void main(String[] args) { NewEngineer1 yamazaki = new NewEngineer1(); yamazaki.id = 1; yamazaki.name = "yamazaki"; show(yamazaki); System.out.println(yamazaki.name); } } |
＜結果＞
| 1 : yamazaki_san yamazaki_san |
これは、プリミティブ型を引数に渡した時とは違う結果です。
プリミティブ型を引数に渡した場合は、値はコピーされて呼び出し元の値と呼び出し先のメソッドの値は別物（コピー）になります。
念のため以下のサンプルプログラムで確認してください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package chap09; public class Example13 { static void inc(int i) { i++; System.out.println("呼び出し先のi:" + i); } public static void main(String[] args) { int i = 10; System.out.println("呼び出し元のi:" + i); inc(i); System.out.println("呼び出し元のi:" + i); } } |
＜結果＞
| 呼び出し元のi:10 呼び出し先のi:11 呼び出し元のi:10 |
この引数の渡し方を値渡しといいます。
Javaだけではなく、多くのプログラミング言語で共通の概念です。
たとえ話をしますと、参照は貸し金庫の鍵のようなものです。
つまり、私があなたに１トンの金塊を渡すとして、金塊そのものを渡すのではなく、鍵を渡しているのです。
ですから、もしも、私も鍵を持っているとしたら、ふたりともその金塊にアクセスできるというわけです。
どちらか一方が金塊を削れば、金塊は小さくなります。
一方､値渡しは契約書のコピーを渡したようなものです｡
どちらか一方が契約書を破っても、もう一枚は手つかずのままなのです。
9.メソッドの戻り値に参照を使う
参照をメソッドの戻り値にすると複数のデータを一度に戻すことができます。
メソッドの戻り値は一つのみでしたが、この方法を使うことで実質は複数の値を同時に返すことが可能になります。
以下のサンプルプログラムでは、idとnameという２つの値を返しています。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
package chap09; public class Example14 { static NewEngineer2 compare(NewEngineer2 se1, NewEngineer2 se2) { if (se1.id > se2.id) { return se1; } else { return se2; } } public static void main(String[] args) { NewEngineer2 se1 = new NewEngineer2(); NewEngineer2 se2 = new NewEngineer2(); se1.id = 1; se1.name = "shinohara"; se2.id = 2; se2.name = "imai"; System.out.println("idの大きい方のSEを表示します。"); NewEngineer2 se3 = compare(se1, se2); se3.show(); } } |
＜結果＞
| idの大きい方のSEを表示します。 私のIDは2、名前はimaiです。 |
上記の例ではフィールドがidとnameの2つだけなので、メソッドで参照を返せることのメリットはあまり感じられなかったかもしれません。
しかし、インスタンスにいろいろなフィールドを付与していけば、その恩恵を感じられることでしょう。
10.コンストラクタでインスタンスの初期化
クラスにはフィールドとメソッドがありました。
実はもう一つ、クラスにはコンストラクタというものがあります。
英語で”constructor”には「建設者」という意味があります。
つまり、コンストラクタとはインスタンスを作り出す処理のことです。
インスタンスが生成されるときに自動的に実行される特別なメソッドのようなものだと思ってください。
※正確には、コンストラクタがヒープメモリーの必要容量を用意する機能を持つものです。
コンストラクタを定義する基本構文は以下の通りです。
|
クラス名（引数列） { 命令文; } |
つまり、コンストラクタはクラスと同じ名前になります。
コンストラクタには戻り値はありません。（あえて言えばインスタンスが戻り値です）
もしも､コンストラクタに戻り値の型を書いてしまうとそういう名前のメソッドだとコンパイラには解釈されてしまいますので気をつけてください｡
コンストラクタには引数を渡せますので、インスタンスを初期化するのに使うことができます。
以下の2つのサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package chap09; public class NewEngineer3 { int id; String name; public NewEngineer3(int id, String name) { this.id = id; this.name = name; } } |
※なお、IDEを使えばコンストラクタの挿入も1クリックでできます。
|
1 2 3 4 5 6 7 8 9 |
package chap09; public class Example15 { public static void main(String[] args) { NewEngineer3 se = new NewEngineer3(3, "tabuchi"); System.out.println(se.id + " : " + se.name); } } |
<結果>
| 3 : tabuchi |
このとき、
| this.id = id; |
のようにthis参照を使っていることに注目してください。
“this”=「この」ということで記述されている自分自身のインスタンスを指してます。
this.を省略すると、ローカル変数や仮引数にも同じ名前の変数があった場合、そちらが優先されてしまうという問題があります。
フィールドとローカル変数の名前が同じ場合はローカル変数が優先されるというルールがあります。
このthisは、以下のように仮引数の名前を変えることで付けずに済ますことも可能です。
|
NewEngineer2(int a, String b) { id = a; name = b; } |
しかし、先のthisを付ける方が分かりやすいことはご理解いただけると思います。
なお、今までコンストラクタを作成することなくインスタンスを作成してきました。
それは、Javaによってデフォルト・コンストラクタ（default constructor）というものが補われていたからなのです。
デフォルト・コンストラクタは、以下のような形をしています。
| NewEngineer1() { } |
つまり、引数も命令文もない形です。
インスタンスをヒープ領域に作成するだけのコンストラクタです。
デフォルトコンストラクタは明示的なコンストラクタがない場合のJavaの親切機能です。
11.コンストラクタのオーバーロード
this(引数)と記述すると自分自身のコンストラクタを呼び出すことができます。
コンストラクタでも、this(引数)を使ってメソッドのときに学んだオーバーロードを実現できます。
ただし、この記述ができるのはコンストラクタの最初の１行目でなくてはいけないというルールがあります。
以下の2つのサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package chap09; class NewEngineer4 { int id; String name; NewEngineer4(int id, String name) { this.id = id; this.name = name; } NewEngineer4() { this(0, "undefined"); } } |
※undefinedは定義されていないという意味です。
|
1 2 3 4 5 6 7 8 9 |
package chap09; public class Example16 { public static void main(String[] args) { NewEngineer4 se = new NewEngineer4(); System.out.println(se.id + " : " + se.name); } } |
＜結果＞
| 0 : undefined |
引数２つのコンストラクタと引数のないコンストラクタを用意して、後者の中で前者を呼び出しています。
オーバーロードとは、同じクラスの中でメソッド名と戻り値の型が同じで、引数の型や数、並び順が違うメソッドを複数定義することをいいました。
コンストラクタもメソッド同様、呼び出し時に指定される引数によって実行されるコンストラクタが区別されるのです。
また、コンストラクタから自分のメソッドを呼び出すこともできます。
showメソッドの使われ方に着目して、以下のサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
package chap09; class NewEngineer5 { int id; String name; NewEngineer5(int id, String name) { this.id = id; this.name = name; this.show(); } void show() { System.out.println("My id is " + id + ".\nMy name is " + name + "."); } } |
＜メインメソッドを持つクラス＞
|
1 2 3 4 5 6 7 8 |
package chap09; public class Example17 { public static void main(String[] args) { NewEngineer5 se = new NewEngineer5(4, "imai"); } } |
＜結果＞
| My id is 4. My name is imai. |
これまで見てきたとおり、Javaにはshowメソッドのようにインスタンスごとに存在するメンバと、mainメソッドのようにクラスで唯一のメンバがありました。
では、これらはどのように使い分けるのが良いのでしょうか？
いまからその点について学んでいきましょう。
12.インスタンス変数とクラス変数の使い分け
インスタンス変数は、個々の実体ごとに固有の情報を保持する目的で使用します。
今までの例ではidやnameです。
クラス変数は、クラス全体で共通の１つの情報を保持する目的で使用します。
クラス変数の代表例を探せば、クラスMathのフィールドPI（標準API）があります。
|
123 |
public static final double PI = 3.14159265358979323846; |
その名の通り、円周率を表すフィールドです。
円周率はいつ、誰が、どこで使っても同じでないと困りますね。
それゆえ、クラス変数なのです。
詳しくPIの宣言を見ます。
publicはこのフィールドがクラス外に公開されていて他のどのクラスからも利用できることを示していました。
staticというキーワードがクラス変数であることの宣言になります。
staticというのは英語で「静的な」という意味があります。
動的にヒープメモリにインスタンスを作らなくても良いということを表しています。
また、finalというのは定数ということでした。
finalというのは英語で「最後」という意味ですから、これ以上変化しない、最後の値であるということを表現しているわけです。
値を表示させてみましょう。
|
1 2 3 4 5 6 7 8 |
package chap09; public class Example18 { public static void main(String[] args) { System.out.println(Math.PI); } } |
※なお、定数によってプログラムが読み解きやすくなっている点にも注目ください。「3.141592653589793」というリテラルをプログラマが円周率のつもりで使っても、プログラムを読む人には伝わりません。“PI”と書かれているからこそ「円周率なのだ」というメッセージを発信することができるのです。
＜結果＞
| 3.141592653589793 |
なお、定数は大文字を使うという命名規則がありましたね。
命名規則は強制ではありませんが、Javaプログラマーが守っているルールですから皆さんも従うようにしてください。
皆さんが作成するクラスでも、クラス共通の情報としたいもの、インスタンスごとの個別情報としたいものがあると思います。
例えば、車を例にとって考えてみましょう。
車といっても抽象的な車ではなく、みなさんの家にあるような具体的な車です。
例えば、ここではプリウスとしましょう。
クラス変数はすべてのプリウスで共通にしたいデータです。
クラス変数の例：ドアの数、ターボの有無、ガソリンタンクの大きさ、などでしょうか。
対して、インスタンス変数は個々のプリウスで違うデータです。
インスタンス変数の例：ナンバープレートの情報、現在のドライバー名、現在のガソリンの残量、など
このような例が思い浮かぶと思います。
以下にクラス変数を使ったサンプルプログラムを見てみましょう。
例えば、今まで作成してきたNewEngineerクラスにおいてクラス変数にすべきものを考えてみましょう。
例として、新人エンジニアの総人数はどのインスタンスが保持すべきでしょうか？
人数の情報は個々のインスタンスが持つべき情報ではありませんね。
クラス変数にした方がしっくりきます。
以下のサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package chap09; class NewEngineer6 { int id; String name; static int count; NewEngineer6(int id, String name) { this.id = id; this.name = name; count++; this.show(); } void show() { System.out.println(id + ":" + name + ":" + count + "人目です｡"); } } |
＜メインメソッドを持つクラス＞
|
1 2 3 4 5 6 7 8 9 10 11 |
package chap09; public class Example19 { public static void main(String[] args) { new NewEngineer6(4, "imai"); new NewEngineer6(3, "shinohara"); new NewEngineer6(2, "tabuchi"); System.out.println("クラスの総人数："+ NewEngineer6.count); } } |
＜結果＞
| 4:imai:1人目です｡ 3:shinohara:2人目です｡ 2:tabuchi:3人目です｡ クラスの総人数：3 |
このように個々のインスタンスに持たせることのできない変数はクラス変数にします。
すべてのクラスで共有する変数なのでクラス変数と呼ぶわけです｡
しかし、クラス変数を使いすぎると様々なクラスから同一の変数にアクセスできてしまいます。
同じクラス変数を2つのプログラムで使用していると、一方が知らないうちに他方が変更を加えているということが起こり得ます。
変数にはスコープ（有効範囲）という概念があります。
スコープは狭い順から、ローカル変数、インスタンス変数、クラス変数です。
そして、できるだけスコープは狭くすべきなのです。
スコープを狭くすることで作成者が意図しない変数の使用をできないようにすべきです。
13.インスタンスメソッドとクラスメソッドの使い分け
次に、クラスメソッドはどんな時に使ったらよいでしょうか？
結論から言うと個々のインスタンス変数の情報を使うメソッドはインスタンスメソッド、そうではない場合はクラスメソッドとして設計すると良いでしょう。
ここでもJava８の標準APIにその範を求めましょう。
Mathクラスのrandomメソッド（標準API）を見てみましょう。
このクラスの説明を読むと以下のようになっています。
0.0以上で1.0より小さい、正の符号の付いたdouble値を返します。戻り値は、この範囲からの一様分布によって擬似乱数的に選択されます。
ゲームなどで有効そうなメソッドですね。
以下のサンプルプログラムを見てください。
|
1 2 3 4 5 6 7 8 |
package chap09; public class Example20 { public static void main(String[] args) { System.out.println(Math.random()); } } |
＜結果の例＞
| 0.40083501149385037 |
結果は様々な乱数が表示されます。
この時に例えば、Mathのインスタンスを作ってそのインスタンスのrandomメソッドを呼び出すというのはどうでしょうか？
少しまどろっこしい気もしますね。
Mathクラスではできませんが、別のクラスを使えば同じようなことができます。
その名もRandom（標準API）という名前のクラスです。
説明文には、
多くのアプリケーションの場合、
Math.random()メソッドを使うほうが簡単です。
と書いてありますが、このクラスを使ったサンプルも載せておきます。
サイコロのイメージです。
|
1 2 3 4 5 6 7 8 9 10 11 |
package chap09; import java.util.Random; public class Example21 { public static void main(String[] args) { Random r = new Random(); System.out.println(r.nextInt(6) + 1); } } |
これはプログラミングというよりは設計の問題になりますが、乱数を発生させるためだけにインスタンスを生成して、その都度使い捨てるのは、メモリやCPU時間の無駄です。
そこで、Javaの設計者はMath.randomをクラスから直接呼び出せるクラスメソッドにした訳です。
ちなみに、Mathクラスはその名の通り数学のためのクラスです。
数学でよく使う様々な計算ツールが揃っています。
このようなクラスをユーティリティクラスと呼ぶことがあります。
Mathクラス（標準API）で見てみましょう。
コンストラクタの定義が見当たりませんね。
こんどはJavaのソースコードを見てみましょう。
IDEをお使いのことと思いますので、ソースコードのMathをキーボードのコントロールキーを押したままクリックしてみてください。
Javaのソースコードを見ることができました。
クラスの宣言のすぐ下に以下のようなコンストラクタが見えますか？
|
110 |
private Math() {} |
コンストラクタがprivateで宣言されています。
privateはpublicの反対の意味で「非公開」ということですね。
つまり、このコンストラクタは他のクラスからは呼び出せないようになっているのです。
その意図は、インスタンスを作らせない純粋なユーティリティクラスであるという宣言です。
Mathクラスはインスタンスを作れないクラスなのですね。
最後にメソッドの呼び出し方をまとめておきます。
| 同じクラス内に定義されているメソッド | メソッド名（実引数）※１ |
| インスタンスに定義されているメソッド | 変数名.メソッド名（実引数） |
| クラスメソッド | クラス名.メソッド名（実引数）※２ ただし、変数名.メソッド名（実引数）と書いてもコンパイラが左記の通りに解釈する |
| スーパークラスのメソッド | super.メソッド名（実引数）※３ 次の継承を参照のこと |
※１に関してクラスメンバからインスタンスメンバへのアクセスはできません。
なぜなら、どのインスタンスの持っているメンバかを特定できないからです。
インスタンスメンバからクラスメンバのアクセスはできます。
なぜなら、staticの付いたメンバは同じクラスから作られる全インスタンスで共有されるものだからです。
ちなみに、お気づきの方も多いと思いますが、IDEでソースコードを書いている最中に
| 変数名． |
と入れて少し待つと、いろいろなメンバがウィンドウに表示されるかと思います。
自分で作成したフィールドやメソッドはもちろんですが、中には作成した覚えのないequalsメソッドやtoStringメソッドもありますね。
この点に関しては次回の継承で重要になってくる事実ですので、記憶にとどめておいてください。
<まとめ：隣の人に正しく説明できたらチェックを付けましょう>
|
□オブジェクト（抽象概念） ＝ クラス（設計図） ＋ インスタンス（具体的なもの）
□個々のインスタンス固有の変数をインスタンス変数（またはインスタンスフィールド）と呼ぶ（単なる変数やクラス変数と区別する）
□Javaで使用できる変数の型にはプリミティブ型と参照型があり、参照型の変数にはインスタンスへの参照が入っている
□インスタンスの参照をメソッドの引数として渡すことができるが、その時インスタンスはコピーされない
□コンストラクタとはインスタンスを作り出す処理のことであり、クラス名と同じ名前で戻り値はない
□staticキーワードがついたクラスメンバからインスタンスメンバへのアクセスはできない。インスタンスメンバからクラスメンバのアクセスはできる
|
まとめができたら、アウトプットとして演習問題にチャレンジしましょう。
今回はインスタンスの活用について見てきました。
次回のテーマは継承（拡張）です。
これも、オブジェクト指向特有のテーマです。
スーパークラスを拡張してサブクラスを作る仕組みを解説します。
【今回の復習Youtube】
021-オブジェクト指向の基本-メソッドの作成-戻り値なし-引数なし
022-オブジェクト指向の基本-メソッドの作成-戻り値なし-引数あり
023-オブジェクト指向の基本-メソッドの作成-戻り値あり-引数なし
024-オブジェクト指向の基本-メソッドの作成-戻り値あり-引数あり
027-オブジェクト指向の基本-コンストラクタのオーバーロード
JavaSE8の解説に戻る
