2018年07月10日

師匠のJava道場~第11回・finalについて学ぶのじゃ!

師匠T:さてさて、この講座も10回を超えたか。ずいぶん歩んできたのう。

弟子D:はい。俺も、Javaのプログラミングについて、いくらか詳しくなったような気がします。

師匠T:言うようになったのう、こいつめ。まぁ、それもわしの見事な教えがあったればこそじゃな。

弟子D:……。

師匠T:ごほん。さて、今回は、final修飾子とについて説明していくとするぞ。

弟子D:はい、師匠!

▽まずはfinal修飾子についてじゃ!▽

師匠T:まず弟子Dに問題じゃ。finalという英語の意味とはなんぞや。

弟子D:えぇと、最後の、という意味でしたっけ。

師匠T:うむ。Javaでのfinalもそれと同じようなものじゃ。finalをつけると、そこから拡張や変更ができなくなるのだ。
どのようになるかは、これから説明していくぞ。

弟子D:はい!

師匠T:まずは、クラスやメソッドにつけた場合じゃ。これらにfinalをつけると、それらの継承やオーバーライドができなくなる。

弟子D:ふむふむ。

師匠T:これらの特性から、メソッドであっても、コンストラクタにはfinalをつけることはできない。注意しておくのじゃ。

Java1807-01.JPG
△ コンストラクタにfinalをつけるとエラーになるぞ!

師匠T:そして基本型の変数(フィールド)にfinalをつけた場合。このとき、この変数の値は変更することはできない。

弟子D:なるほど。

師匠T:なお、Javaでは、このようにして宣言された変数を定数として扱う。その場合、変数名は大文字で書くのが慣例じゃ。

弟子D:はい、わかりました!

師匠T:うむ、いい返事じゃ。さて、続いては、基本型の引数にfinalをつけた場合じゃ。これも同じように、その引数の値を変えることはできぬ。正確に言うと、変える命令を実行することはできるが、実際に値を変更することはできぬのじゃ。ほれ、この通り。

Java1807-02.JPG
△ 色が変わっている部分に注目。引数aの値を3に変えているが……。

Java1807-03.JPG
△ aの値は2のままだ!

弟子D:なるほど。

師匠T:なお、ローカル変数につけた場合も、フィールドと同じく、その値を変更することはできぬのだ。

弟子D:ふむふむ。あ、師匠。いまさらなんですが、ローカル変数とフィールドってどう違うので?

師匠T:うむ。それを説明し忘れておったの。どちらも、値を格納したり、インスタンスと結び付けたりといった機能は同じじゃが、ローカル変数は、そのメソッドの中でのみ有効で、メソッドを抜けると消滅してしまうもの、そしてフィールドは、メソッド外で宣言されたもので、そのクラス内ならどこからでも参照できるものを指すのじゃ。基本的にフィールドとは、そのインスタンスの特性を表すために使われておるな。

弟子D:なるほど、わかりました。

師匠T:うむ。さて、では続けるぞ。フィールド、ローカル変数問わず、参照型変数にfinalをつけた場合じゃ。

弟子D:はい。

師匠T:この場合、その変数の参照先(リンク先)を変えることはできない。しようとすると、エラーになるのじゃ。

Java1807-04.JPG
△ 参照型変数に、代入(参照型変数の場合は参照先の変更)しようとすると、エラーになるぞ!

師匠T:ただし、参照先の内容を直接変えるのならOKじゃ。

弟子D:なるほど、わかりました、師匠!

師匠T:うむ。次回は、Javaにおいて、クラスと並んで重要なポイントの一つ、例外について説明していくぞ。予習復習を忘れてはならぬ!



※次の更新は、7月12日。『師匠TのチャレンジARSゲーム!』の予定です。お楽しみに!
posted by 裏編 at 07:33| Comment(0) | 師匠のJava道場 | このブログの読者になる | 更新情報をチェックする

2018年06月07日

師匠のJava道場~第10回・抽象クラスを使うのじゃ!

弟子D:ど、どうなさったのですか、師匠? 何か黒いオーラが。

師匠T:いや、この間散歩しておったら、カップルがいっぱいな……いやなんでもない。気にするな。

弟子D:は、はぁ……(触らぬ神に……)

師匠T:さて、今回は抽象クラスについて説明する。覚悟はよいか?

弟子D:は、はい……。

▽抽象クラスとは?▽

弟子D:師匠、いきなりですが、抽象クラスとはなんぞや。

師匠T:うむ。抽象クラスとは、普通のクラスとは少し違っておって、継承されることを前提としたクラスじゃ。
 これには、次のような特徴があるぞ。

弟子D:ふむ。

師匠T:まず一つ。抽象クラスはインスタンスを作ることができない。

弟子D:つまり、例えば、Zakuクラスが抽象クラスだとして、そこからインスタンスのoZakuを作ることはできない、ということてすね? こんな風に。

----------
Zaku oZaku = new Zaku();
----------

師匠T:うむ、その通りじゃ。ただし、継承はできることを忘れてはならぬぞ。また二つ目の特徴として、抽象クラスは特別に、処理内容の中身を持たぬ、抽象なメソッド……ずばり抽象メソッドを持つことができる。
もちのろん、普通のメソッドを持つこともできるぞ。

弟子D:なるほど。でも、処理内容のないメソッドを用意して何になるんです?

師匠T:うむ、よい質問じゃの。例えば、複数のクラスの中で、ほぼ同じメソッドがあるとするじゃろ?

弟子D:はい。

師匠T:そうした場合、各クラスで別々のメソッド名にされては、管理が色々と困難になる。そこで、抽象クラス側で、そうしたメソッドを用意しておき、その処理は、この用意されたメソッドに書いてもらえばいい、というわけじゃ。
例えば、ZakuクラスもGoufクラスも、マシンガンを撃つ処理がある場合、スーパークラス側にMachineGunメソッドを用意しておき、どちらのクラスも、これを使ってもらえばいいというわけじゃな。

弟子D:なるほど!

師匠T:では次はいよいよ、抽象クラスの作り方、などについて説明するぞ!

▽抽象クラス、抽象メソッドを作るには?▽

師匠T:まずは、抽象クラスの作り方について説明していくとしよう。といっても簡単じゃ。クラス名の前に、abstractと描けばよい。

----------
例:abstract class Mobile Suits()
----------

弟子D:ふむふむ。

師匠T:そして、抽象メソッドの作り方じゃ。これもまた簡単で、メソッド名の前に、同じようにabstractをつければよい。

弟子D:ふむふむ。あ、publicとかprivateとか、型名とかの前と後、どちらに書けばいいんですか?

師匠T:おぉ、それがあったの。よくぞ気が付いた。

弟子D:忘れるなんて、師匠ももうと……。

師匠T:何か言ったか?

弟子D:いえ、なんでもありません……。

師匠T:ごほん。abstractは、それらの前に書けばよいのじゃ。この通り。

----------
例:abstract public void MachineGun();
----------

師匠T:この例の通り、抽象メソッドには、波かっこ({})もその処理も、何も書いてはならぬ。必ず、()の後、;で〆るのじゃ。

弟子D:ふむふむ。

師匠T:そして、ポイントをもう一つ。抽象メソッドを持たせれば、そのクラスは必ず抽象クラスになる。ゆえに……。

弟子D:そのクラスにも、abstractをつけなきゃならない、ということですね。

師匠T:さて。こうして作った抽象クラスを継承した場合、そのサブクラスは、次のいずれかになる。

(1) 抽象メソッドを全て実装(メソッドの処理内容を全て書く)した場合、通常のクラスになる。
(2) 抽象メソッドが一つでも実装されなかった場合、そのクラスも抽象クラスになる。

師匠T:このため、(2)に該当するクラスにも、abstractをつけなくてはならぬ。注意せよ。

弟子D:はい、師匠!

師匠T:なお、継承したサブクラスで、その抽象メソッドを使う場合は、いつも通りにそのまま使えばよい。

----------
※抽象クラス側
abstract public int Shot();


※サブクラス側
public int Shot() {

}
----------

▽参照型変数についてじゃ!▽

師匠T:このことについて話す前に、一つ教えておくべきことがある。前回、オブジェクト型の変数は、実際に中に何か入っているわけではなく、変数から、オブジェクトにリンクが張られている、と話したな?

弟子D:はい。

師匠T:このような変数を、『参照型変数』ともいう。覚えておくように。

弟子D:わかりました!

師匠T:うむ。さて、先ほど話した通り、抽象クラスからはインスタンスを作ることができぬ。じゃが、今話した参照型変数にすることはできるのじゃ。

----------
※MobileSuitsクラスは抽象クラスです。
Zaku oZaku = new MobileSuits(); はNG
MobileSuits oMS = new Zaku(); はOK
----------

弟子D:ふむふむ。

師匠T:これは、後に説明する多態性について重要なポイントなので、心の片隅にでも覚えておくがよい。

弟子D:はい、師匠!

▽thisについてなのじゃ!▽

師匠T:さて。それでは次は、抽象メソッドの実装についてじゃ。スーパークラスで宣言されたフィールド(変数)を、サブクラス側で利用したい場合は、次のように書く。

----------
this.〇〇〇
例:this.sisyo
----------

弟子D:なるほど! ところで、サブクラスってなんでしたっけ?

師匠T:はぁっ!!(飛び蹴り)

▽オーバーライドについてなのじゃ!▽

師匠T:さて、次は@overrideについてじゃ。これは、次の二つの使用法で使われる。

(1) 抽象メソッドを実装する
(2) 既にあるメソッドの内容を上書きする
(3) インターフェイスの抽象メソッドを実装する

師匠T:(3)については、後の講座で説明するぞ。さて、(1)については既に話したの?

弟子D:はい。処理内容が何もないメソッドの処理を実際に書く……でいいんでしたっけ?

師匠T:うむ、そのようなものと考えればよかろう。そして、(2)についてじゃが、例えば、RPGにおいて、戦闘終了後の処理で、既存のシステムでは経験値とお金だけが入るのだが、今度作るゲームでは、特別なポイントを増やしたい、という場合があったりするじゃろ?

弟子D:はい。

師匠T:そのような場合、その既存の処理を残し、その処理の後、特別なポイントを増やす、という手法が使われることがある。場合によっては、その処理を丸々書き換えることもあるがの。
このように、スーパークラスのメソッドを、サブクラス側で書き換えることを、オーバーライドというのだ。

弟子D:なるほど。

師匠T:さて、そのような場合に使われる@overrideじゃが、使い方はそう難しいことではない。対象となるメソッドのすぐ上に、これを書けばいいだけじゃ。

----------
@override
public void MachineGun()
{

----------

弟子D:なるほど、わかりました。師匠!

▽多態性についてなのじゃ!▽

師匠T:さて。では最後に、先ほど話した、多態性について話すとしようぞ。多態性とは一言で言ってしまえば、同じメソッドでも、クラスによって実際の処理が異なることを言う。

弟子D:???

師匠T:例えばじゃ。例えばモビルスーツのクラスと、そのサブクラスがあったとする。

弟子D:はい。

師匠T:そのサブクラスそれぞれに格闘戦を表すメソッドがあったとしても、それぞれのモビルスーツによって、どうやって格闘戦を行うかは違ってくるじゃろ? ザクはヒートホークじゃが、ガンダムはビームサーベル、モビルファイターは拳で、というようにの。

弟子D:なるほど!

師匠T:このように、それぞれによって、実際の内容が違うのが、多態性、ポリモーフィズムというのじゃ。覚えておくがよい。

弟子D:はい!

師匠T:さて、次回はfinal修飾子について説明する。予習復習を忘れてはならぬぞ。ふぅ……さすがに疲れたわい。

弟子D:師匠ももうと……。

師匠T:はぁっ!!(飛び蹴り)

※次の更新は、6月11日、『師匠Tのチャレンジ!ARSゲーム』の予定です。お楽しみに!
posted by 裏編 at 09:00| Comment(0) | 師匠のJava道場 | このブログの読者になる | 更新情報をチェックする

2018年05月10日

師匠のJava道場~第9回・クラスを継承するのじゃ!

師匠T:さて、今回はクラスについての話第二弾、継承について話すとするぞ。準備はよいか?

弟子D:はい、師匠! でも、クラスについての話であれば、前回にすればよかったような。

師匠T:筆者が勉強したのは、クラス→キャスト→継承の順番だったのじゃ、仕方なかろう。

弟子D:わかったような、わからんような。

師匠T:無理やりわかれ。では始めるぞ!

▽継承とはなんぞや?▽

師匠T:例えば、ゲームを作るときのことを考えてみよ。自機や敵に共通して、移動の処理があるが、二つのクラスそれぞれに移動の処理を書いていたら大変じゃの。

弟子D:そういえばそうですね。

師匠T:そんなとき、移動の処理を持つ共通のクラスを作り、それから自機や敵のクラスを作れば、移動させるときには、その処理を呼び出せばいいので楽ではないか?

弟子D:おぉ、それは確かにっ。

師匠T:これが継承の利点じゃ。そして話が前後してしまったが、継承とは、あるクラスを基にして別なクラスを作ることを言う。

弟子D:ガンダムで例えるなら、ザクを基にして、ザクキャノンや高機動型ザク、サイコミュ高機動試験型ザクを作るようなものですね!

師匠T:なぜおぬしがザクキャノンや高機動型ザクはまだしも、ビショップ(=サイコミュ高機動試験型ザク)のような、マニアックなMSのことを知っているかは置いといて、見事な例えじゃな、まさにその通りじゃ。

弟子D:師匠がビショップの名前を知っているのも十分謎ですが……。

師匠T:気にするな。さて、次は継承のやり方について説明することにするぞ!

▽継承のやり方じゃ!▽

師匠T:継承のやり方じゃが、とても簡単。クラス名の宣言のあとに、こうつければいいだけじゃ。

----------
extends [スーパークラス名]

例:
public ZakuCannon extends Zaku
----------

師匠T:前々回説明した通り、スーパークラスとは、あるクラスの基になったクラス、サブクラスとは、あるクラスを基にして作られたクラスを言う。例えば、ZakuクラスからZakuCannonクラスを作った場合、ZakuクラスはZakuCannonのスーパークラス、ZakuCannonクラスは、Zakuクラスのサブクラス、となるわけじゃ。

弟子D:ふむふむ。

師匠T:さてさて。継承してクラスを作った場合、スーパークラスのメソッドやフィールドは、private宣言されているものを除いて、全て継承される。例えば、前々回作ったZakuクラスからZakuCannonクラスを作った場合、Zakuクラスに備え付けられていたfireメソッドも、ZakuCannonクラスは自動的に持つことになるのじゃ。

弟子D:なるほど。コンストラクタはどうなのでしょう?

師匠T:残念ながら、コンストラクタは継承されぬ。じゃが、スーパークラスのコンストラクタを利用する方法はあるので安心するがよい。

▽Objectクラスじゃ!▽

師匠T:さて、次はObjectクラスについて語るとしようぞ。

弟子D:確か前回も出てきましたね。あらゆるクラスの親になるクラスでしたっけ。

師匠T:うむ、そのとおりじゃ。よく覚えておったの。このObjectクラスは、継承について大きな意味を持つ。

弟子D:それはどのような?

師匠T:うむ。継承させずにクラスを作るとき、当然ながら、extendsはつけぬな?

弟子D:はい。

師匠T:そのような場合、Javaは内部で自動的に、『extends Object』と補完するようになっておるのじゃ。このことについて、わしら開発者側は意識することはないがの。

弟子D:なるほど、よくわかりました!

▽継承のさいの注意点じゃ!▽

師匠T:さて、続いては、継承のさいに気を付けることについて語るとするぞ。まず一つは、継承を行うさい、スーパークラスにできるのは一つだけ。二つのクラスから継承して、サブクラスを作ることはできぬのじゃ。
例えるなら、Zakuクラスと、Goufクラスから継承して、ZakuGoufクラスを作る、なんてことはできぬのじゃ。

弟子D:それでは、そのようなものを作りたいときはどうすれば?

師匠T:うむ。そのような場合には、インターフェースというものを使う。じゃが、これの説明はあとに回すとしよう。

弟子D:はい。それで、今一つは?

師匠T:うむ。これが、難しくも重大なポイントじゃ。『[引数を持たないコンストラクタ]を持たないスーパークラスを継承するさいには、注意が必要』ということじゃ。

弟子D:それはどのようなことなのでしょう?

師匠T:うむ。そのようなクラスを継承するさい、コンストラクタを作らずに継承した場合、Javaは、勝手に『引数を持たないコンストラクタ』を補完してしまう。じゃが、スーパークラスはそのコンストラクタを持たぬゆえ、ビルドエラーになってしまうのじゃ。

弟子D:むむむ、なんか難しいですね。

師匠T:まぁ、難しければ、『[引数を持たないコンストラクタ]を持たないクラスを継承する場合、サブクラスのほうで、そんなコンストラクタを作ること』と覚えておけば問題はなかろう。

弟子D:ううう、わかりました、師匠。

▽スーパークラスの変数への紐づけじゃ!▽

師匠T:さて、この話をするさいに、一つ前提として覚えておくことがある。オブジェクト型の変数というものは、String型と同じように、オブジェクト(=インスタンス)へのリンクが張られた存在、ということじゃ。

弟子D:例えば、Zakuクラスの変数oZakuは、中に本当にZakuクラスのインスタンスが入っているわけではなく、インスタンスは別の場所にあり、変数からそのインスタンスへのリンクが張られている、ということですか?

師匠T:うむ、そういうことじゃ。さて、例えば、ある変数に、それと同じクラスのインスタンスをリンクすることができる……これは当然じゃな?

----------
※ZakuCannonは、Zakuのサブクラスです。
ZakuCannon CharsZaku = new ZakuCannon(~);
----------

弟子D:はい、そうですね。

師匠T:じゃが、ある変数に、そのクラスのサブクラスのインスタンスをリンクさせる、ということもできるのじゃ!

----------
Zaku GarmasZaku = new ZakuCannon(~);
----------

弟子D:な、なんと! それはすごいです、師匠!

師匠T:うむ、じゃが、この使い方をした場合、いくつか制限がある。まず一つ、作られるインスタンスは、作る際に指定したクラスのもので、リンク先の変数のクラスには影響されない、ということじゃ。つまり、上の例でいえば、作られるのはZakuCannonクラスで、Zakuクラスにはならん、ということじゃな。

弟子D:ちょっと難しいですけど、考えれば当然の話ですね。

師匠T:そして二つ目。リンク先の変数のクラスにないメソッドやフィールドは使うことはできない、というものじゃ。例えば、ZakuCannonクラスにLongShotメソッドというメソッドがあっても、この場合は使うことができぬ、ということじゃ。

弟子D:ふむふむ。

師匠T:そして最後。両方のクラスに同じメソッドがあった場合、インスタンスのクラス側のメソッドが実行される、ということじゃ。

弟子D:なるほど!

▽コンストラクタの補完その他じゃ!▽

師匠T:では、今回の講座のラストじゃ。クラスを作る場合、コンストラクタを省略した場合は、デフォルトコンストラクタが補完される。

弟子D:師匠、デフォルトコンストラクタとはいかに?

師匠T:デフォルトコンストラクタとは、コンストラクタがない場合、Javaが自動的に作ってくれるコンストラクタのことじゃ。次のような構造となっている。

----------
[クラス名]()
{

}

例:
Zaku()
{

}
----------

弟子D:引数を何も持たず、中身もないんですね。なぜこのようなものを?

師匠T:うむ。それは、コンストラクタを作った場合、Javaが自動的に、super()という命令を補完して、スーパークラスのコンストラクタを呼び出すようにしてくれるからじゃ。(コンストラクタを作らず、Javaがデフォルトコンストラクタを作った場合も含む)じゃが、元々スーパークラスにコンストラクタがないと、困ったことになる。そこで、コンストラクタを作らなかった場合、自動的にJavaがデフォルトコンストラクタを用意してくれる、というわけなのじゃ。

弟子D:なるほど。

師匠T:なお、super()の記述は、Javaの補完に任せず、自分で書くこともできる。その場合、コンストラクタの最初の行に書く必要がある。よいかな?

弟子D:はい、師匠!

師匠T:うむ、ではいよいよ最後じゃ。先ほど話した、スーパークラスのメソッドやフィールドを使いたい場合。これにもsuperを使う。その方法はこうじゃ。

----------
super.[メソッド名orフィールド名]

例:
super.x = 5;
super.fire();
----------

弟子D:superのあとに、ピリオドで区切って、メソッド名やフィールド名を書けばいいんですね。わかりました!

師匠T:うむ。さて、次回は、抽象クラスについて語ることにするぞ。予習、復習を欠かしてはならぬ!

※次回の更新は、5月14日、『師匠TのチャレンジARSゲーム!』の予定です。お楽しみに!
posted by 裏編 at 07:31| Comment(0) | 師匠のJava道場 | このブログの読者になる | 更新情報をチェックする

2018年04月06日

師匠のJava道場~第8回・キャストについて学ぶのじゃ!

師匠T:さて、それじゃ行くとしようぞ。弟子よ、心の準備はよいか?

弟子D:すやすや……

師匠T:なんじゃ、居眠りしておるのか。仕方ないのう。

弟子D:ぐぅぐぅ……師匠の老いぼれじじい……。

師匠T:……はぁっ!!(弟子に飛び蹴り

弟子D:うわぁ、師匠、何をなさるんです。

師匠T:やかましい。それでは今月も、Java道場を始めるとするぞ!

▽まず、キャストとはなんぞや?▽

師匠T:さて。今回は、キャストについて話すとするぞ。

弟子D:はい、師匠! さっそくですが、キャストとはなんぞや。

師匠T:うむ。例えば、int型をlong型、float型をdouble型というように、ある値を、別の型に変換することじゃ。このキャストには、二種類ある。プログラマが、プログラム中でコードを書いて自分で行うものと、Javaが勝手に変換してくれるものじゃ。一般的にキャストというと、前者のことを指すことが多い。

弟子D:ふむふむ。それで師匠。キャストはどの型からも、そしてどの型へも、自由にできるのでしょうか?

師匠T:おぉ、それは良い質問じゃな。居眠りしておったからか、頭がいつもよりさえているようじゃの。
 こほん。うむ、自由というわけにはいかぬ。型によって、できるキャストが決められておるのじゃ。次の通り。

・Boolean(ラッパークラス:Boolean)→キャスト不可能
・char(ラッパークラス:Character)→int、long、float、double
・byte(ラッパークラス:Byte)→short、int、long、float、double
・short(ラッパークラス:Short)→int、long、float、double
・int(ラッパークラス:Integer)→long、float、double
・long(ラッパークラス:Long)→float、double
・float(ラッパークラス:Float)→double
・double(ラッパークラス:Double)→キャスト不可能

弟子D:基本的に、上位の型(intならlongというように)へのキャストはできるんですが、下位にはできないんですね。それで師匠、ラッパークラスとはなんぞや?

師匠T:うむ。それは簡単に言ってしまえば、その型をより便利に使うために必要なクラスのことじゃ。例えば、int型のラッパークラスであるIntegerクラスなら、数値を文字列にしてくれるtoStringや、逆に文字列を数値に変換してくれるparseIntなどの、便利なメソッドが用意されておる。

弟子D:なるほど。

師匠T:さて、Javaが自動的にやってくれるキャストについてじゃが、これは変数に代入したり、計算を行うときに、Javaがその結果などを、適切な型に変換してくれる。

弟子D:それは便利ですね。

師匠T:うむ。じゃが、Javaに任せっきりにすると、思わぬエラーが出てくる可能性もあるから、なるべく必要なところでは、自分でキャストを行うのがいいじゃろう。

弟子D:はい、師匠!

▽キャストのやり方じゃ!(その1)▽

師匠T:ではいよいよ、キャストのやり方を伝授するとしようぞ。まずは、intやlongなどの基本型同士のキャストについてじゃ。これは、変数や値などの前に、( )で目的の型を囲んでやればいい。こんな感じじゃな。

(例)
double a = (double)b;

弟子D:ふむふむ。

師匠T:そして次は、数値の基本型(intやlongなど)とString型の変換についてじゃ。これは、先ほどのやり方ではキャストすることはできぬ。

弟子D:String型は、String型のインスタンス……つまり、オブジェクトですから、当たり前といえば当たり前ですね。では、どうするのですか?

師匠T:うむ。まず、String型を、基本型にキャストする場合じゃが、こちらは、目的とする基本型のラッパークラスに備えられておる、parse〇〇〇メソッドを使う。

(例)
int c = Integer.parseInt(d);

師匠T:逆に、基本型をString型にキャストする場合は、Stringクラスに備え付けられているvalueOfメソッドを使う。こんな感じじゃな。

(例)
String e = String.valueOf(f);

弟子D:なるほど!

▽キャストのやり方じゃ!(その2)▽

師匠T:さて、次はboolean型と、String型をキャストする方法じゃ。これも、通常の方法ではキャストすることはできぬ。これの場合も、基本型をString型にキャストするのと同じように、変換先の型のラッパークラスにあるvalueOfメソッドを使って変換する。
 なお、booleanをStringに変換した場合、結果はtrueまたはfalseという文字列になる。

(例)
boolean g = String.valueOf(h);
String i = Boolean.valueOf(j);

師匠T:そして次。intとBigDecimalの変換についてじゃ。

弟子D:あの師匠。BigDecimalとはなんぞや?

師匠T:うむ。これは、変更不可能な、任意の精度の符号付き10進数を扱う特別な型じゃ。オーバーフローしたり、精度を失うことなく、さまざまな計算ができるので、通貨の計算に適しておる。

弟子D:なるほど!

師匠T:それだけでなく、小数点以下の値を丸めるのにも便利じゃぞ。
 さて、基本型からBigDecimalにキャストする場合は、BigDecimalクラスにあるvalueOfメソッドを使って変換する

(例)
BigDecimal k = BigDecimal.valueOf(l);

師匠T:一方、BigDecimal型から基本型に変換する場合は、『変換元であるBigDecimal型変数の』〇〇〇Valueメソッドを使う。

(例)
int m = n.intValue();

師匠T:そして、StringとBigDecimalをそれぞれ変換する場合じゃが、まずはBigDecimalからStringに変換する方法。これは簡単じゃ。変換元変数のtoStringメソッドを使う。

(例)
String o = p.toString();

師匠T:そして、String型からBigDecimalに変換する場合じゃが、これはちと厄介じゃ。引数に、変換元のString型を渡したうえで、BigDecimalのインスタンスを作る必要がある。こんな感じじゃ。

(例)
BigDecimal q = new BigDecimal(r);

弟子D:なるほど、なんとかわかりました、師匠!

▽キャストのやり方じゃ!(その3)▽

師匠T:次は、Object型と基本型との変換についてじゃ。なお、基本型はまたの名を、プリミティブ型と呼ばれることもある。覚えておくがよい。
 さて、Object型というのは、あらゆるクラスの親に当たる。全てのクラスは、スーパークラス(親となるクラス)として、これを持っておる。

弟子D:ふむふむ。

師匠T:さて、基本型は、Object型の変数にそのまま入れることはできぬ。その型のラッパークラスのインスタンスを作り、それをObject型変数に代入する必要がある。

(例)
Object s = new Integer(t);

師匠T:そして、逆にObject型を基本型に変換する場合は、変換先の型のラッパークラスにある、〇〇Valueメソッドを使うのじゃ。

(例)
int u = new Integer(v).intValue();

弟子D:ふむふむ。

師匠T:そしてラスト。Object型とString型についてじゃが、これは変換することなく、そのまま代入することができる。じゃが、Object型をString型の変数に入れる場合は、toStringメソッドで、String型に変換してやる必要があるので注意するのじゃ。

(例)
String aa = bb.toString();
Object cc = dd;

弟子D:String型を、Object型に入れる場合は、そのまま入れればいいんですね。

師匠T:うむ。さて、今回はこれまで。次回は、再びクラスについての話に戻る。クラスの拡張について説明するぞ。復習、予習をしっかりしておくがよい。

弟子D:はい、師匠!

師匠T:ふぅ、さすがに疲れたのう。

弟子D:師匠も、もう歳……

師匠T:はぁっ!!(弟子に飛び蹴り)

※次回の更新は、4月9日。『パソレクのなく頃に』の予定です。お楽しみに!
posted by 裏編 at 09:02| Comment(0) | 師匠のJava道場 | このブログの読者になる | 更新情報をチェックする

2018年03月15日

師匠のJava道場~第7回・クラスについて知るのじゃ!(後編)

師匠T:さて、今月も始まったの。師匠のJava道場。
 今回は、アクセス修飾子と、文字列について学び、そしていよいよクラスを実際に作ってみようと思う。
 準備はよいか?

弟子D:はい、師匠!

師匠T:うむ。弟子も燃えておるようじゃの。いいことじゃ。それでは始めるぞ!

▽アクセス修飾子とはなんぞや?▽

師匠T:まずは、アクセス修飾子からじゃ。これは、クラス、メソッド、変数が、他所からアクセスできるかどうかを示したものじゃ。これには、次の四つがある。
・public……どこからでもアクセスできる
・protected……自分のファイルからはどこでもアクセス可能。他所のファイルからは、サブクラスからのみアクセス可能。
・private……自分のいるクラスからのみアクセスできる

師匠T:例えば、sisyoというクラス内に、privateで宣言された変数があった場合、この変数は、sisyoクラスの中からしか、アクセスすることはできぬのじゃ。

弟子D:一方、publicで宣言された場合は、どこからでもアクセスできるというわけですね? ……あれ? 師匠、四つあると言っておきながら、実際には三つしかありませぬが。ははーん、師匠ももうボケ……いてっ。

師匠T:たわけが。わしはまだまだ若い。アクセス修飾子を省略した場合も含むから、四つというわけなのじゃ。アクセス修飾子を省略した場合は、自分のファイルからなら、どこからでもアクセスできる。他のファイルのクラスなどからはアクセスできぬのじゃ。

弟子D:なるほど。それで師匠。protectedのときに述べられているサブクラスとはなんぞや?

師匠T:うむ。それは、あるクラスをもとにして作られたクラスのことじゃ。ちなみに、そのもとになったクラスのことは、スーパークラスという。

弟子D:ふむふむ。

師匠T:このあるクラスを基にして違うクラスを作ること……継承というがの……については、別の機会に説明する。今は、サブクラスは、スーパークラスから作られたクラスであることを覚えておけばよい。

弟子D:ということは、protectedで宣言された場合は、アクセスするクラスが、別ファイルにあるクラスから作られたサブクラスであれば、アクセスできる、ということですね。

師匠T:うむ、その通り。さて、ついでにstaticについても説明しておこう。一般的に、変数やメソッドなどにアクセスするためには、事前にそのクラスを実体化……これをインスタンス化という……させる必要があるが、staticがつけられたクラス、メソッド、変数は、インスタンス化させてなくてもアクセスすることができるのじゃ。

弟子D:おぉっ、それは便利ですね!

師匠T:じゃが、そんな便利そうなstaticにも一つ問題がある。staticで宣言されたメソッドからは、staticでないメソッドをアクセスすることはできぬのじゃ。

弟子D:なるほど……。

師匠T:なお、アクセス修飾子やstaticは、クラス名やメソッド名、変数名の前に、次のようにしてつける。

----------
[アクセス修飾子][static][型]名前
例:
public int a;
private static long b;
----------

師匠T:それと、protectedは、メソッドや変数にしか使うことができぬので、注意すること。

▽文字列の正体とは!?▽

師匠T:さて。いよいよ文字列についてじゃ。

弟子D:はい、師匠! 確か前、「文字列は特別で、変数では扱えない」と言っておられましたが。

師匠T:うむ。それはなぜか、いよいよ語るとしよう。実は文字列は……。

弟子D:ごくり。

師匠T:クラスであり、オブジェクトであるからなのじゃ!!

弟子D:な、なんと!?

師匠T:文字列は、Stringクラスというクラスのインスタンスなのじゃ。そして、この場合、文字列を変数に格納するというのは、実際には、その変数と、文字列……Stringクラスのインスタンスとを結びつける作業なのじゃ。

弟子D:つまり、入れているわけではなく、変数には文字列へのリンクが張られている、と?

師匠T:うむ、そのようなイメージで問題なかろう。それゆえに、この文字列と文字列変数には、いくつか、普通の変数と違う振る舞いや制限があるのじゃ。

弟子D:それはどのような?

師匠T:まず一つ。文字列は変更させることができない。

弟子D:ええええ!? だって、

----------
String s = "abc";
s = "def";
----------

弟子D:ってやったら、ちゃんと動きますよ?

師匠T:うむ。ちゃんと動く。だがそれは、abcという文字列が変わったからというわけではない。

弟子D:???

師匠T:おぬし、さっき言っておったであろうが。変数には何が張られている?

弟子D:あっ! 「文字列のリンク」!

師匠T:その通り。つまり、上の文からすると、書き換えているように見えるが、実際には、defという文字列(実際には、Stringクラスのインスタンス)を新しく作って、変数sからのリンクを、最初のabcという文字列から、新しく作られたdefという文字列に張りなおしているのじゃ。

弟子D:な、なるほど……。

師匠T:話を戻すぞ。そして二つ目。文字列変数は、通常の方法では比較することはできぬ。そのためには、Stringクラスに備わっている、equalsというメソッドを使う必要がある。使い方はこうじゃ。

----------
[文字列変数].equals(比較対象);
例:
s.equals("abc");
----------

師匠T:このメソッドは、文字列変数の中身が比較対象と同じならばtrueを返すぞ。なお、Stringクラスには他にも、文字列を扱うメソッドが色々とある。興味があるなら、Javaについての本やサイトを読むがよい。

弟子D:はい、師匠!

▽クラスを作ろう!▽

師匠T:さて、ではいよいよクラスを作ってみよう。今回は、fireメソッドを実行すると、「BAN!」と表示する、zakuクラスを作ることにする。

弟子D:はいっ!

師匠T:まずはクラス名の宣言からじゃな。どうするかは覚えておるか?

弟子D:え、えーとえーと……。

師匠T:こう書くのじゃぞ。改めて頭に刻みなおすがよい。

----------
[アクセス修飾子]class[クラス名]
----------

弟子D:ということは……

----------
public class Zaku {
----------

弟子D:こうですかね?

師匠T:うむ、その通り。次はコンストラクタじゃな。コンストラクタはこう書くぞ。覚えておるか?

----------
public クラス名(引数)
----------

弟子D:つまり、メソッド名が、クラス名と同じメソッドを作ればいいんですよね?

師匠T:うむ、その通りじゃ。さて、今回は引数はなしでいこう。とすると、こうなるぞ。

----------
public Zaku() {
----------

師匠T:コンストラクタの内容じゃが、"Stand Up!"と表示させることにしよう。ということで、さっきのと合わせて、コンストラクタはこうなる。

----------
public Zaku() {
  System.out.println("Stand Up!");
}
----------

師匠T:さて、次はfire……の前に、セッター、ゲッターのテストとして、弾数を表すint型の変数shotの内容を表示、および設定するゲッター『getShot』とセッター『setShot』も作るとしよう。

弟子D:変数shotは、どこで宣言すればいいんですかね?

師匠T:これまで学んだことと、セッター、ゲッターの意味から考えるのじゃ。セッター、ゲッターはそれを通して、変数の中身を変えるためにある。他方、変数の内容は、クラス内のセッター、ゲッターのどこからでもアクセスできるようにしなくてはならぬ。ということは?

弟子D:あっ! クラス変数として宣言しなくちゃならない、ということですね! ということは、public class Zaku {の下に書くのが正解なのでは? それも、privateとして。

師匠T:うむ、その通り。見事じゃ。その調子で、セッターとゲッターも作ってみるがよい。

弟子D:はい! えーと……こうでしょうか?

---------------------------------------
public int getShot() {
  return shot;
}

public void setShot(int inShot) {
  shot = inShot;
}
---------------------------------------

師匠T:うむ。ゲッター、セッターの両方とも、publicで宣言しておるな。正解じゃ。さて、本題のfireメソッドじゃが、これは簡単じゃな。

---------------------------------------
public void fire() {
  System.out.println("BAN!");
}
---------------------------------------

師匠T:完成したクラスのプログラムがこうじゃ。

-------------------------------------------
public class Zaku {
  private int shot;

    public Zaku() {
      System.out.println("Stand Up!");
    }

    public int getShot() {
      return shot;
    }

    public void setShot(int inShot) {
      shot = inShot;
    }

    public void fire() {
      System.out.println("BAN!");
    }
}
-------------------------------------------

師匠T:今回はここまで。次回は、クラスからいったん離れて、変数を扱ううえで重要なことの一つ、キャストについて説明する。復習、予習をしっかりしておくがよい。


※次の更新は、3月19日、URAURA Game Reviewの予定です。お楽しみに!
posted by 裏編 at 09:12| Comment(0) | 師匠のJava道場 | このブログの読者になる | 更新情報をチェックする