[Java入門]初心者がJava言語を覚えてみる(条件分岐)

コレまでの内容

  1. [Java入門]初心者がJava言語を覚えてみる(準備)
  2. [Java入門]初心者がJava言語を覚えてみる(コンパイル)
  3. [Java入門]初心者がJava言語を覚えてみる(基本文法)
  4. [Java入門]初心者がJava言語を覚えてみる(変数と型)
  5. [Java入門]初心者がJava言語を覚えてみる(基本データ型)

[Java入門]初心者がJava言語を覚えてみる(条件分岐)

とうとう制御文まできました。
ココがJava言語を覚える難関の一つかも知れません。

逆にココを超えて、初心者脱出です。
皆さん初級者になれます!

その前に、、、

制御で結構重要な boolean 型

前回かるーく流した boolean 型、ここで結構重要になります。
なんせ、繰り返し条件だったり、プログラムの分岐条件ってコレでやるしね(^^;

先ずは、この boolean 式を使う方法を学ぶとする。

  1. int i=32;
  2. boolean b;

としておいて、

  1. b = i < 64;

とか使った記憶あったよね?w
コレには結構色んな種類がある。

< 小なり
> 大なり
<= 以下
<= 以上
== 等しい
! 真偽逆転
&& なおかつ
|| もしくは

といった種類がある。

基本分岐

if文 について、
まぁ条件分岐なんて難しいコト言ってますが、
「このときはこうする」
でええやん。

基本的には以下の通り。

  1. if ( 条件(boolean) )
  2. {
  3.     (条件に一致した場合に動く部分)
  4. }
  5. else
  6. {
  7.     (条件に一致しなかった場合に動く部分)
  8. }

else 以降は無くても動きます。

まぁこっからは作って覚えましょ?
先ず、必要なネタからいきましょう。

  1. public class if_sample
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.     }
  6. }

ここから色々やってみましょう。
今回の目的は、「西暦14894年が閏年かどうか」です。

閏年って分かります?
ホラ、オリンピックやる年です。

4 で割りきれる年は閏年
100 で割り切れたら閏年じゃない
400 で割り切れたら閏年

でしたよね?
早速書いてみます。

条件的に、400で割り切れるかどうかというのは、
一番優先されそうですよね?

考え方は、400で割り切れる = 400で割った余りが 0 で考えます。

  1. public class if_sample
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int year = 14894;
  6.         if( (year%400) == 0 )
  7.         {
  8.             System.out.println(year + " は閏年です");
  9.         }
  10.     }
  11. }

次に、 100 で割り切れたら閏年じゃない。
は、いいとして、
既に「閏年」と判定されてるものを「閏年じゃない」って言っていいの?
って問題があります。

つまり、

  1. public class if_sample
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int year = 14894;
  6.         if( (year%400) == 0 )
  7.         {
  8.             System.out.println(year + " は閏年です");
  9.         }
  10.         if( (year%100) == 0 )
  11.         {
  12.             System.out.println(year + " は閏年じゃないです");
  13.         }
  14.     }
  15. }

って言えないよね?
西暦2000年で試してみましょう。
これは、400で割れるので、閏年ですが、、、、

  1. public class if_sample
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int year = 2000;
  6.         if( (year%400) == 0 )
  7.         {
  8.             System.out.println(year + " は閏年です");
  9.         }
  10.         if( (year%100) == 0 )
  11.         {
  12.             System.out.println(year + " は閏年じゃないです");
  13.         }
  14.     }
  15. }

実行結果

  1. 2000 は閏年です
  2. 2000 は閏年じゃないです

とまぁ、ちんぷんかんぷんなコト言います。
避ける為には、さっき出てきた else ってのを使いましょう。

  1. public class if_sample
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int year = 2000;
  6.         if( (year%400) == 0 )
  7.         {
  8.             System.out.println(year + " は閏年です");
  9.         }
  10.         else
  11.         {
  12.             if( (year%100) == 0 )
  13.             {
  14.                 System.out.println(year + " は閏年じゃないです");
  15.             }
  16.         }
  17.     }
  18. }

あれ? {} の中に {} って書いていいの?
って思った人。

全然OKっす

ガンガン書いてください。
この様に、入れ子の関係を作ることを、プログラムの世界では
「ネスト」といいます。

でももう少し綺麗なコードにならない?

そう思った人!正しい。
こういう書き方もできます。

  1. public class if_sample
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int year = 2000;
  6.         if( (year%400) == 0 )
  7.         {
  8.             System.out.println(year + " は閏年です");
  9.         }
  10.         else if( (year%100) == 0 )
  11.         {
  12.             System.out.println(year + " は閏年じゃないです");
  13.         }
  14.     }
  15. }

ぉぉぅ。
見た目スッキリー。

「else if」 という書き方で、「それ以外で、こういう条件のとき」
ですね。

  1. if ( 条件 1 )
  2. {
  3.     ( 条件 1 に合ったときに動く )
  4. }
  5. else if ( 条件 2 )
  6. {
  7.     ( 条件 1 に合わないけど、条件 2 に合ったとき動く )
  8. }
  9. else
  10. {
  11.     ( 全ての条件に合わなかったときに動く )
  12. }

という書き方です。
ここで、「else if」は何個でも書くことが出来ます。

最後に、「4で割り切れたら閏年」も追加しましょう。

  1. public class if_sample
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int year = 14894;
  6.         if( (year % 400) == 0 )
  7.         {
  8.             System.out.println(year + " は閏年です");
  9.         }
  10.         else if( (year % 100) == 0 )
  11.         {
  12.             System.out.println(year + " は閏年じゃないです");
  13.         }
  14.         else if( (year % 4) == 0 )
  15.         {
  16.             System.out.println(year + " は閏年です");
  17.         }
  18.     }
  19. }

その他の場合は、閏年ではありませんから、

  1. public class if_sample
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int year = 14894;
  6.         if( (year % 400) == 0 )
  7.         {
  8.             System.out.println(year + " は閏年です");
  9.         }
  10.         else if( (year % 100) == 0 )
  11.         {
  12.             System.out.println(year + " は閏年じゃないです");
  13.         }
  14.         else if( (year % 4) == 0 )
  15.         {
  16.             System.out.println(year + " は閏年です");
  17.         }
  18.         else
  19.         {
  20.             System.out.println(year + " は閏年じゃないです");
  21.         }
  22.     }
  23. }

これで一応完成です。

ですが、良く考えれば、boolean の計算には、
「&&(左も右も)」「||(もしくは)」ってのありましたよね?
これを使えば綺麗に書けるんじゃない?

先ずは、400 で割って余りが 0 のときは閏年(true)

  1. int year = 14894;
  2. boolean b;
  3. b = ((year % 400) == 0);
  4.  

それ以外(もしくは)、100 で割った余りが 0 のとき、閏年ではない(false)。

  1. int year = 14894;
  2. boolean b;
  3. b = ((year % 400) == 0) || !((year % 100) == 0)) ;
  4.  

なおかつ、4 で割った余りが 0 のとき、閏年(true)。

  1. int year = 14894;
  2. boolean b;
  3. b = ((year % 400) == 0) || ( !((year % 100) == 0) && ((year % 4) == 0) ));
  4.  

もう何がなんだか、、、、
分かりにくければ、下の考え方もある。

日本語に直すとこんな感じ。

(year を 400 で割れたら true) もしくは ( (year を 100 で割れたらfalse) なおかつ (year を 4 で割れたらtrue) )

true の反対は false , false の反対は true なので、

(year を 100 で割れたらfalse) = !(year を 100 で割れたらtrue)

(year を 400 で割れたら true) もしくは ( !(year を 100 で割れたらtrue) なおかつ (year を 4 で割れたらtrue) )

「もしくは」は「||」で、「なおかつ」は「&&」だから、

(year を 400 で割れたら true) || ( !(year を 100 で割れたらtrue) && (year を 4 で割れたらtrue) )

「year を X で割れたら true」 は、
「year を X で割った余りが 0 なら true」なので、
「(year % X)==0」
だから、

((year % 400) == 0) || ( !((year % 100)==0) && ((year % 4) == 0) )

理屈は分かるでしょ?
そうするとこんな感じになる。

  1. public class if_sample
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int year = 14894;
  6.         boolean b;
  7.         b = (year % 400) == 0) || ( !((year % 100) == 0) && ((year % 4) == 0) );
  8.         if( b )
  9.         {
  10.             System.out.println(year + " は閏年です");
  11.         }
  12.         else
  13.         {
  14.             System.out.println(year + " は閏年じゃないです");
  15.         }
  16.     }
  17. }

何か1行だけ長くて見栄えが、、、、
ここで、「改行と、半角スペースはいくら入れてもOK」を思い出すと、

  1. public class if_sample
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int year = 14894;
  6.         boolean b;
  7.         b = (year % 400) == 0)
  8.             || (
  9.                 !((year % 100) == 0)
  10.                 && ((year % 4) == 0)
  11.             );
  12.         if( b )
  13.         {
  14.             System.out.println(year + " は閏年です");
  15.         }
  16.         else
  17.         {
  18.             System.out.println(year + " は閏年じゃないです");
  19.         }
  20.     }
  21. }

さて、完成といえるでしょう。

プログラムにメモ書きしよう

さて、ここで問題です。
こんな複雑な式を覚えておける?
後で見て理解する自信ある?

僕はムリ!

プログラマの格言にこんなものがあります。
「3日前の自分は他人」

ええ、何を思って書いたのか分からんのです。
そこで、プログラムの中にメモ書きをするコトにします。

メモ書きは二種類あって、長文メモと一行メモの2つがあります。

長文メモの例

  1. /* 左の2文字から
  2. ↓の2文字までの間は、何書いてもOK!
  3. */

一行メモの例

  1. // 「//」から改行するまでは有効。何書いてもOK

これで、メモを入れていきましょうか。

  1. /* これは if 文のサンプルです。
  2.    内容としては、 14894年が、閏年かどうかを判定してます。
  3. */
  4. public class if_sample
  5. {
  6.     public static void main(String[] args)
  7.     {
  8.         // 判定したい年
  9.         int year = 14894;
  10.         boolean b;
  11.         // 判定計算。閏年なら true
  12.         // 400 で割り切れたら true
  13.         b = (year % 400) == 0)
  14.             // もしくは
  15.             || (
  16.                 // 100 で割り切れなければ true
  17.                 !((year % 100) == 0)
  18.                 // なおかつ 4 で割り切れたら true
  19.                 && ((year % 4) == 0)
  20.             );
  21.         if( b )
  22.         {
  23.             System.out.println(year + " は閏年です");
  24.         }
  25.         else
  26.         {
  27.             System.out.println(year + " は閏年じゃないです");
  28.         }
  29.     }
  30. }

と、メモ書きを残してみました。
何?まだ不安?
なら、一番難しいところをメモ書きする?

  1. /* これは if 文のサンプルです。
  2.    内容としては、 14894年が、閏年かどうかを判定してます。
  3.    
  4.    一番難しいところ → 閏年かどうかの判定
  5.    最初は日本語で考えてみる。
  6.  
  7.    (year を 400 で割れたら true) もしくは ( (year を 100 で割れたらfalse) なおかつ (year を 4 で割れたらtrue) )
  8.  
  9.    true の反対は false , false の反対は true なので、
  10.    (year を 100 で割れたらfalse) = !(year を 100 で割れたらtrue)
  11.  
  12.    (year を 400 で割れたら true) もしくは ( !(year を 100 で割れたらtrue) なおかつ (year を 4 で割れたらtrue) )
  13.  
  14.    「もしくは」は「||」で、「なおかつ」は「&&」だから、
  15.  
  16.    (year を 400 で割れたら true) || ( !(year を 100 で割れたらtrue) && (year を 4 で割れたらtrue) )
  17.  
  18.    「year を X で割れたら true」 は、
  19.    「year を X で割った余りが 0 なら true」なので、
  20.    「(year % X)==0」
  21.    だから、
  22.  
  23.    ((year % 400) == 0) || ( !((year % 100)==0) && ((year % 4) == 0) )
  24. */
  25. public class if_sample
  26. {
  27.     public static void main(String[] args)
  28.     {
  29.         // 判定したい年
  30.         int year = 14894;
  31.         boolean b;
  32.         // 判定計算。閏年なら true
  33.         // 400 で割り切れたら true
  34.         b = (year % 400) == 0)
  35.             // もしくは
  36.             || (
  37.                 // 100 で割り切れなければ true
  38.                 !((year % 100) == 0)
  39.                 // なおかつ 4 で割り切れたら true
  40.                 && ((year % 4) == 0)
  41.             );
  42.         if( b )
  43.         {
  44.             System.out.println(year + " は閏年です");
  45.         }
  46.         else
  47.         {
  48.             System.out.println(year + " は閏年じゃないです");
  49.         }
  50.     }
  51. }

これでどうでしょう?
これって実は結構、教科書とか、学校の授業で出る問題なんですよね。

覚えておくと学校の授業が楽になる?

本日のまとめ

  • 「boolean」は単純に見えておくが深い
  • 「if」文で、条件付で実行できる
  • 「if」に合わなくても、「else if」で追加条件ができる
  • 「else」で条件に合わないときのものが書ける
  • 「//」や「/* */」で、プログラムの中にメモ書きできる

[Java入門]初心者がJava言語を覚えてみる(基本データ型)

コレまでの内容

  1. [Java入門]初心者がJava言語を覚えてみる(準備)
  2. [Java入門]初心者がJava言語を覚えてみる(コンパイル)
  3. [Java入門]初心者がJava言語を覚えてみる(基本文法)
  4. [Java入門]初心者がJava言語を覚えてみる(変数と型)

[Java入門]初心者がJava言語を覚えてみる(基本データ型)

前回を振り返って

プログラムの扱うデータは、「型」って形で
それぞれ別な扱いを受けるのは前回で分かってもらえたと思う。
そして、整数型の変数を用意して、
変数の使い方についてやってみた。

ここでは、他の型、主に、基本データ型と呼ばれるものについて
紹介していこうと思う。


基本データ型

プログラムで最も基礎となる、データの型、
変数の型を、基本データ型という。
ここから先、変数宣言と使い方を片っ端から示そう。

クラス宣言やメインは省略するので、
コンパイルする際はその辺補完 YO RO SHI KU! SHI KU YO RO!


最小の整数型:byte

前回やった整数型は、int ですが、Javaには他にも
整数型があります。

どれも、足し引き算、掛け算、割り算、剰余算が出来ますが、
決定的に違うものがあります。

それは値の範囲です。

-128 - 127

ちいさっ!!と思うよね?
でもこの値って実はプログラムの
データ取り扱いの最小単位だったりするんだわ(;・∀・)

  1. byte b = 32;
  2. b = b - 120;
  3. System.out.println("byte : " + b);

やや小さめの整数型:short

やや小さめも整数型。
プログラムは、0 と 1 しか無いって言ったのですが、
この 0 or 1 の二進数の桁をビットといいます。
実はさっきの byte ってやつは 8 ビットで、
0 と 1 が 8 個並んでるのが byte なんですね。

そして、この short なんですが、
その倍の 16 bit あります。
それだけ大きな数が使えるんですね。

分かりやすくいうと、、、、
byte : ファミコンLv
short : スーパーファミコンLv
ですね。

値の範囲は

-32768~32767

うん。この辺りからもう根性で数えるのは厳しいねw
使い方は以下の通り

  1. short s = 32;
  2. s = s - 120;
  3. System.out.println("short : " + b);

基本的にやること変わんない、、、、|||orz


いつもの整数型:int

前回もやった整数型、int です。
こいつは short より更に上だぜ!
それも 32 ビット! ….ってプレステですやん(´・ω・`)

値の範囲は以下の通り

-2147483648 ~ 2147483647

この辺になってくると、もうなんだか分からない桁に(^^;
20億、、、国家予算計算なら使い切るのかもね、、、。

そして代わり映えのしないサンプルコード

  1. int i = 32;
  2. i = i - 120;
  3. System.out.println("int : " + i);

多倍長整数型:long

何かかっこいい名前の来ましたよ!
long って何が長いんだい?ねぇピート!
お~カール!そいつは 64 ビット もあるんだよハッハー!
そいつはご機嫌だねぇ!!

、、、って早い話が NINTENDO 64 と同Lv

値の範囲はもう凄いことに

-9223372036854775808~9223372036854775807

( ; ゚Д゚)
900京の数字なんてどんな計算で使うことやら、、、。
まぁいいんですがね?(;・∀・)

これだけちょっと使い方が違うよ~

  1. long l = 123456789L;
  2. l = l * 120000L;
  3. System.out.println("long : " + l);

何か整数の後ろに、「 L 」が付いてるのが分かると思う。
こうしないと、書いた数字が int として扱われてしまう。
つまり、

  1. long l = 2147483648;

こう書くと、「2147483648」 という数字は、
「int」として、処理しようとする、、、、、、が、
int の最大は 2147483647 なので、
結局 l には何か不明な数字が入ってしまう。
(実際には -1 )

よって、以下の様に書く。

  1. long l = 2147483648L;

これでしっかりデータが入った。
ココから先は、非整数になっていくよー


文字型:char

はい。見覚えの無い型が出ました。
char と書いてますが、 charactor の略です。

キャラクタ?ってホラゲームの、、、、
いえいえ違います。
プログラムのキャラクタって言うのは表示する文字です。
char ってのは、文字を「1文字だけ」を指す型です。

「たかだか1文字じゃ文章できねぇよ!」
はいその通り。
まぁ、その辺は追々テクニックをお教えします。

文章が大量に出てくるゲームをこれでどうやって作るのか?
知れば知るほど道のりが遠くなるのがプログラムです。

千里の道を千里と知って歩むものだけが、
真のプログラマになれます。

使い方

  1. char c;
  2. c = ‘a’;
  3. System.out.println("charactor : " + c);

文字列(文章)と、1文字の違いが分かりますでしょうか?
コレが分かる人は注意力ありますねー

文字を囲むとき、「’」を使うか、「”」を使うかの違いです。

「文字と文字列?ってコトは 文字列型ってあるんじゃない?

と考えた人。いい勘してますよ。
あるんですw
基本型じゃないので、今回は紹介しませんけど、、、


浮動小数点数 : float

チョット小さい浮動小数点型。
勿論大きな浮動小数点型というのもありますよ?
取り合えずこっちから~

使い方は

  1. float f = 0.13578f;
  2. f = f * 10.555f;
  3. System.out.println("float : " + f );

扱える値の範囲は、
±3.40282347E+38 ~ ±1.40239846E-45

なんのこっちゃ、、、( ; ゚Д゚)
E+38 と書いてあるけど、これは 10 の 38 乗。
まぁ要するに、異常に大きな数字が使えると、、、、。

た だ し ☆

有効桁数というものが浮動小数点にはある。
これの場合 9 桁以降は信用できないのであ~る。


倍制度浮動小数点数:double

普通小数点というとコレを挿す、、、、というほど
良く使う double型

扱える値の範囲は
±1.79769313486231570E+308 ~ ±4.94065645841246544E-324

有効桁数は15桁!
うーん優秀だ。

使い方は、、、、

  1. double d = 0.13578;
  2. d = d * 10.555;
  3. System.out.println("double : " + d );

論理型:boolean

論理型、、、、なーんか難しそう、、、、って言うかもしれませんが、
ある意味難しい。

ホラ、中学で「真である、偽である」とか、数学でやらなかった?

あ…ごめんちゃいm( __ __ )m
いやな記憶思い出させましたね、、、

まだ早い話が、「正しい(true)」か「正しくない(false)」かを扱う型です。
逆を言えば、値はこの2つしかありません。

次のサンプルを見れば分かるのかも知れません。

  1. int i = 5;
  2. boolean bool;
  3. bool = (i < 10);
  4. System.out.println(bool);

「i」 には、「5」が入ってますから、当然10以下です。
よって、結果は「正しい」ですから、bool には true が入ります。

よって、結果は「true」と表示です。


本日のまとめ

  • Javaには、int,short,byte,long,char,float,double 等の型がある
  • int , short , byte , long は全て整数型
  • float , double は浮動小数点型
  • char は1文字しか扱えない!
  • boolean は true か false しか入らない

[Java入門]初心者がJava言語を覚えてみる(変数と型)

コレまでの内容

  1. [Java入門]初心者がJava言語を覚えてみる(準備)
  2. [Java入門]初心者がJava言語を覚えてみる(コンパイル)
  3. [Java入門]初心者がJava言語を覚えてみる(基本文法)

[Java入門]初心者がJava言語を覚えてみる(変数と型)

またも前回に学んでみる。

前回の結果を覚えているだろうか?

  1. public class StudySimpleMath
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         System.out.println("512 + 22 = " + ( 512 + 22 ));
  6.         System.out.println("512 - 22 = " + ( 512 - 22 ));
  7.         System.out.println("512 × 22 = " + ( 512 * 22 ));
  8.         System.out.println("512 / 22 = " + ( 512 / 22 ));
  9.         System.out.println("512 を 22 で割った余り " + ( 512 % 22 ));
  10.     }
  11. }

これである。

割り算の結果は、23 と表示されていたはずだ。
しかし、正しい結果は、「23.2727272727…」である。

嘘だと思うなら電卓で、、、、って
小学生を対象にしてるんじゃないから分かるよね?(|| ゚Д゚)
何故このようなことになったのか、、、

その答えは、 512 / 22 という書き方にある。
2つの数は、共に「整数」である。
「整数」って覚えてます?
小数点の入らない数字のコト。
中学校以降、こんな呼び方そうそうしないから
(文系は特に)忘れてるんじゃないかなー(;・∀・)

…え?知ってる?……そうか……。

Java言語というヤツは、「整数」同士の計算結果は、
必ず「整数」になるというルールがある。

ということはだ、正しい結果(小数点以下)が欲しければ、
「小数点付き」で入力してやればよいのではないか?
と、考えたら、それ正解。

実際に、以下のコードに変更してみる。

  1. public class StudySimpleMath
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         System.out.println("512 + 22 = " + ( 512 + 22 ));
  6.         System.out.println("512 - 22 = " + ( 512 - 22 ));
  7.         System.out.println("512 × 22 = " + ( 512 * 22 ));
  8.         System.out.println("512 / 22 = " + ( 512.0 / 22.0 ));
  9.         System.out.println("512 を 22 で割った余り " + ( 512 % 22 ));
  10.     }
  11. }

512.0 / 22.0 というように、「?.0」と、小数点第一位をくっつけた。
実行してみよう!
すると、以下の様な結果になる。

  1. C:\JavaStudy>javac StudySimpleMath.java
  2.  
  3. C:\JavaStudy>java StudySimpleMath
  4. 512 + 22 = 534
  5. 512 - 22 = 490
  6. 512 × 22 = 11264
  7. 512 / 22 = 23.272727272727273
  8. 51222 で割った余り 6

うん、正しく表示されましたね。
このような「小数点付き」の数字を、
プログラムでは「浮動小数点数」といいます。

あ、そういえば気づいてました?
表示コマンドの「System.out.println()」ですけど、
プログラムの上から順に動いてるらしいって。

あ……知ってましたか……そっか……。


型について

結局、整数浮動小数点数で扱いが違うことが分かりましたが、
プログラムではこの違いを「型の違い」と表現します。
そして、「型」によって、それぞれ別の扱い方をします。

つまり、プログラムからは、「整数型」「浮動小数点型」という二つの
別な型として扱います。


変数

さて、整数と浮動小数点数が、それぞれ違う型なので、
扱いが違うと分かったところで、
初心者が最初に躓く「変数」について説明してきましょう。

変数とは何か?

あ、哲学するワケじゃないからそのまま聞いてね。

パソコンというもの、プログラムってやつは、正直アホです。
何処がアホかって?
先ほど、色々計算して画面表示しましたよね?

実はあれ、表示し終わったら計算結果忘れてるんです。

そう、プログラマの私たちがちゃんと「記録しろ」っていわないと、
計算したそばから忘れてしまいます。

ね?アホでしょ?

そこで、計算した結果を、整数専用の用紙にメモします。
この メモ用紙 は、同じ 整数 のデータでなら、
何度でも書き換えできます。

もちろん、この メモ用紙整数 と同じ様に扱えます。

変化 する 整数 として扱える、、、、
ということで、このメモ用紙変数 といいます。


変数のプログラム

まぁ百聞は一見に如かず、千聞とてまた然り。
(あ、この言葉僕のお気に入りね♪)

プログラムを作ってみましょう。
クラス名は、、、StudyVariable としときましょう。
で、計算結果が入るのを確認しないといけませんので、
「最初に 0 を入れて表示する。
その後、 3 の 2 乗を計算し、更に 5 を引いて、それぞれ結果を表示する。」

としましょう。

とりあえず、main まで用意する。

  1. public class StudyVariable
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.     }
  6. }

整数をメモする「変数」の用意の仕方は、

  1. int (変数名)

なので、今回は 「Seisu」 とでもしときます。
1行、1命令の後には 「;」 を入れる必要もあるので、

  1. public class StudyVariable
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int Seisu;
  6.     }
  7. }

となります。

先ずは、Seisu0 を入れて表示します。

  1. public class StudyVariable
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int Seisu;
  6.         Seisu = 0;
  7.         System.out.println("Seisuの中身 = " + Seisu );
  8.     }
  9. }

実はこれ、変数を用意すると同時に代入(= で変数に値を入れる)
することが出来ます。
なので、それを使って書き直してみると、

  1. public class StudyVariable
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int Seisu = 0;
  6.         System.out.println("Seisuの中身 = " + Seisu );
  7.     }
  8. }

どっちで書いても間違いじゃないですよ~(念のために)。

次に、「3 の 2 乗を計算し表示する」ってのやってみます。
計算は 3 * 3 ってだけで、代入のやり方もやりましたからこの位は楽勝?

  1. public class StudyVariable
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int Seisu = 0;
  6.         System.out.println("Seisuの中身 = " + Seisu );
  7.         Seisu = 3 * 3;
  8.         System.out.println("3 * 3 = " + Seisu );
  9.     }
  10. }

最後に、Seisu の中の数を 5 引いて表示します。
ここが一番分かりにくいかな?
Seisu「変数」 ですので、数字として扱えるから、

  1. public class StudyVariable
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int Seisu = 0;
  6.         System.out.println("Seisuの中身 = " + Seisu );
  7.         Seisu = 3 * 3;
  8.         System.out.println("3 * 3 = " + Seisu );
  9.         Seisu = Seisu - 5;
  10.         System.out.println("Seisu - 5 = " + Seisu );
  11.     }
  12. }

はい、保存してコンパイルして実行~!
今回は実行結果載せてあげない♪

因みに、上のプログラムにエラーはないですよー。
だって、コピペして試しましたからw
タイプミス(誤字)や、
「;」の付け忘れなんかを確認してみてくださいな。
{ } の対応もきちんと確認!

書き方で気をつけないといけないのが、「 = 」の扱い方ですね。
良く算数だと

3 - 2 = Seisu

みたいに書くのが、逆

Seisu = 3 - 2

になってますよね?
プログラム言語は、「 = 」は左右が等しいって意味じゃなくて、
右の値を左に入れる って意味なんですね。
難しい言い方すると、「代入演算子」 っていうプログラムコードなんですねー。

これはもう「慣れてください」としかいえません。


本日のまとめ

  • プログラムは、上から順に実行される。
  • プログラムで使うデータ(今回は整数と浮動小数点数)は、それぞれ別々の「型」というプログラムの枠組みで分けられ、扱い方が違う。
  • プログラムは、計算して、終わると結果を忘れるお馬鹿さん。
  • 計算結果は、変数代入 して、記録できる。
  • 変数 は、 として、計算式に書ける。

[Java入門]初心者がJava言語を覚えてみる(基本文法)

コレまでの内容

  1. [Java入門]初心者がJava言語を覚えてみる(準備)
  2. [Java入門]初心者がJava言語を覚えてみる(コンパイル)

初心者がJava言語を覚えてみる(基本文法)

ここでは、計算することを目標にしてみる。

前回のコンパイルの時のコードを参考にしてみる。

ファイル名:StudyCompile.java

  1. public class StudyCompile {
  2.     public static void main ( String[] args ) {
  3.         System.out.println("何か喋らせてみた");
  4.     }
  5. }

ここから、以下のことが分かる。

  1. 「ファイル名」と「public class」の後の名前が一致している。
  2. { } で範囲が区切られているらしい(何の範囲かは不明)。
  3. System.out.println(”"); を使えば表示ができる。

で、魔法の様に使ってた言葉の説明をしていく。

1、クラスの名前

  1. public class StudyCompile

Java という言語は、プログラムの一つ一つを「class」という単位で扱う。
このコードは、「StudyCompile」という「class」ですよという意味。
そして、直後の { } によって、「ここからココまでがクラスの範囲ですよ」と示している。

public は誰でも実行していいですよー という意味。
(無いと制限を食うこともw)

2、main からプログラム開始

  1. public static void main ( String args[] )

プログラムを書いたところで、何処から実行していいのか、
パソコンは馬鹿なので分からない(苦笑)
そこで、「ここから始まりますよ~」という目印に main と記述する。

static と void は、まぁ、、、後で説明しますよ(--;
( String args[] ) は、コマンドライン引数、、、、とかいうので使う。
後で説明させてくれ(;;


それを踏まえたうえで、プログラムを順に書いて考える。

最初にクラスが欲しい。
StudyCompile というプログラムだから、

  1. public class StudyCompile{}

main文が無いと、プログラムが何処からはじまっていいか分からないので追加。

  1. public class StudyCompile
  2. {public static void main(String[] args){}
  3. }

文字を表示させるよいう処理を書く。

  1. public class StudyCompile
  2. {public static void main(String[] args)
  3. {System.out.println("何か喋らせてみた");}
  4. }

これで一応は完成だ。
プログラムの範囲というのは { } で囲まれているというが、、、
今の状態では { } がちゃんとあるのか良く分からない。
↓のプログラムはエラーになる。

  1. public class StudyCompile
  2. {public static void main(String[] args)
  3. {System.out.println("何か喋らせてみた");
  4. }

何が違うのか、1 秒以内に判別するのは難しいと思う。

そこで、半角スペースやタブを使って整形する。
Javaにおいて、半角スペースやタブ、改行はプログラム的な意味はないので、
いくらでも追加 OK である。

追加の方針は、

  • { が出たら次以降の行は半角スペース4個↑に上げる
  • } が出たら次以降の行は半角スペース4個↓にさげる
  • { } が出たら必ず改行(次の行に)する

それで、エラーになるプログラムを修正する。

  1. public class StudyCompile
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         System.out.println("何か喋らせてみた");
  6.     }

すると、「public class StudyCompile」分の「 } 」が足りてないことが分かる。
このような空白を、「インデント」という。


簡単な計算をさせてみる

512 と 22 という数字を使って、簡単な計算をやっていこうと思う。
クラスの名前は、、、、「StudySimpleMath」 にしておく。

最初に、クラスと、main を用意しよう。

  1. public class StudySimpleMath
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         System.out.println("512 + 22 = " + ( 512 + 22 ));
  6.         System.out.println("512 - 22 = " + ( 512 - 22 ));
  7.         System.out.println("512 × 22 = " + ( 512 * 22 ))
  8.         System.out.println("512 / 22 = " + ( 512 / 22 ));
  9.         System.out.println("512 を 22 で割った余り " + ( 512 % 22 ));
  10.     }
  11. }

保存名は、、、、わかるよね?
クラスの名前が「StudySimpleMath」だから、、、、

早速コンパイルしてみます。

  1. C:\JavaStudy>javac StudySimpleMath.java
  2. StudySimpleMath.java:7: ‘;’ がありません。
  3.                 System.out.println("512 × 22 = " + ( 512 * 22 ))
  4.                                                                                                                 ^
  5. エラー 1
  6.  
  7. C:\JavaStudy>

エラーが出てしまいましたね。

StudySimpleMath.java:7: ‘;’ がありません。

というのは、説明してませんでしたが、処理を1つ、1行ごとに「 ; 」が必要です。
それを書かなかったからです。

修正したものが↓です。

  1. public class StudySimpleMath
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         System.out.println("512 + 22 = " + ( 512 + 22 ));
  6.         System.out.println("512 - 22 = " + ( 512 - 22 ));
  7.         System.out.println("512 × 22 = " + ( 512 * 22 ));
  8.         System.out.println("512 / 22 = " + ( 512 / 22 ));
  9.         System.out.println("512 を 22 で割った余り " + ( 512 % 22 ));
  10.     }
  11. }

足し引き算は特に問題無いと思います。
(見たままですしね)
掛け算と割り算が、* / になってます。
割った余り算というのが、プログラムならではかもしれません。
計算記号は % ですね。

実行結果に関して、割り算だけ疑問かも知れませんが、まぁそこは次回やるとしてw

本日のまとめ

  • プログラムは「class(クラス)」という単位で動いてる
  • プログラム実行時には main を実行する
  • クラスもメインも、{ } で範囲指定が必要
  • System.out.println(”"); を使えば表示ができる。
  • 改行、半角スペース等は結構自由に入れられる。
  • 改行、半角スペースを使って、インデントすると、コードが整理される
  • 足し算引き算掛け算割り算(四則計算)と、割った余り算ができる

[Java入門]初心者がJava言語を覚えてみる(コンパイル)

コレまでの内容

  1. [Java入門]初心者がJava言語を覚えてみる(準備)

前回、Javaのインストールをやってもらったので、
今回から実際にJavaでプログラムを書こうと思う。

とりあえず気合入れていくか~
ヾ( ゚д゚)ノ゛ハァァァァァ・・・・・・・!

わたしが訓練教官の響先任軍曹である
話しかけられたとき以外は口を開くな
口でクソたれる前と後に“サー”と言え
分かったか、ウジ虫ども!

貴様ら雌豚どもが俺の勉強に生き残れたら―――
各人が職人となる プログラムに祈りを捧げるコードの司祭だ
その日まではウジ虫だ! 地球上で最下等の生命体だ

分かったか!!

ふざけるな! 大声だせ!

んじゃ早速プログラム、、、、


でもその前に

そもそもプログラム言語って何よ?って話をしようと思う。
パソコンは結構なんでもやってくれるし、色んなことができる。
パソコンと一括りで考えれば違和感は無いのでが、実はこれ、
パソコンの細かいパーツをそれぞれ動かして成り立っている。

パッと見、ディスプレイ、キーボード、マウス、本体。
本体の中では、CPU やら、メモリやら、とにかく色んなパーツが協力して動いている。

そして、このパーツ達、、、0 か 1 って言語しか理解できない(苦笑
で、そんな 0 と 1 を見ても僕らが理解できない(;・∀・)

そこで、その間を取った言語が、プログラム言語である。
人間に読みやすい、、、とは言えないが、我慢できなくない言語だ。

で、この言語は勿論 0 , 1 の言語(機械語)じゃ無いので、
コンパイラというプログラム(ソフト)を使って、機械語に翻訳する。
この翻訳作業のことを、コンパイルという。

ということで、今回は、コンパイルまでの基本的な手順をやっていこうと思う。


初のプログラム

最初に目的を決めておく(仕様とか言うらしい)。

今回は、コンパイルすることを覚えるのが目的なので、目標は簡単に、
「何か喋らせてみた」
と文字を表示させるだけにしておこうと思う。

え?何だって?それじゃゲームなんていつになったら作れるんだよって?
心配するな。これだってプログラマ共が通った道だ
そして、職人の仕事が素人に出来ると思うんじゃない!

基本的に、プログラムというのはテキストファイルなので、「メモ帳」で書けます。
ほぼ全てのプログラム言語は「メモ帳」で記述できます!

って、、、、「メモ帳(Notepad)」ってソフト知らない?(;・∀・)
「スタート」→「全てのプログラム」→「アクセサリ」→「メモ帳」
で起動できるWindowsデフォルトのテキストエディタなんだけど、、、

まぁいいや、それでも出来るって話で(--;
良く使われるのは TeraPad とかいうテキストエディタ。
一応もっと優秀なエディタはあるけど、勉強にならんから却下!

起動画面はこんなカンジ

起動したら、メニューから、「表示」→「編集モード」→「Java」 を選択しよう。
Javaのプログラムを見やすく着色してくれる設定である。

早速以下のコードを打ち込んでみよう。

  1. public class StudyCompile {
  2.     public static void main (