Java独学ノート/その2:変数・配列の使用と計算 - long wood bow @ ウィキ

この内容を学ぶ前に...

やっていくと、コードの中にメモ書きをしたい時っていうのが出てくると思います。
というか、長いコードについて解説する上でこちらもコードに直接メモ書きしたいのですが、普通に文字列を入力すると、コンパイラが読み間違えてコンパイルエラーを起こします。
その時に使うのがコメントです。
以下の書き方が存在します。

//ここから行の最後まではコンパイラが無視するのでメモ書きできる

/*ここから
コメント扱いされるので
終端まで何を書いても大丈夫
終端はこれ→*/

/**これは
上記のように範囲内がコメントになるが
アスタリスクが2つだと、JDKの機能の一つ、javadocでコードの説明として表示される
一人でプログラミングする分にはおそらく使わない...
終端のアスタリスクは1つでOK、コメントはここまで→*/

変数を作る

変数の宣言をする

変数・・・といえば算数の授業でやったと思います。現時点で分からない数や、状況によって変わる数をxに置き換えて式を作り、両端を足したり掛けたりしてその数自体、もしくは他の変数との関わり(V=IRとか)を解き明かすのに使いますね。
プログラミングでの変数は、変数の中に数字だけでなく文字などの情報が入ります。
変数自体に種類があり、それらはよく形状の違う箱に例えられます。
では、実際に変数を使ってみましょう、次のコードを見てください。

public class Math0
{
 public static void main(String[] args)
 {
  int a;
  System.out.println(a);
 }
}

5行目のint a;で、aという名前のint型の変数が作られました。
int型というのは、整数を入れることのできる変数の事で、少数や文字列は入れられません。型というのはいわゆる箱の形状で、どんなものが入れられるかを表していますが、他の型は後ほど紹介します。
今回aという変数名を使ってますが、これは基本的に半角の英字か英字+数字がルールですが、英字と数字だけを使った名前であればどんな変数名でも大丈夫です。全角文字も使って大丈夫ですが推奨しません。あと、変数名に半角スペース、括弧や数字だけの名前は使えません。
また、予約語といって今のところ出てきたpublic、classなどその単語自体が特別な効果を持つ単語はそのまま変数名には使えません。メモ書きに予約語を書いておきます。
次に6行目、System.out.printlnの括弧の中が二重引用符"で囲まれていません。この二重引用符、その値がどんな特徴を持つか(aaなら変数、"aa"なら文字列など)を表す記号です。
これも後ほど紹介しますが、今のところは二重引用符で囲まれてない数字は数値、文字列は変数として扱われると思ってください。
System.out.printlnは括弧の中の数値や文字列などを画面に表示しますが、変数を入れると、変数の中に入っている数値や文字列を表示します。
しかしこのコード、コンパイルしようとすると(するときはclassの後の言葉、ここではMath0と書いてください(*1))エラーになります。
｢変数aは初期化されいない可能性があります｣というエラーが出てくると思います。なぜなら、まだ変数aの中には何も入ってないからです。

変数の初期化・上書き

では、この変数の中に数値を入れましょう。次のコードを見てください。

public class Math1
{
 public static void main(String[] args)
 {
  int a;
  a = 10;
  System.out.println(a);
 }
}

5行目、a = 10;という部分でint型の変数aに10という整数が入りました。次の行で、aの中に入っているものを画面に表示します。
これをコンパイルした後起動すると、10という数字が出て終わるはずです。
aは変数ですよね。=は演算子というものの一種で、右にある数値や文字などを左の変数に入れるという役割をしています。
この文だと、10という数値を変数aに入れるという意味になるので、他の数値を入れて試してみてください。それをコンパイルして起動すると、その数が出てくるはずです(*2)。
変数に情報を入れることを代入と言いますが、特に何も入っていない変数に値を入れることを特に初期化と言います。

変数は必ず初期化してから使うのですが、変数の作成と初期化を1行で行う事ができます。
=は左にある変数に右の変数を入れる性質を持ちますが、変数を作る宣言をする文に=でつなげて値(計算式もok)を書くことで変数の作成と初期化を同時にする事ができます。
以下はMath1と同じ処理がされるコードです。

public crass Math2
{
 public static void main(String[] args)
 {
  int a = 10;
  System.out.println(a);
 }
}

ところで、次の場合はどうなるでしょう。

public class Math3
{
 public static void main(String[] args)
 {
  int a;
  a = 5;
  System.out.println(a);
  a = 10;
  System.out.println(a);
 }
}

これの実行結果はこうなります。

5
10

とりあえずこれを先にお教えしましょう、Javaは上から下へ書いてある事を順に実行していきます。
なので、これを上から翻訳していくと、

1. 変数aという箱を作る
2. 変数aに数値5を入れる
3. 変数aの中の数値を画面に出力する
4. 変数aに数値10を入れる
5. 変数aの中の数値を画面に出力する

となります。しかしこの翻訳だと疑問がわきます。なぜ5が入ってる箱に10を入れたら15ではなく10になるのか。
これは、=が代入演算子であるからです。代入って覚えてますか?変数を(実際の数値が分かったため)実際の数値に置き換える事です。
リストの2でaを5と置き換えられるようにしたのを、4でaを10と置き換えられるようにする、箱の中を=の右の値と同じにする、等式を作るといえばどれかでピンと来るかと思います。
なので、今まで｢入れる｣と言っていましたが、それは一度も値を変化させないときはそう考えれば大丈夫という話で、=は左の変数に右の数値(もしくは変数の中身の値)を代入、つまり上書きを行う事を意味します。

型とリテラル

型は以下に示す物が主に使われます。

型	入れられる情報	リテラル
byte	1バイトの整数	整数
short	2バイトの整数
int	4バイトの整数
long	8バイトの整数	整数+L(l)
float	浮動小数点(点以下7桁)	小数+F(f)
double	倍精度の浮動小数点(点以下16桁)	小数
boolean	真偽値	true false
char	文字	引用符'(shift+7)で囲む
String	文字列	二重引用符"(shift+2)で囲む

1バイトは2進数の一ケタ(0~1)を表す事のできるビットが8つあり、2の8乗である256の数字、0から始めれば0~255を表現可能なのですが、
どの数も1ビットを使って負の数を表現できるようにしてます。その分最大桁数、2進数の1桁が使えなくなり半分(2分の1)になります。
256の半分は128、byteの使用可能な数値の限界は127~-128になります。127~0で128、-1~-128で128で合計256の数字を使えます。
この負の数の方が1多いというのは整数型4種に当てはまります。

リテラルは、数字や文字列などの値の事を表します。表記の仕方によって、それがどんな値かが変わります(trueなら真偽値、"true"は文字列など)。
変数には、同じ型のリテラルしか入れられません。しかし数の場合は例外があり、byte<short<int<long<float<doubleと数が大きくなるこの種の型に、それ以下の大きさの型のリテラルを入れる(longにL(l)の付いてない整数など)事が可能です。
ただし、その際に変数の型と同じ型のリテラルになります。変数の値をそのまま他の変数に代入する時にそのままではできなくなる(int型をdouble型変数に入れてそれをint型変数に代入など)といった事が起こります。
これはキャストという方法でどうにかなりますが、それは代入演算子の所でやります。
ちなみに、float型やdouble型は小数点以上の数もlongと同程度のケタを扱えます。なのでlong型のリテラルをfloatやdoubleに入れることが可能です。もちろんlong型+小数点以下のケタを扱うので、long型よりメモリを多く食います。
実際、大規模なプログラムでもbyteやshort、floatを使わないとメモリを多く食うといった事はまずありません。
特にint型はコンピュータによってはbyteやshortより処理が早かったりするので、基本整数はint、少数はdoubleを使えば問題ありません。

数値のリテラルは、半角のアンダースコアで区切る事でケタ数を分かりやすくする事ができます。
例)123_456_789、1234_5678など
このアンダースコアの間隔にルールはありません。ただし、リテラルの性質を表す文字と数字を切り離したり(1._234_fなど)、アンダースコアを複数並べる事(1___2など)はできません。
また、先頭に0xをつけると16進数、0をつけると8進数、0bをつけると2進数として扱われます。
例)0xFF→(10進数の)255、010→8、0b100→8など

よく精度が低いといわれるJavaの小数ですが、これは通常の場合ケタを超える数は切り上げか切り捨てになり、それが積み重なると誤差が大きくなるだけで、循環しない小数になる割り算なら精度は気になりません。
しかし、一番大きい位が小数点から4つほど離れると特有の表示方法になる他、0でない桁数の範囲が大きくなると一番大きい位から16ケタより下の位は精度が鈍ります。
この小数型の性質はメモ書きに検証したものを書いておきます。
余談になりますが、循環しない小数にするには、両端を約分した後、分母が、素数が2と5だけで構成される数になれば割り切れます。

boolean型ですが、その状態と、その反対の状態がある(ステージの中間地点を通過したかしてないかなど)時に使えますが、これは3つ以上の状態がある(キャラクターの属性など)時は整数型の方が良かったり、情報としては割りと使いにくかったりします。
しかし、この真偽値、条件によって分岐や繰り返しを行う文法をやる上で重要な型だったりします。

char型ですが、これは文字を整数の数値として扱っているので、足し算や引き算をしたりすると違う文字になったりします(メモ書きで詳しく解説します)。
リテラルを表す記号として引用符'を使うので、char型の変数に引用符を入れたい場合はエスケープ文字を使う必要があります、二重引用符"はそのままでもエスケープ文字でもエラーを起こしません。
正直使う事はほとんど無いのですが、これを使うAPI(詳しくはその7で)があったりします。

エスケープ文字は、\(*3)の後に特定の文字を入れる事で、特殊な文字やそのままだとリテラルの終点扱いになってしまう文字を入力するのに使います。
これは覚えとくと良いのは4種類あり、\"(文中の"として扱われる)、\'(文中の'として扱われる)、\\(文中の\として扱われる)、\n(改行する(*4))があります。他にもあるのでメモ書きに書いておきます。

String型はint型並みに多く使われる変数です。この型だけ最初が大文字な理由なのですが、これにはオブジェクト指向の知識が必要になるのでその時お教えします。
このString型、理由があって他の型と性質の違いがあったりします。主に代入した時に影響が出たりします。
char型に対し、こちらは二重引用符"を文中に使う際にエスケープ文字が必要で、引用符'を使う時はエスケープ文字であっても無くても大丈夫です。

複数の変数を定義

これは知らなくても問題は無いのですが、使う人もいるので合わせて覚えておきましょう。

public class Math4
{
 public static void main(String[] args)
 {
  int a, b;
  a = 1;
  b = 10;
  System.out.println(a);
  System.out.println(b);
 }
}

5行目、aとbという2つの変数を定義しています。それ以降は数を代入して表示という今までと同じ事をしていますね。もちろん実行結果はこうなります。

1
10

また、宣言と同時に初期化も可能です。以下は上記のコードと同じ実行結果になります。
aの後の" = 1"を消すと初期化されないのでコンパイルエラーになります。最後の" = 10"でまとめて初期化される訳ではありません。

public class Math5
{
 public static void main(String[] args)
 {
  int a = 1, b = 10;
  System.out.println(a);
  System.out.println(b);
 }
}

この変数宣言と代入、つまり変数宣言する上で,で区切られた部分は、その中が解決してから次の区切りの部分を行います。
つまり、こんな芸当もできます。使う事は多分無いと思いますが...
これも上記と同じ実行結果になります。

public class Math6
{
 public static void main(String[] args)
 {
  int a = 2 - 1, b = a + 9;//+は左右の数を足す、詳しくは後術
  System.out.println(a);
  System.out.println(b);
 }
}

以下はコンパイルエラーになる一例です。

public class Math7
{
 public static void main(String[] args)
 {
  int a = b, b = 10;//左から処理しているので、bがまだ宣言されてないのにbを使おうとしている

  int c, d = 10//全部10にしてくれるわけでは無いので次の文でコンパイルエラー
  System.out.println(c);

  int e = 2;
  int f = 1, e = f;//すでに宣言された変数eをまた宣言しようとしている
 }
}

演算子

計算を行う演算子

単に箱に情報を入れて表示するだけでは意味が無いですね。ってことなので算術演算子と呼ばれる演算子の一種を使ってみましょう。
先に言っておきますと、変数やリテラル、要するに演算子以外の計算に関わっているものをオペランドと言います。
もっとも単純なものを以下に表記しておきます。

表記	効果
+	(この演算子の)左にあるオペランドに、右のオペランドを足す
-	左にあるオペランドから、右のオペランドを引く
*	左にあるオペランドを、右のオペランドで掛ける
/	左にあるオペランドを、右のオペランドで割る
%	左にあるオペランドを、右のオペランドで割った余り(整数同士の計算専用)

また、+は文字列(String型)同士で計算する事が可能で、そうすると、左にあるオペランドの最後に、右のオペランドを繋げた文字列にします。
これをどう使うかをふまえ、以下のコードを見てみましょう。

public class Math8{
 public static void main(String[] args)
 {
  int a = 10 + 3;
  int b = 10 - 3;
  int c = 10 * 3;
  int d = 10 / 3;
  int e = 10 / 3;
  String f = "文字列を" + "つなげる";
  System.out.println(a);
  System.out.println(b);
  System.out.println(c);
  System.out.println(d);
  System.out.println(e);
  System.out.println(f);
 }
}

このコードの実行結果は以下のようになります。

13
7
30
3
1
文字列をつなげる

10 / 3は3になりました。このように、整数型の割り算は、小数点以下は切り捨てるようになっています。
計算に変数を使う事もできますが、これは評価のところでやります。複雑な計算をする時のやり方(1+2*3など)もそちらでやります。

計算の順番(評価)

演算子を多く使った計算や計算に変数を使うとどうなるのか、たとえば、以下の計算結果はどうなるでしょうか。

a = 1 - 2 + 6 / 2

このような計算を、コンピュータは一つ一つの演算子を1つずつ行い、演算子と両端のオペランドを計算結果のリテラルに変化させ、その上でオペランド2つと演算子のトリオを見つけて計算します。このトリオを1つのリテラルにすることを評価と言います。
演算子には1~15の評価の優先度が決まっており、少ないほどその演算子による演算は優先されます。今の所は、掛け算割り算と余り算、足し算引き算、代入の順で優先度が高いと覚えておきましょう。
で、まずこの式のどこを評価するかというと、この中でもっとも優先度の高い演算子である/と、その両端の6と2を評価します。
この演算子は左のオペランドを右のオペランドで割るので、計算結果は3です。6 / 2が3になり、以下の式と同等になります。

a = 1 - 2 + 3

この6 / 2が3になるような事を評価というわけです。次は、次に優先度の高い演算子である-と+が評価されるわけですが、これはどう評価されるでしょうか。
これには法則があって、同じ優先度の演算子は同じ方向に評価され、同じ優先度の演算子が並んだ場合、その方向の順番で評価されていきます。
足し算などの優先度と掛け算などの優先度の演算子は左から右に評価されます。なので、以下のように評価されていきます(括弧は評価される部分)

a = (1 - 2) + 3 ⇒ a = -1 + 3
a = (-1 + 3) ⇒ a = 2

そして最後に代入演算子によりaに2が代入されます。

式の中に変数を使う事もできますが、この場合、評価していく上で都合の良いリテラルに変化させるという仕組みが作動します。これをふまえて以下の式を見てみましょう。

a(int型の変数で10が入っている) = a + 10

まず最も優先度の高い+とその両端のオペランドを評価する訳ですが、算術演算子によって評価する際には、両端がリテラルである必要があります。
なので、算術演算子を評価する際に変数を巻き込む場合、変数がその中身の値と同じリテラルに変化します。
その結果右のaが10に変化して、式は以下と同等になります。

a = 10 + 10

そして10 + 10が評価されて式は以下と同等になります。

a = 20

そしてaに20が代入されます。

代入演算子は左に変数、右にリテラルがあると、左の変数に右のリテラルを代入するという演算子ですが、この演算子は右から左に評価されます。なので、

a = b = 1

これだとまず最初にb = 1が評価されてbに1が代入されます。
次にa = bを評価するわけなのですが、右はリテラルでないといけないので、bが中身の1というリテラルに変化します。なので、

a = 1

このような式と同等になるわけです。

都合の良いオペランドに変化させるという仕組みは異種の型のリテラルが演算子の両端に来たときにも発生する事なのですが、これはString>double>float>long>小さい整数という優先順位で変化していきます。次の式を見ていきましょう。

100 + 900l + 1000 + 200.0f + 800.0 + "点" + 30 + 70

まず、+は左から右に評価されるので100 + 900lが評価されます。
左はint、右はlong型のリテラルなので都合が悪いですね。この時、int型のリテラル100は、long型よりも小さい整数なのでlong型に変化します。つまり100lになるわけですね。
結果この時点でできるリテラルは1000l、long型の1000です。つまり、現時点ではこうなります。

1000l + 1000 + 200.0f + 800.0 + "点" + 30 + 70

次は1000l + 1000ですが、左から右へと評価してint型の2000となると思う人もいるかもしれません。この評価の結果は2000l、long型ですね。左右は関係なく、どちらが優先順位が高いかによって型は決まります。よってこれで式はこの状態になります。

2000l + 200.0f + 800.0 + "点" + 30 + 70

後は2000l(long) + 200.0f(float)が2200.0f(float)、2200.0f(float) + 800.0(double)が3000.0(double)になるのは分かると思います。
これまでの結果、式はこうなります。

3000.0 + "点" + 30 + 70

次は3000.0 + "点"ですが、優先順位の高いのは文字列のほうです。文字列の足し算は左に右をつなげるんでしたよね。なので式はこうなります。

"3000.0点" + 30 + 70

その後の30と70ですが、これは順を追って評価すると以下のようになるはずです。

"3000.0点30" + 70
"3000.0点3070"

100 + 900l + 1000 + 200.0f + 800.0 + "点" + 30 + 70が"3000.0点3070"になりました。皆さん理解できたでしょうか。

上記の性質を理解したうえでこの式を見てください。

3 / 2 + 3.5
3 / 2.0 + 3.5

上は整数同士の割り算で、3 / 2が余り算の答えである1になり、結果4.5になります。
下は小数の計算になるため3 / 2.0が1.5になり、結果5.0になります。

二つ上の式で、評価の結果を"3000.0点100"にしたい、つまり30 + 70を計算させたいときはどうしたら良いでしょうか。
ここで使うのが括弧()です。括弧内の最も優先度の高い演算子を優先して評価し、括弧の中で1つのリテラルができるまで評価します。
なので、以下のようにすれば"3000.0点100"という結果になります。

100 + 900l + 1000 + 200.0f + 800.0 + "点" + (30 + 70)

括弧には親子関係があり、中の括弧ほど優先されます。優先度の高い演算子が優先されるということも含めて、この式を見てください。

3 - ((1 + 2 * 3) * (4 / 5.0 * 6))

まず、二重に囲われている、左側を評価してみましょう。2 * 3が先に評価されて6、1 + 6で7なので式は以下のようになります。

3 - (7 * (4 / 5.0 * 6))

次に右側を評価してみましょう。4 / 5.0が2.5(ついでに型の代わり方も見てみまましょうか)、2.5 * 6が15.0なので式は以下のようになります。

3 - (7 * 15.0)

その後はカッコ内が優先され以下のようになります。

3 - 105.0
-102.0

代入を行う演算子

代入を行う演算子、これは基本=ですが、=の前に基本演算子を付ける事で、a = a + 1のような式をa += 1という形で表現できます。
以下に演算子のリストを表記します。

表記	効果
=	右のリテラルを左の変数に代入する (左の変数の中身を右のリテラルにする)
+=	右のリテラルと左の変数を足してその値を左の変数に代入する String型の場合、左の変数の最後尾に右のリテラルの内容をつなげて左の変数に代入する
-=	右のリテラルと左の変数を引いてその値を左の変数に代入する
*=	右のリテラルと左の変数を掛けてその値を左の変数に代入する
/=	右のリテラルと左の変数を割ってその値を左の変数に代入する
%=	右の整数のリテラルと左の整数の変数を割ってその余りを左の変数に代入する

この代入演算子、左の変数が右のリテラルよりも大きい型でないといけません。たとえばint型の変数にlong型やdouble型のリテラルを代入させようとすると、たとえint型の範囲の整数でも精度が落ちる可能性を指摘してコンパイルさせてもらえません。
その時使うのがキャスト演算子です。
これは括弧()の中に型名を入れると機能します。

例) a = (int) 1.5

この機能、リテラルがString型だと基本型とは違う性質の関係でキャストできません。また、小数から整数にキャストする場合、小数点以下は切り捨てられます。この場合、aには1が代入されます。
ちなみにキャスト演算子は*や/よりも優先度が高いです。なので、以下の式ではコンパイルエラーになります。

a(int型) = (int) 100 * 1.05

この時、キャスト演算子は100をキャストしてint型にします。なので結局aには100 * 1.05でできるdouble型のリテラルが入れられようとされます。
なので、括弧()を使ってキャスト演算子の後に続く式の優先度を上げましょう。

a = (int) (100 * 1.05)

これで100 * 1.05が優先されて評価され、その値をint型にキャスト、aにその値が入るようになります。

キャスト、というよりはString型の注意点として、基本データ型は、キャストで他の型からString型、逆にString型から他の型に変化させる事ができません。これはオブジェクト指向の考え方が必要になるのでその時お伝えしますが、こう変化させる方法は存在します。

また、単純に数値型の変数に1追加したいときはインクリメント演算子を使うと良いです。逆に1減らすデクリメント演算子も存在します。
a++とするとa = a + 1やa += 1と同じ意味に、a--とするとa = a - 1やa -= 1と同じ意味になります。
式の途中に使うと変な動きをするので、メモ書きに性質を詳しく書いておきますが、基本は単体で使用することが推奨されています。

public class Math9
{
 public static void main(String[] args)
 {
  int a = 1;
  a++;
  System.out.println(a);
  a--;
  System.out.println(a);
 }
}

このコードの実行結果はこうなるはずです。

2
1

trueかfalseに変化する演算子

この関係演算子、基本は条件分岐や繰り返しの条件を表すのに使います。
これ自体の効果は、左右にあるオペランドの関係によってtrueかfalseに変化します。
優先度は*や+といった算術演算子より低く、=といった代入演算子より高いです。
以下に演算子のリストを表記します。

表記	効果
==	(右と左のリテラルが) 等しいときtrue、違うときはfalseに変化する
!=	違うときtrue、等しいときはfalseに変化する
>	(右より、左のリテラルが) 大きいときはtrue、等しいか小さいときはfalseに変化する
<	小さいときはtrue、等しいか大きいときはfalseに変化する
>=	大きいか等しいときはtrue、小さいときはfalseに変化する
<=	小さいか等しいときはtrue、大きいときはfalseに変化する

関係演算子は=が二つである事は覚えておきましょう。
また、+=などと同じように、=の前に記号を入れると特殊な性質を持ち、後に入れるとコンパイルエラーになる事はよく覚えておきましょう。順番は覚え間違いやすいです。

この使い方や評価のされ方を見てみましょう。
たとえば以下の式の場合はどうでしょうか。

a(boolean型) = 1 + 2 == b

この場合、まず代入演算子や関係演算子より優先度の高い算術演算子が評価され、1 + 2が3になり、式は以下と同等になります。

a = 3 == b

このbに入っている値が3と同等であればtrue、そうでなければfalseです。言うまでも無く、bがString型など3とは違う型の変数やリテラルであればfalseです。これがtrueになった場合は式はこうなります。

a = true

そしてaにtrueかfalseが入ります。

両方が違う数値型である場合、算術演算子と同様に小さいほうの方を大きいほうの型に変化させて比較します。

例)3.2 == 3は3.2 == 3.0として見られる

char型は数値で文字を表すので数値型と==などの関係演算子で比較する事ができます。使う事は無いと思いますが。
boolean型は言うまでも無くboolean型以外とは比較できません。
String型は基本データ型とは違う性質を持つ関係で==などの関係演算子では比較できません。しかし、オブジェクト指向の関係で、以下の文を書くことで、中に値を持つ変数が式の途中で中の値に変化するように、この文自体がtrueかfalseに変化します。

a.equals(b)
※a:比較されるString型のリテラル、変数 b:比較するString型のリテラル、変数

String型以外と比べようとすると、どう合っていても結果がfalseになります。
String型以外と比べる場合は、比べるものに+ ""を最後につけて、何も無い文字列と足し合わせるという形でString型にしましょう。

例) c(int型) + ""は可、(String)cはコンパイルエラーになるので不可
例) a(String型)とb(int型)を比べる場合、a.equals(b + "")

関係演算子は算術演算子同様、左から右に評価されます。そのため、

1 == 1 == true

これはint型とint型が比較されてboolean型になった後、そのboolean型とboolean型が比較されるので大丈夫ですが、

true == 1 == 1

これは最初にboolean型とint型が比較されるのでコンパイルエラーになります。

論理演算子は、NOT、AND、OR回路のようにboolean型の変数(やリテラル)を比較したり、変化させる演算子です。
NOTとして!、ANDとして&&、ORとして||(Shift+キーボード一番右上2回)があります。
!はその右にあるboolean型の変数、リテラルを反転させます(!true⇒false、!false⇒true)。
この!、==など関係演算子よりも優先度が高いので、

!a.equals(c) !b(boolean型変数) !b == true

これらなどは大丈夫で

!a(int型変数) == 1

これらなどはコンパイルエラーになります。なので、ここは式の優先度を上げる括弧を使って

!(a == 1)

とすれば正常に機能します。
&&は、両端にあるboolean型の変数やリテラルの両方がtrueならtrue、片方でもfalseならfalseと評価します。
||は、両端にあるboolean型の変数やリテラルの片方でもtrueならtrue、両方がfalseならfalseと評価します。
この2つは、関係演算子よりも優先度が低く、代入演算子よりも高いです。

例) a(boolean型変数) = true && 1 + 1 == 2
a = true && (1 + 1) == 2 ⇒a = true && 2 == 2
a = true && (2 == 2) ⇒a = true && true
a = (true && true)
a = true

また、算術演算子同様左から右に評価されます。

例) true || true && false
(true || true) && false ⇒ true && false
(true && false) ⇒ false

ちなみに、この場合右から左だとtrueになります。

実際、式の中でこの関係演算子を使う事はあまりありません。その3で使うので、そのときに見直す程度で良いです。

配列

配列の目的

配列は、同じ型のデータを、添え字と呼ばれるIDのような番号で管理できる変数の集合体のようなものです。一つ一つの変数の事を要素と言います。
このような変数の集合体をデータ構造と呼び、Javaには他の種類のデータ構造も存在します。
この配列の利点として、

• 1つずつ変数の名称を指定して必要な分変数を作る今までに対し、｢○個の要素を持つ配列を作る｣と宣言するだけで必要な数の変数が出来上がる
• 添え字を変数で指定できるので、いわゆるIDのような感じで情報を呼び出せる
  • これを使えば違う型の配列でも、ID0の名称(文字列)と得点(数値)、ID1の名称と得点と言うように、どの人や物体の情報かを数字で指定することで情報を管理しやすくできる
• その3で学習する繰り返しを使う事で、配列のそれぞれの要素に同じ操作を同時に行う事ができる
  • 条件分岐を使えば30以下の数値の入った要素には5を追加するなど特定の要素のみ操作する事も可能

このように、共通点を持った複数の変数を1つの配列として扱う事で特に管理がしやすいという利点を得る事が可能です。

配列の使い方・生成

では実際に配列を使っていきましょう。しかし、いままでの変数とは扱い方が少し違います。
いままでは変数という箱を作るという宣言をし、その箱に値を代入して使っていきました。
しかし配列は、以下の順序で作ります。

1. 配列の入る変数(=配列自体が1つ入る箱)を作る
2. 要素の集まりである配列自体を作成し、上記の配列の入る変数に入れる(箱に配列が入る、ボックスinボックス的な感じ)
3. 変数に対して配列の要素に値を入れる宣言をする

このように配列は専用の変数の中に配列があって、その配列の要素の中に値を入れるという、変数より一重かぶさった形をしています。

実際に作って使ってみましょう。
配列を入れる変数は以下のように定義します。

型[] 変数名;
例)int[] array;

これはこちらの書き方でもできますが、公式的には上記の書き方を通常としているようです。

型 変数名[];
例)int array[];

例の場合、これでint型の変数の情報群である配列を入れられる変数が定義されました。
次、配列自体を作成し、変数の中に入れる方法ですが、都合上これは同時に行う必要があります。

変数名 = new 型[要素の数];
例)array = new int[10];

配列を入れる変数を定義する際、下の方の書き方をした場合、変数名[]とは書かず変数名だけを書いてください。

例)int array[];
array = new int[10];

newというのは+や=と同じ演算子の一種で、これはメモリの中にデータ構造を作る事を意味しています。これはオブジェクト指向をやる上でも使うので、次項で認識を深めておきましょう。
例の場合、これにより、変数にはint型の10個のデータを入れられる配列が入りました。
変数の宣言と配列自体の作成、代入は通常の変数同様、一まとめにできます。

型[] 変数名 = new 型[要素の数];
例)int[] array = new int[10];
型 変数名[] = new 型[要素の数];
例)int array[] = new int[10];

最後、要素に値を入れる方法ですが、この時注意してもらいたいのは、配列の要素の添え字は0から始まる事です。10個の要素を持つ配列を作ると0~9の添え字を持つ要素が作られ、添え字10の要素を使おうとすると、実際にjavaで起動した際にエラーになります(これは例外というエラーです、その7で教えます)。
以下がやり方と例です。

変数名[要素の添え字] = 入れる値;
例)array[0] = 2;

=は代入演算子なので、変数と同様右側で計算などをしても問題なく代入できます。

例)a = 1 + 1;(aに2が入る)
a[0] = 1 + 1;(aの中の配列の1つ目の要素に2が入る)

使用する際ですが、上記の式の左辺を見てください。通常の変数名が書かれた部分と配列の入った変数名[要素の添え字]が同じように機能しています。
配列の中の値を使用する際は、変数がその中身自体のリテラルに変化するように、変数名[添え字]と書くと、配列の中の、その添え字の要素の中身のリテラルに変化します。

a=2、bの要素0=1、要素1=3の場合
例)a = a + 1;⇒a=3
b[0] = b[1] + 1;⇒b[0]=4
例)System.out.println(a);⇒2と表示される
System.out.println(b[1]);⇒3と表示される

とりあえずこの時点での配列の使い方をしたソースコードを見てみましょうか。

public class ArrayTest0
{
 public static void main(String[] args){
  int[] array = new int[3];
  array[0] = 3;
  array[1] = array[0] + 2
  array[2] = array[1] + 1
  System.out.println(array[0]);
  System.out.println(array[1]);
  System.out.println(array[2]);
 }
}

このコードの実行結果は以下になります。

3
5
6

最初に記載した配列の利点のように、添え字には整数型の変数が使えます。上記と同じ動きをするコードを記載しておきますが、これはその3の条件分岐や繰り返しがあってこそ効果があるものだったりするので、そちらでもっと詳しくやります。

public class ArrayTest1
{
 public static void main(String[] args){
  int[] array = new int[3];
  int i = 0;
  array[i] = 3;
  i++;
  array[i] = array[i-1] + 2;
  i++;
  array[i] = array[i-1] + 1;
  i = 0;
  System.out.println(array[i]);
  i++;
  System.out.println(array[i]);
  i++;
  System.out.println(array[i]);
 }
}

配列は初期化しなくてもあらかじめデフォルトの情報が入っています。
数値は0、文字は半角スペース(数値的には0)、真偽値はfalse、文字列はnullと入っています。

最初から入れる値が分かっている時、初期化の方法を知っておくと便利です。上記ソースコードを見ると分かるように、これを使わないと1文ずつ値を代入する文を書く必要が出てしまいます。

public class ArrayTest2
{
 public static void main(String[] args)
 {
  int[] array = {1, 2, 3, 4, 5};
  System.out.println(array[0]);
  System.out.println(array[1]);
  System.out.println(array[2]);
  System.out.println(array[3]);
  System.out.println(array[4]);
 }
}

実行結果は以下になります。

1
2
3
4
5

この、数学用語でいう中括弧で配列の中身を指定する方法は、初期化の時しか使えません。以下のコードはコンパイルエラーになります。

public class ArrayTest3
{
 public static void main(String[] args)
 {
  int[] array = {1, 2, 3};
  System.out.println(array[0] + " " + array[1] + " " + array [2]);//ここまでで止めれば1 2 3と画面に表示される
  array = {4, 5, 6};//この方法で中身をまとめて変える事は不可能(コンパイルエラーになる)
  System.out.println(array[0] + " " + array[1] + " " + array [2]);
 }
}

多次元配列

多次元配列は、要素を表す添え字が複数存在する配列です。
2つ添え字が存在するものは二次元配列とも呼ばれます。次元の数字は添え字の数です。
これはコードを見た方が早いかもしれません。

public class ArrayTest4
{
 public static void main(String[] args)
 {
  //1つ目の添え字はキャラのID、2つ目の添え字は0から体力、攻撃力、防御力
  int[][] characterData = new int[4][3];
  characterData[0][0] = 100;//一人目の体力
  characterData[0][1] = 20;//一人目の攻撃力
  characterData[0][2] = 10;//一人目の防御力

  //int[4][3]はint[3]の配列が4つ並ぶ配列とも見れる
  int[] character2Data = new int[3];//二人目のステータスを一次元配列として作る
  character2Data[0] = 90;
  character2Data[1] = 25;
  character2Data[2] = 10;
  characterData[1] = character2Data;//二人目のステータスを二次元配列に入れる

  int[] character3Data = {120, 15, 5};//三人目のステータスを一次元配列として作る
  characterData[2] = character3Data;//三人目のステータスを二次元配列に入れる

  int[] character4Data = {80, 15, 15};//四人目のステータスを一次元配列として作る
  characterData[3] = character4Data;//四人目のステータスを二次元配列に入れる

  //これはできない模様
  //characterData[3] = {80, 15, 15};//四人目のステータスを直接配列を作って入れる

  int i = 0;
  //一人目
  System.out.println("キャラクター" + (i + 1) + " 体力:" + characterData[i][0] + " 攻撃力:" + characterData[i][1] + " 防御力:" + characterData[i][2]);
  i++;//二人目
  System.out.println("キャラクター" + (i + 1) + " 体力:" + characterData[i][0] + " 攻撃力:" + characterData[i][1] + " 防御力:" + characterData[i][2]);
  i++;//三人目
  System.out.println("キャラクター" + (i + 1) + " 体力:" + characterData[i][0] + " 攻撃力:" + characterData[i][1] + " 防御力:" + characterData[i][2]);
  i++;//四人目
  System.out.println("キャラクター" + (i + 1) + " 体力:" + characterData[i][0] + " 攻撃力:" + characterData[i][1] + " 防御力:" + characterData[i][2]);
 }
}

実行結果は以下のようになるはずです。

キャラクター1 体力:100 攻撃力:20 防御力:10
キャラクター2 体力:90 攻撃力:25 防御力:10
キャラクター3 体力:120 攻撃力:15 防御力:5
キャラクター4 体力:80 攻撃力:15 防御力:15

添え字が3つ以上、三次元以上の多次元配列を作る事もできます。
また、多次元配列を一発で初期化する方法もあります。
ちょっと長いですが、多次元配列の事が一通り分かると思うのでもしよろしければご覧ください。

public class ArrayTest5
{
 public static void main(String[] args)
 {
  //両手の武器を定義、1つ目の添え字が左か右か、2つ目が攻撃力、射程、連射力
  //改行など書き方は人それぞれ、メモ書きに例を書いておきます
  int[][] newCharacter =
  {
   {10, 2, 3},//1次元の配列を","で区切る
   {5, 2, 6}
  };
  System.out.println("新規キャラクター");
  System.out.println("左手武器:攻撃力/" + newCharacter[0][0] + " 射程/" + newCharacter[0][1] + " 連射/" + newCharacter[0][2]);
  System.out.println("右手武器:攻撃力/" + newCharacter[1][0] + " 射程/" + newCharacter[1][1] + " 連射/" + newCharacter[1][2]);
  System.out.println("");//空行を入れる、\nでも良いけど...

  //1つ目の添え字は何人目かで、後は前の配列の添え字を一つずらした感じで2つ目の添え字が左か右か、3つ目が攻撃力、射程、連射力
  //ここはnew int[4][2][3]ってやっても良いが、一つずつ数字を代入するのは面倒なのでそのやり方は省略
  int[][][] party =
  {
   //一人目、添え字は0
   {
    {4, 1, 10},
    {7, 3, 4}
   },//配列の配列も","で区切る
   //二人目
   {
    {2, 5, 8},
    {20, 5, 1}
   },
   //三人目
   {
    {5, 4, 5},
    {6, 4, 4}
   },
   //四人目
   {
    {5, 1, 8},
    {10, 1, 4}
   }
  };
  int i = 0;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);
  i = 1;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);
  i = 2;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);
  i = 3;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);

  System.out.println("");

  //int[][][]はint[][]の配列としても見れる、例に漏れず二次元配列の初期化のように配列を直接作って入れる事は不可能
  party[0] = newCharacter;
  System.out.println("キャラクター1を新規キャラクターと交換しました");
  i = 0;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);
  i = 1;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);
  i = 2;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);
  i = 3;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);

  System.out.println("");

  //int[][][]はint[]の入る二次元配列とも見れる
  int[] newWeapon = {30, 3, 1};
  party[0][1] = newWeapon;
  party[1][1] = newWeapon;
  party[2][1] = newWeapon;
  party[3][1] = newWeapon;
  System.out.println("全キャラクターの右手武器を同じものに交換しました");
  i = 0;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);
  i = 1;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);
  i = 2;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);
  i = 3;
  System.out.println("キャラクター" + (i + 1));
  System.out.println("左手武器:攻撃力/" + party[i][0][0] + " 射程/" + party[i][0][1] + " 連射/" + party[i][0][2]);
  System.out.println("右手武器:攻撃力/" + party[i][1][0] + " 射程/" + party[i][1][1] + " 連射/" + party[i][1][2]);
 }
}

実行結果はこうなります。

新規キャラクター
左手武器:攻撃力/10 射程/2 連射/3
右手武器:攻撃力/5 射程/2 連射/6

キャラクター1
左手武器:攻撃力/4 射程/1 連射/10
右手武器:攻撃力/7 射程/3 連射/4
キャラクター2
左手武器:攻撃力/2 射程/5 連射/8
右手武器:攻撃力/20 射程/5 連射/1
キャラクター3
左手武器:攻撃力/5 射程/4 連射/5
右手武器:攻撃力/6 射程/4 連射/4
キャラクター4
左手武器:攻撃力/5 射程/1 連射/8
右手武器:攻撃力/10 射程/1 連射/4

キャラクター1を新規キャラクターと交換しました
キャラクター1
左手武器:攻撃力/10 射程/2 連射/3
右手武器:攻撃力/5 射程/2 連射/6
キャラクター2
左手武器:攻撃力/2 射程/5 連射/8
右手武器:攻撃力/20 射程/5 連射/1
キャラクター3
左手武器:攻撃力/5 射程/4 連射/5
右手武器:攻撃力/6 射程/4 連射/4
キャラクター4
左手武器:攻撃力/5 射程/1 連射/8
右手武器:攻撃力/10 射程/1 連射/4

全キャラクターの右手武器を同じものに交換しました
キャラクター1
左手武器:攻撃力/10 射程/2 連射/3
右手武器:攻撃力/30 射程/3 連射/1
キャラクター2
左手武器:攻撃力/2 射程/5 連射/8
右手武器:攻撃力/30 射程/3 連射/1
キャラクター3
左手武器:攻撃力/5 射程/4 連射/5
右手武器:攻撃力/30 射程/3 連射/1
キャラクター4
左手武器:攻撃力/5 射程/1 連射/8
右手武器:攻撃力/30 射程/3 連射/1

余談ですが、先ほど配列の宣言の仕方で、int a[]という方法もあると言いました(推奨しませんが)。
その上で、int[] a[][]と書くと三次元の配列が入る変数になります。
つまり型の部分と変数の部分の[]の数の合計の次元の配列が入る変数になります。
出来るというだけで非推奨です。冗談でもやらない方が良いかと思います...

配列の大きさを数字に

これはその3でやる繰り返しなどで主に使うものなのですが、配列を使うと、配列の要素の数を数字として出したい時が出てきます。
その時は、変数の後に.lengthと付けると、それが要素の数のint型のリテラルになります。なのでshort型やbyte型の変数にはそのまま入れられません(やりたいならキャストが必要)。
例えば、new int[10]と入れた変数aがあって、a.lengthと書くと、それが10というint型のリテラルになります。最後の要素の添え字(0から始まる)の9ではなく、要素の数(1から始まる)になるのでちょっと注意が必要かもです。
ちなみにオブジェクト指向をやっていくと、ついつい.length()と括弧を付けそうになるかもしれません。混同しないように注意しましょう。
以下に一例を書いておきます。

public class ArrayTest6
{
 public static void main(String[] args)
 {
  int[] a = new int[10]；//要素が10個の配列を作成
  System.out.println(a.length);//10と表示される

  System.out.println("");//区切り

  int[][][] b = new int[4][2][3];//多次元配列の場合
  System.out.println(b.length);//一つ目の[]の大きさである4と表示される
  System.out.println(b[0].length);//二つ目の[]の大きさである2と表示される、1つ目の添え字がどうだろうと同じとはいえb[].lengthだとコンパイルエラーになるので適当な数字を入れて置くこと
  System.out.println(b[0][0].length);//三つ目の[]の大きさである3と表示される
  System.out.println("bの要素の数の合計は" + (b.length * b[0].length * b[0][0].length));添え字が何通りあるか=要素が何個あるかを計算
 }
}

実行結果はこうなります。

10

4
2
3
bの要素の数の合計は24

配列は参照型

所で、以下のコードは実行するとどうなるでしょうか。

public class ArrayTest7
{
 public static void main(String[] args)
 {
  int a = 0;
  int b = a;
  b++;
  System.out.println(a);
  System.out.println(b);

  int[] c = {0, 0};
  int[] d = c;
  d[0]++;
  System.out.println(c[0]);
  System.out.println(d[0]);
 }
}

前半はbにaの内容を代入、詳しく言えばaがリテラルの0に変化してそれをbに代入して、さらにbだけに数値を1追加しています。つまりaは0のままで、bは1になります。
後半はdにcの内容を代入、さらにdの1つ目の要素に1を追加しています。dは{1, 0}になりますが、cは...
とにかく、実行内容はこちらです。

0
1
1
1

前半は予想通りaとbがそれぞれ0と1になっていることが分かります。
しかし、cとdは、dだけ変更を加えたはずなのに、c[0]も0ではなく1になってしまいました。

これは、あの式で渡した内容は配列の内容ではなく、その配列のデータがコンピュータが作業する上で一時的にデータを置く場所であるRAM(*5)(物理メモリとも)のどこにあるかの情報、分かりやすく例えれば住所を渡しているからです。
つまり、配列が入っている変数は厳密には配列の住所が入っている箱だったのです。このような型を参照型と言います。逆に今までやってきたintなどは基本型、あるいはプリミティブ型と呼ばれています。厳密には、というか一般的なコンピュータ用語で参照型もプリミティブ型の一種なのですが...
ちなみにStringでこのようなこと(前のString型変数を代入した後に後のString型変数の内容を変更する)をやっても前半と同じようになります。リテラルに変化するからなのですが、オブジェクト指向を学ぶとちょっと疑問に思う部分です...それは置いときます。

さて、本来こんな事はやりませんが、こんなコードを実行してみましょう。println()の性質上、char型の配列でやると文字列として表示されてしまうのでご注意を。

public class ArrayTest8
{
 public static void main(String[] args)
 {
  int[] a = {0, 0};
  System.out.println(a);
 }
}

このコードの実行結果は環境などによって変わると思われますが、以下のように何か文字列と@の後に16進数の数が表示されると思います。

[I@5ca881b5

これがaの中に入っているものの正体、@の後の数字がRAM上のどの場所にあるかを示す住所なのです。
ArrayTest6のd = cというのはこの住所を代入しているので、dに変更を加えるとその住所にある配列をいじる事になるので、cを読み込むとdに加えた変更がそちらにも適用されたように見えるという事です。

この参照型は、情報の受け渡しをする上で、膨大なデータを住所という小さい大きさの情報でやり取りができるという利点があります。詳しくはその4でお教えします。

ちなみに、int[]という型はint型の1次元配列が入るっていうだけなので、以下のように元々変数に入っていた配列と要素の数が違う、同じ型の配列を入れる事が可能です。

public class ArrayTest9
{
 public static void main(String[] args)
 {
  int[] a = new int[2];
  int[] b = {1, 2, 3};
  a = b;
  System.out.println(a[0]);
  System.out.println(a[1]);
  System.out.println(a[2]);
 }
}

一応実行結果を書くと以下のようになります。

1
2
3

所で、二次元配列は、一次元配列を要素に持つ一次元配列、つまり配列の配列としても見れる訳ですが、大きさの違う配列を要素として入れる事が出来ます。

例:
int[][] a = {{0,1}, {2, 3, 4}};
int[] b = {5, 6, 7, 8};
a[0] = b;//これでaの中身は{{5, 6, 7, 8},{2, 3, 4}}に

逆を言えば、二次元配列の要素として入ってる配列は、大きさがバラバラでも構わないという事です。

もし同じ要素の新しい配列を作る場合、1つ1つ代入をしなければなりません。
面倒ですが、その3で学ぶ繰り返しを使えばある程度すっきりとした記述が可能です。
配列は一度作ったら大きさを変えられないので、そういう点でも重要そうに見えて、実は好きなように大きさを変えられる配列が存在するので意外と使う事はありません。
それに関してはオブジェクト指向を身に付ける必要がありますが...逆にこのタイプの配列は機能が限られてる分メモリ消費ややる事によっては動作も軽いので、ケチりが癖になってる人は多用するかもしれません...

この性質は、オブジェクト指向をやる上でも関わってくるので、覚えておいて損はありません。

---

これでその2は終わりです。次は、条件分岐や繰り返しというものを使っていきましょう。

---

コメント

指摘や質問等あったらここへ。

---

*1 この理由はその4で説明します

*2 大きすぎるとコンパイルエラーになるので注意してください

*3 ・・・済みません、全部バックスラッシュになってますね。これキーボードの一番右上か右下を押すと出る半角円記号\です。

*4 環境によって例外あり

*5 例えば、今開いているウィンドウの内容をRAMに書き出して、画面に映す上でRAMから読み込んだ情報を使ったり、使わないウィンドウもRAMにデータを置くことで使う時にすぐにデータを取り出して表示したり...Javaではintなどの変数の情報もRAMに一時的に保存されます。