これらプログラムの 実 行 は 普 通 はハードウェア 上 で 行 うのですが Java の 場 合 は 特 殊 なことを 行 っています 難 しい 理 屈 はここでは 説 明 しませんが ハードウェア 上 で 直 接 動 作 するのではなく ソフトウェアで 実 現 された 仮 想 のハードウェアが

1 Java の 基 礎 知 識 1.1 プログラミング プログラミング(programming) とは プログラム(program ある 一 連 の 処 理 をコンピュータへ 指 示 するもの)を 作 成 すること をいいます このプログラムを 記 述 (コーディング coding)する 際 に 使 用 する 専 用 の 言 語 を プログラミング 言 語 (programming language) といいます プログラミング 言 語 を 使 って 記 述 されたプログ ラムを ソースコード(source code) と 呼 び 普 通 はテキストファイルに 保 存 します ソースコードが 保 存 されたファイルを ソースファイル(source file) と 呼 びます 1.2 コンパイル Java 言 語 とは プログラミング 言 語 の 一 種 です Java 言 語 を 使 うと 人 間 にと って 比 較 的 分 かりやすくプログラムを 記 述 できます Java 言 語 のように 人 間 が 解 釈 しや すい 言 語 を 高 級 言 語 または 高 水 準 言 語 と 呼 びます Java 言 語 で 書 かれたプログ ラムは 人 間 にとっては 読 みやすいのですが 2 進 数 値 しか 解 釈 できないコンピュータ では そのまま 実 行 できません コンピュータが 実 行 できるようにするためには ソースコードに 対 して コンパ イル(compile) という 処 理 を 行 い オブジェクトコード(object code) と 呼 ばれる ものを 生 成 します このコードは コンピュータが 解 釈 実 行 できるものです( 図 1) 図 1 コンパイル オブジェクトコードは コンピュータが 解 釈 実 行 できるものです Java の 場 合 オブジェクトコードを Java バイトコード(byte code) と 呼 びます オブジェクトコ ードは バイナリファイル(binary file) として 保 存 されます Java の 場 合 そのフ ァイルを クラスファイル(class file) と 呼 びます 1.3 プログラムの 動 く 実 際 にこのプログラムを 動 作 させるには 補 助 記 憶 装 置 ( 通 常 は ハードディスク) に 保 存 されているファイルを 読 み 込 んで 主 記 憶 装 置 (メインメモリ)へロード(load) して 実 行 させます( 図 2) 図 2 プログラムを 実 行 1

これらプログラムの 実 行 は 普 通 はハードウェア 上 で 行 うのですが Java の 場 合 は 特 殊 なことを 行 っています 難 しい 理 屈 はここでは 説 明 しませんが ハードウェア 上 で 直 接 動 作 するのではなく ソフトウェアで 実 現 された 仮 想 のハードウェアがあって その 上 で 動 作 する と 覚 えておいてください( 仮 想 のハードウェアを Java 仮 想 マシ ン(Java Virtual Machine) と 呼 びます) Java Virtual Machine は JVM と 略 されま す 1.4 Eclipse でコンパイルをやってみる 前 の 説 明 にとおり HelloWorld クラスを 作 ったら Java のワークスペースの 中 ( pleiades workspace helloworld src helloworld)に HelloWorld.java というファイルとし て 保 存 します これは Java のソースファイルです Eclipse でプログラムを 実 行 すると バイトコードを 生 成 します 保 存 場 所 ( pleiades workspace helloworld bin helloworld)で HelloWorld.class が 見 えます これ は 生 成 した Java バイトコードです 2

2 Java プログラミング 基 礎 2.1 Java プログラムの 基 本 形 作 成 した HelloWorld プログラをみながら Java のプログラムの 基 本 形 について 見 ていきましょう コンソール 上 で 実 行 可 能 な Java4 のプログラムを 作 るには 次 のような 形 でコードを 記 述 します class HelloWorld { 1 2 3 public static void main(string[] args) { 3 5 4 5 System.out.print("Hello World!") ; 6 7 2.1.1 Class クラス 宣 言 Java のプログラムは ほとんどの 場 合 class プログラム 名 という 形 で 書 き 始 め ます Class は クラス と 読 み Java のプログラムの1つの 単 位 を 表 すものです このようにしてプログラムを 書 き 始 めることを クラスの 宣 言 と 呼 びます 2.1.2 HelloWorld クラス 名 Java のクラスには1つひとつ 固 有 の 名 前 をつけてやります この 名 前 のことをクラ ス 名 と 言 います クラス 名 には 半 角 英 数 字 及 びいくつかの 記 号 が 使 えますが クラス 名 の 先 頭 は 英 字 もしくは$ _のいずれかで 始 める 必 要 があります また Java プログ ラマの 間 の 暗 黙 の 了 解 として クラス 名 の 先 頭 及 び 単 語 の 区 切 りを 大 文 字 にすること になっています 2.1.3 { クラスの 範 囲 どこからどこまでが クラス の 範 囲 なのかを 示 すため クラス 宣 言 文 からプログ ラムの 末 尾 までを{ で 囲 みます 2.1.4 Public static void main(string[] args) メソッド 宣 言 そのプログラムが 持 つ 機 能 つまり 動 作 にあたるものは メソッドという 形 で 定 義 します 3

まず クラス という 大 きな 殻 を 作 り そのあとに 動 作 をつかさどるメソッド を 入 れていくようなイメージです コンソール 画 面 上 などで 動 作 するプログラムを 作 るときには 常 にこのような 形 で main という 名 前 のメソッドを 宣 言 し この 中 にプログラムの 内 容 を 書 き 込 んでいきま す このようなメソッドを main メソッドと 呼 びます 2.1.5 { メソッドの 範 囲 クラスと 同 様 メソッドも 始 まりと 終 わりを 中 カッコで 囲 みます ここからここ までがメソッドです ということ 示 すためです 始 まりのカッコと 終 わりのカッコが 正 しく 対 になっていないと プログラムは 正 し くコンパイルされません 2.1.6 System.out.println( Hello World! ); 命 令 文 コンピュータに 実 行 させたい 作 業 の 内 容 は 命 令 文 として 記 述 していきます 命 令 文 にはいろいろなものがあり それぞれに 書 き 方 が 決 めっています ここに 登 場 しているのは 画 面 上 に Hello World と 表 示 しなさい という 意 味 の 命 令 文 です これを 一 般 に println メソッドと 呼 んでいます 画 面 上 になんらかのメッセージなどを 表 示 させたいときは println メソッドを 使 っ て 次 のような 形 で 命 令 文 を 記 述 します System.out.println( [ 表 示 させたいメッセージの 内 容 ] ); ()のなかには 表 示 させたいメッセージの 内 容 を ( 半 角 )で 括 って 書 き 込 みます 例 えば こんにちは と 表 示 させたい 場 合 は 次 のようになります System.out.println( こんにちは ); 2.1.7 命 令 文 の 終 了 のしるし 命 令 文 の 終 わりには この 命 令 はここで 終 わりです ということを 示 すために;( 半 角 セミコロン)を 記 述 します Println メソッドなどの 命 令 文 を1 行 書 いたら 忘 れずに セミコロンを 入 力 しておきましょう ただし クラス 宣 言 文 やメソッド 宣 言 文 中 カッコなどの 行 にはセミコロンは 不 要 です 4

2.2 Java のコメント プログラムを 作 成 していく 時 に このメソッドはどんなメソッドなのかや 誰 がいつ 記 述 したものなのかといった 情 報 を 残 しておくと 後 で 見 なした 時 に 便 利 です このよう にプログラムの 中 に 説 明 を 記 述 する 時 に 使 うのがコメントです コメントはプログラムが 実 行 される 際 に 無 視 されますのでプログラムの 動 作 には 何 の 影 響 もしません 2.2.1 1 行 コメント プログラム 中 に // が 現 れた 場 合 // から 行 末 までをコメントとして 扱 います // は 行 の 先 頭 に 記 述 しその 行 を 全 てコメントとしてもいいですし 行 の 途 中 で 記 述 してその 位 置 より 右 側 をコメントとしてもいいです // 作 成 日 09.02.09 class sample{ public static void main(string args[]){ System.out.println("こんにちは"); // 画 面 出 力 2.2.2 ブロックコメント プログラム 中 に /* が 現 れた 場 合 次 に */ が 現 れるまでの 部 分 を 全 てコメン トとして 扱 います この 形 式 を 使 う 場 合 には 複 数 行 に 渡 ったコメントを 記 述 することが できます /* 作 成 日 09.02.09 バージョン 1.0.3 クラス 名 sample */ class sample{ public static void main(string args[]){ System.out.println("こんにちは"); /* 画 面 出 力 */ 5

2.3 Java の 識 別 子 識 別 子 とは 今 まで 出 てきたクラス 名 やメソッド 名 これから 出 てくる 変 数 名 など を 識 別 するための 名 前 です 識 別 子 のルール: 使 える 文 字 は a~z, A~Z, 0~9, _(アンダーバー), $ ( 例 ) name, old, no32 0~9 先 頭 の 文 字 に 使 えない ( 例 ) 12point などは Java の 予 約 語 (キーワード)と 同 名 は 不 可 ( 例 ) char や class などの 予 約 語 は 使 用 できない 大 文 字 と 小 文 字 は 識 別 される ( 例 ) old と Old は 別 の 変 数 2.4 Java の 予 約 語 Java の 言 語 仕 様 として 何 らかの 意 味 を 持 つ 単 語 を 予 約 語 として 登 録 してあります 例 えば 条 件 分 岐 を 記 述 する 時 に 使 用 される if などが 予 約 語 です 今 後 変 数 やクラス などの 名 前 を 自 分 で 付 ける 時 には Java の 予 約 語 は 使 用 することができません 予 約 語 の 一 覧 は 次 の 通 りです abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for goto if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchrnized this throw throws transient try void volatile while なお 下 記 の 3 つは 予 約 語 ではなく 予 め 用 意 された 定 数 です true false null 6

2.5 Java の 定 数 値 (リテラル) リテラル( 英 : literal)は 文 字 どおり 字 義 どおり を 意 味 する 語 である プ ログラムの 中 には 定 数 値 という 意 味 です 各 データ 型 のリテラルを 型 名 を 先 頭 につけて 文 字 列 リテラル 整 数 リテラル 日 付 リテラル などと 呼 びます Java で 定 数 値 ( 固 定 の 値 即 値 )を 表 現 するには 以 下 のようにします リテラル 名 形 式 型 例 整 数 リテラル 数 0 で 始 めると 八 進 数 0x で 始 めると 十 六 進 数 0b で 始 めると 二 進 数 (JDK1.7 以 降 ) int 123 0173 0x7b 0b1111011 末 尾 に L を 付 けると long 型 long 123L 浮 動 小 数 リテラル 小 数 点 付 きの 数 double 123.0 末 尾 に F を 付 けると float 型 末 尾 に D を 付 けると double 型 float double 123f 123d 文 字 リテラル シングルクォーテーションで 囲 む char 'A' 文 字 列 リテラル ダブルクォーテーションで 囲 む String "abc" 論 理 値 リテラル true 又 は false boolean true false 空 リテラル null 空 型 null 特 殊 な 文 字 の 入 力 (エスケープシーケンス) 文 字 と 文 字 列 を 値 として 使 用 する 場 合 キーボードから 入 力 できないような 文 字 が あります 例 えば 改 行 です 文 字 列 の 中 で 改 行 をキーボードから 入 力 した 場 合 は 次 のよ うになります class sample{ public static void main(string args[]){ System.out.println("こんにちは お 元 気 ですか"); 上 記 の 例 では こんにちは と お 元 気 ですか の 間 で 改 行 を 入 力 しようとしまし たがキーボードで Enter キーを 押 してもプログラムが 改 行 されるだけです 7

そこで 改 行 などキーボードから 入 力 できない 文 字 などは + 特 定 の 文 字 の 組 み 合 わせで 表 現 します 例 えば 改 行 は n という と n の 組 み 合 わせによって 表 すことができます class sample{ public static void main(string args[]){ System.out.println("こんにちは n お 元 気 ですか"); 上 記 では こんにちは と お 元 気 ですか の 間 に n が 記 述 されています n は 改 行 を 表 しますので 実 際 に 実 行 してみるとダイアログが 開 き 次 のように 表 示 されま す このようにキーボードから 入 力 できない 文 字 を 他 の 文 字 の 組 み 合 わせで 表 現 した ものをエスケープシーケンスといいます エスケープシーケンス 意 味 b バックスペース f 改 ページ n 改 行 r 復 帰 ( 行 頭 にカーソルを 戻 す) t 水 平 タブ ' ' " " 8

2.6 Java の 変 数 2.6.1 変 数 とは 変 数 とは プログラムのソースコードにおいて 扱 われるデータを 一 定 期 間 記 憶 し 必 要 なときに 利 用 できるようにするために データに 固 有 の 名 前 を 与 えたものである 変 数 は 値 を 保 存 しておくための 箱 のようによく 言 われます この 箱 には 数 値 や 文 字 列 などの 値 を 保 存 することができ そしていつでも 取 り 出 したり 改 めて 違 う 値 を 保 存 す ることができます 整 数 整 数 文 字 文 字 変 数 変 数 2.6.2 変 数 のデータ 型 変 数 宣 言 するときには 変 数 名 と 同 時 に 変 数 のデータ 型 を 指 定 する 必 要 があります 型 にはプログラマが 拡 張 できない 基 本 型 (プリミティブ 型 )と プログラマが 拡 張 できる 参 照 型 (リファレンス 型 )があります 整 数 型 (byte,short,int,long) 数 値 型 浮 動 小 数 点 数 (float,double) 基 本 型 (プリミティブ 型 ) 文 字 (char) boolean 型 (boolean) データ 型 クラス(class) 参 照 型 (リファレンス 型 ) インターフェース(interface) 配 列 9

整 数 や 浮 動 小 数 点 数 そして 文 字 などです Java で 用 意 されているデータ 型 は 次 の 通 りです データ 型 メモリ 領 域 をどのような 値 に 使 用 するか( 取 り 得 る 値 ) boolean char true or false 16 ビット Unicode 文 字 u0000~ uffff byte 8 ビット 整 数 -128~127 short 16 ビット 整 数 -32768~32767 int 32 ビット 整 数 -2147483648~2147483647 long 64 ビット 整 数 -9223372036854775808~9223372036854775807 float double 32 ビット 単 精 度 浮 動 小 数 点 数 64 ビット 倍 精 度 浮 動 小 数 点 数 2.7 メソッドとフィールド 計 算 機 に 必 要 なものは 加 算 や 減 算 といったデータを 処 理 する 機 能 と 計 算 対 象 や 計 算 結 果 などの データ に 分 けることができます Java では 機 能 をメソッドと 呼 び データ をフィールドと 呼 びます クラスには そのクラスから 作 り 出 されるモノが 持 つ 機 能 (メソッド)とデータ(フィ ールド)を 記 述 していきます class クラス 名 { フィールド 1 フィールド 2 メソッド 1 メソッド 2 どんなメソッドとフィールドを 用 意 するかでそのクラスから 作 り 出 されるものが 決 まります 目 的 の 処 理 を 行 わせるために 適 切 なメソッドとフィールドを 設 計 しなけ ればなりません 10

2.7.1 メソッド メソッドの 書 式 は 次 のようになっています [ 修 飾 子 ] 戻 り 値 のデータ 型 メソッド 名 ( 引 数 1, 引 数 2,.){ ここでは 詳 しく 解 説 はいたしませんが メソッドは 呼 び 出 す 時 単 に 呼 び 出 すだけ ではなく 値 を 指 定 することもできます 例 えテレビに 対 して チャンネルを 変 えろ と いうメソッドを 呼 び 出 すことも 出 来 ますが チャンネルを"1"に 変 えろ と 何 か 値 を 指 定 して 呼 び 出 す 場 合 もあります また 現 在 のチャンネルを 教 えろ というメソッドを 呼 び 出 せばテレビが 持 っているデータを 参 照 して 呼 び 出 し 元 に 値 を 返 してきます ここでは 説 明 のために 一 番 簡 単 な 構 成 のメソッドを 見 てみます void メソッド 名 (){ 引 数 も 戻 り 値 もないメソッドです クラスの 場 合 { から の 間 にメソッドや フィールドを 記 述 しましたが メソッドの 場 合 も { から の 間 にメソッドが 行 い たい 処 理 を 記 述 します では 挨 拶 だけをする 簡 単 なクラスを 作 成 してみます class Robot{ void hello(){ System.out.println("こんにちは"); void bye(){ System.out.println("さようなら"); Robot クラスの 中 に hello メソッドと bye メソッドを 用 意 しました hello メソッド は 呼 び 出 されると こんにちは と 表 示 します また bye メソッドは 呼 び 出 されると さ ようなら と 表 示 します このように 必 要 な 機 能 をメソッドとして 追 加 しくことで そ のクラスから 作 成 されるモノが 持 つ 機 能 が 増 えていくことになります 11

2.7.2 フィールド フィールドの 書 式 は 次 のようになっています [ 修 飾 子 ] データ 型 変 数 名 ; ここでは 詳 しく 解 説 はいたしませんが フィールドには 変 数 を 記 述 します 変 数 と いうのは 値 を 一 時 的 に 保 管 する 場 所 のことで 値 のデータ 型 と 名 前 を 指 定 します デー タ 型 とは 値 の 種 類 のことで 例 えば 数 値 とか 文 字 列 などがあります 名 前 は 保 管 場 所 を 識 別 するために 付 けられた 名 前 です 例 えば 次 のように 記 述 します int old; String name; 整 数 を 扱 う old という 名 前 の 変 数 と 文 字 列 を 扱 う name という 名 前 の 変 数 を 記 述 しました では 数 値 をカウントするクラスを 作 成 してみます class Counter{ int num; void init(){ num = 0; void count(){ num = num + 1; void printnum(){ System.out.println(num); Counter クラスの 中 に 1 つのフィールドと 3 つのメソッドを 用 意 しました init メソ ッドを 呼 び 出 すと num 変 数 に 0 を 格 納 し count メソッドを 呼 び 出 すと num 変 数 に 格 納 されている 値 に 1 を 加 えて 再 度 num 変 数 に 格 納 します そして printnum メソッドを 呼 び 出 すと num 変 数 に 格 納 されている 値 を 出 力 します このようにフィールドは 同 じクラスのメソッドによって 値 を 設 定 したり 取 り 出 し たりして 使 われます メソッドもフィールドも 詳 細 に 説 明 するのはまた 別 のページで 行 いますので ここ ではどのように 使 われるのかを 覚 えておいてください 12

2.8 Java の 演 算 子 算 術 演 算 子 算 術 演 算 子 は 数 値 を 計 算 する 場 合 に 使 用 します 次 のようなものが 用 意 されていま す 演 算 子 使 用 例 意 味 + a + b a に b を 加 える - a - b a から b を 引 く * a * b a に b をかける / a / b a を b で 割 る % a % b a を b で 割 った 余 り 単 項 マイナス 演 算 子 単 項 演 算 子 は 数 値 の 正 と 負 を 反 転 させるために 使 用 します 次 のようなものが 用 意 されています 演 算 子 使 用 例 意 味 + +a a の 正 負 をそのまま - -a a の 正 と 負 を 反 転 インクリメント デクリメント 演 算 子 演 算 の 中 でも 数 値 を 1 つだけ 増 加 することと 1 つだけ 減 少 させる 処 理 は 比 較 的 多 く 使 用 されます + 演 算 子 や - 演 算 子 を 使 って 記 述 すると 次 のようになります int num = 7; num = num + 1; 変 数 num に 代 入 されている 値 と 1 を 加 算 し その 結 果 を 改 めて 変 数 num に 格 納 しています 1 つだけ 減 らす 場 合 も - 演 算 子 を 使 って 同 じように 記 述 することが できます このように 1 だけ 増 加 する 又 は 1 だけ 減 算 するために 用 意 された 演 算 子 がインク リメント 演 算 子 (++)とデクリメント 演 算 子 (--)です 演 算 子 使 用 例 意 味 ++ a++ 又 は ++a a の 値 を 1 増 加 する -- a-- 又 は --a a の 値 を 1 減 らす 13

例 えば 先 ほどの 例 は 次 のように 書 き 換 えることができます int num = 7; num++; 同 じように 変 数 の 値 を 1 つだけ 減 らす 場 合 には 次 のように 記 述 することができま す int num = 7; num--; ++ 演 算 子 や -- 演 算 子 は 対 象 となる 変 数 の 値 を 変 化 させますので 演 算 結 果 を 変 数 に 代 入 する 必 要 はありません なお a++ と 記 述 する 代 わりに ++a と 記 述 することもできますが 結 果 が 異 な る 場 合 があります 前 置 と 後 置 インクリメント 演 算 子 とデクリメント 演 算 子 にはそれぞれ 前 置 と 後 置 の 二 種 類 が 用 意 されています インクリメント 演 算 子 の 前 置 きと 後 置 きは 次 のようになります 前 置 : ++ 変 数 後 置 : 変 数 ++ デクリメント 演 算 子 の 前 置 きと 後 置 きは 次 のようになります 前 置 : -- 変 数 後 置 : 変 数 -- 前 置 であっても 後 置 であってもインクリメント 演 算 子 は 対 象 の 変 数 の 値 を 1 だけ 増 加 させ デクリメント 演 算 子 の 場 合 は 対 象 の 変 数 の 値 を 1 だけ 減 少 させることに 違 い はありません 次 の 例 を 見 て 下 さい int a = 7; a++; System.out.println(a); // 8 ++a; System.out.println(a); // 9 前 置 であっても 後 置 であってもこのような 使 い 方 の 場 合 には 同 じ 結 果 となります 14

前 置 と 後 置 で 結 果 が 異 なる 場 合 前 置 と 後 置 で 結 果 が 異 なる 場 合 について 確 認 します 次 の 例 を 見 て 下 さい int a = 7; int b; b = a++; System.out.println(a); System.out.println(b); 後 置 のインクリメント 演 算 子 を 使 っています この 場 合 は 次 のように 実 行 されます int a = 7; int b; b = a; a = a + 1; System.out.println(a); // 8 System.out.println(b); // 7 後 置 のインクリメント 演 算 子 の 場 合 まずインクリメント 演 算 子 が 書 かれていない かのように 文 が 実 行 されます 今 回 の 場 合 であれば 変 数 b に 変 数 a を 代 入 してい ますので 数 値 の 7 が 変 数 b に 代 入 されます それから 変 数 a の 値 を 1 だけ 増 加 さ せます 次 の 例 を 見 て 下 さい int a = 7; int b; b = ++a; System.out.println(a); System.out.println(b); 前 置 のインクリメント 演 算 子 を 使 っています この 場 合 は 次 のように 実 行 されます int a = 7; int b; a = a + 1; b = a; System.out.println(a); // 8 System.out.println(b); // 8 前 置 のインクリメント 演 算 子 の 場 合 まず 対 象 の 変 数 を 1 だけ 増 加 させます よっ て 変 数 a の 値 が 8 となります それからインクリメント 演 算 子 を 除 いた 文 の 実 行 を します 今 回 の 場 合 であれば 変 数 b に 変 数 a を 代 入 していますので 数 値 の 8 が 変 15

数 b に 代 入 されます 今 回 の 場 合 はインクリメント 演 算 子 と 代 入 が 含 まれる 場 合 でしたが a++; や --b; などのよう 文 でない 場 合 には 前 置 と 後 置 で 結 果 が 異 なる 場 合 がありますので 注 意 して 下 さい ビット 演 算 子 整 数 の 値 に 対 してビット 単 位 で 処 理 を 行 うために 用 意 されているのがビット 演 算 子 です 次 の 演 算 子 が 用 意 されています 演 算 子 使 用 例 意 味 & a & 0xFF00FF00 a と 0xFF00FF00 のビット AND a 0xFF00FF00 a と OxFF00FF00 のビット OR ^ a ^ 0xFF00FF00 a と OxFF00FF00 のビット XOR ~ ~a a のビット 反 転 (ビット NOT) << a << 3 a を 左 へ 3 ビットシフト >> a >> 3 a を 右 へ 3 ビットシフト( 符 号 有 り) >>> a >>> 3 a を 右 へ 3 ビットシフト( 符 号 無 し) 数 値 を 2 進 数 の 形 式 で 表 示 し 各 ビットに 対 して 演 算 を 行 います シフト 演 算 子 ビット 演 算 子 の 中 でも 下 記 の 3 つはシフト 演 算 子 と 呼 ばれることもあります 演 算 子 使 用 例 意 味 << a << 3 a を 左 へ 3 ビットシフト >> a >> 3 a を 右 へ 3 ビットシフト( 符 号 有 り) >>> a >>> 3 a を 右 へ 3 ビットシフト( 符 号 無 し) これらの 3 つの 演 算 子 は 対 象 の 値 の 各 ビットを 右 または 左 へシフトします 10 進 数 で 右 または 左 へ 数 値 をシフトした 場 合 それは 数 値 を 1/10 にしたり 10 倍 す ることを 意 味 します 例 えば 1230 を 左 へシフトして 12300 とす れば 10 倍 したことに なりますし 右 へシフトして 123 とすれば 1/10 になったこととなります 同 じように 2 進 数 でシフトした 場 合 は 1/2 にしたり 2 倍 したりすることを 意 味 します 代 入 演 算 子 変 数 に 値 を 代 入 する 時 に 使 用 する 代 入 演 算 子 (=)はこれまでのサンプルなどでも 使 用 してきました 演 算 子 使 用 例 意 味 = a = b a に b を 代 入 する = の 右 辺 に 書 かれた 値 や 変 数 などを 左 辺 に 書 かれた 変 数 に 代 入 します 16

代 入 演 算 子 は = の 他 に 別 の 演 算 子 と 組 み 合 わせた 次 のものが 用 意 されています 演 算 子 使 用 例 意 味 += a += b a = a + b と 同 じ -= a -= b a = a - b と 同 じ *= a *= b a = a * b と 同 じ /= a /= b a = a / b と 同 じ %= a %= b a = a % b と 同 じ &= a &= b a = a & b と 同 じ = a = b a = a b と 同 じ ^= a ^= b a = a ^ b と 同 じ <<= a <<= b a = a << b と 同 じ >>= a >>= b a = a >> b と 同 じ >>>= a >>>= b a = a >>> b と 同 じ これらの 演 算 子 は 変 数 に 代 入 する 値 に 何 らかの 演 算 を 行 って その 結 果 を 再 度 同 じ 変 数 に 代 入 する 場 合 に 便 利 です 関 係 演 算 子 今 後 処 理 を 制 御 するための 様 々な 方 法 が 出 てきます その 中 でもある 条 件 を 満 た している 時 だけ 実 行 する 条 件 分 岐 や 条 件 が 満 たされている 間 は 繰 り 返 し 同 じ 処 理 を 行 う 繰 り 返 し 処 理 などが 多 く 利 用 する 機 会 が 多 いと 思 います 詳 しい 解 説 は 別 のページで 行 いますので 下 記 のサンプルだけ 簡 単 に 見 てください int old = 10; if (old >= 20){ System.out.println("20 歳 以 上 です"); else{ System.out.println("20 歳 未 満 です"); 変 数 old に 代 入 された 値 を 20 と 比 較 します 大 きいか 等 しければ 20 歳 以 上 で す と 画 面 に 出 力 し 小 さい 場 合 には 20 歳 未 満 です と 画 面 に 出 力 します このような 条 件 式 で 使 用 されるのが 関 係 演 算 子 です 関 係 演 算 子 は 2 つの 値 を 比 べ ます 大 きいか 小 さいかまたは 等 しいかなどを 評 価 し 結 果 として 式 全 体 が true 又 は false となります 左 辺 関 係 演 算 子 右 辺 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 式 が 評 価 され 結 果 として 式 が true か false となる 17

関 係 演 算 子 として 用 意 されているのは 次 の 通 りです 演 算 子 使 用 例 意 味 < a < b a は b よりも 小 さい <= a <= b a は b よりも 小 さいか 等 しい > a > b a は b よりも 大 きい >= a > b a は b よりも 大 きいか 等 しい == a == b a と b は 等 しい!= a!= b a は b は 等 しくない instanceof a instanceof b 参 照 型 変 数 a が b クラス/インターフェース/ 配 列 のインス タンスかどうか 関 係 演 算 子 を 含 む 式 が 正 しければ true となり 間 違 っていれば false となります 例 えば 10 < 20 は 正 しいので 10 < 20 という 式 が true となります 論 理 演 算 子 関 係 演 算 子 を 使 うことで 様 々な 条 件 を 記 述 することができますが さらに 論 理 演 算 子 を 使 うことで 10 より 大 きく かつ 30 より 小 さい や x が 10 と 等 しい 又 は y が 20 と 等 しい などのように 複 数 の 条 件 式 を 組 み 合 わせたより 複 雑 な 条 件 式 を 記 述 でき ます 論 理 演 算 子 を 使 った 場 合 も 結 果 として 式 が boolean 型 の true( 真 )か false( 偽 )のいずれ かとなります 論 理 演 算 子 として 用 意 されているのは 次 の 通 りです 演 算 子 使 用 例 意 味 && a && b a と b が 共 に true の 時 に true a b a か b の 少 なくとも 1 つが true の 場 合 に true!!a a が true の 場 合 に false a が false の 場 合 に true 論 理 演 算 子 の 場 合 には 対 象 となる 値 が boolean 型 の 値 です これは boolean 型 の 値 を 指 定 する 場 合 もありますが 通 常 は 関 係 演 算 子 を 使 った 条 件 式 などを 記 述 します ではそれぞれ 確 認 してみます 論 理 積 && は 論 理 積 とも 呼 ばれ 演 算 子 の 左 辺 及 び 右 辺 の 値 が 共 に true の 場 合 だけ 全 体 も true となります 左 辺 && 右 辺 18

左 辺 と 右 辺 の 値 による 全 体 の 値 の 一 覧 は 次 の 通 りです 左 辺 右 辺 全 体 true true true true false false false true false false false false 次 の 例 を 見 てください int num = 10; boolean b; b = num > 5 && num <= 20; この 場 合 まず num > 5 について 判 定 します 結 果 は true です 次 に num <= 20 を 判 定 します 結 果 は true です そして&& 演 算 子 の 両 端 の 値 が 共 に true ですので 式 num > 5 && num <= 20 は true となります なお 最 後 に && 演 算 子 が 判 定 されるのは > 演 算 子 や <= 演 算 子 と 比 べて 優 先 順 位 が 低 いためです 論 理 和 は 論 理 和 とも 呼 ばれ 演 算 子 の 左 辺 または 右 辺 の 値 の 少 なくとも 一 つが true の 場 合 に 全 体 が true となります 左 辺 右 辺 左 辺 と 右 辺 の 値 による 全 体 の 値 の 一 覧 は 次 の 通 りです 左 辺 右 辺 全 体 true true true true false true false true true false false false 次 の 例 を 見 てください int num1 = 10; int num2 = 20; boolean b; b = num1 > 20 num2 < 30; 19

この 場 合 まず num1 > 20 について 判 定 します 結 果 は false です 次 に num2 < 30 を 判 定 します 結 果 は true です そして 演 算 子 の 両 端 の 値 の 少 なくとも 一 つが true ですので 式 num1 > 20 num2 < 30 は true となります なお && 演 算 子 と 演 算 子 の 優 先 順 位 は 同 じではなく && の 方 が 優 先 順 位 が 高 くなっています 次 の 例 を 見 てください int num1 = 30; int num2 = 10; boolean b; b = num1 > 20 num2 < 30 && num2 > 20; この 場 合 先 に num2 < 30 && num2 > 20 が 判 定 されます これは false となりま す 次 に num1 > 20 false が 判 定 されますので 全 体 としては true となります もし 先 に num1 > 20 num2 < 30 から 判 定 された 場 合 は 次 に true && num2 > 20 が 判 定 されるため 全 体 としては false となり 本 当 の 結 果 とは 変 わってしまいます このように 論 理 演 算 子 が 複 数 含 まれるような 式 の 場 合 には 優 先 順 位 に 注 意 して 下 さい 論 理 否 定! は 論 理 否 定 とも 呼 ばれ 演 算 子 の 右 辺 の 値 を 反 転 します! 右 辺 右 辺 の 値 による 全 体 の 値 の 一 覧 は 次 の 通 りです 右 辺 true false 全 体 false true 次 の 例 を 見 てください int num = 10; boolean b; b =!(num > 20); この 場 合 まず num > 20 について 判 定 します 結 果 は false です そして! 演 算 子 によっての 式!(num > 20) は true となります なお! 演 算 子 は 優 先 順 位 がかなり 高 いので 必 要 に 応 じて 括 弧 を 使 って 下 さい 20

判 定 される 順 番 && 演 算 子 や 演 算 子 では 左 辺 及 び 右 辺 の 値 を 使 って 全 体 の 判 定 を 行 いますが どち らの 演 算 子 もまず 左 辺 から 判 定 します 左 辺 && 右 辺 && 演 算 子 の 場 合 で 考 えてみると まず 左 辺 を 判 定 します ここで 左 辺 が false だっ た 場 合 には 全 体 が false と 確 定 するため 右 辺 の 判 定 は 行 いません 左 辺 右 辺 演 算 子 の 場 合 もまず 左 辺 を 判 定 します ここで 左 辺 が true だった 場 合 には 全 体 が true と 確 定 するため 右 辺 の 判 定 は 行 いません ここで 順 番 を 何 故 気 にするのかと 言 えば まず 左 辺 から 先 に 判 定 されるため 左 辺 と 右 辺 のどちらに 何 を 記 述 するのかによって 処 理 効 率 が 変 わる 場 合 があります 左 辺 だけ で 結 果 が 確 定 する 場 合 が 多 いようにしておけば 右 辺 を 判 定 する 必 要 がなく 効 率 的 です また 左 辺 で 結 果 が 確 定 した 場 合 に 右 辺 は 判 定 されませんので 右 辺 にインクリメン ト 演 算 子 を 含 む 式 が 記 述 されていた 場 合 など 式 そのものが 処 理 されない 場 合 もありま す 次 の 例 を 見 てください int num1 = 30; int num2 = 25; boolean b; b = num1 > 10 ++num2 < 40; この 場 合 演 算 子 の 左 辺 だけで 全 体 が true となることが 確 定 するため 右 辺 はまっ たく 処 理 されません その 為 変 数 num2 の 値 も 1 増 えることはあ りません もしも 左 辺 が false だった 場 合 には 右 辺 も 判 定 されるため 変 数 num2 の 値 が 式 を 判 定 後 に 1 だけ 増 加 します このように 論 理 演 算 子 を 使 用 する 場 合 には 注 意 が 必 要 となります 条 件 演 算 子 ( 三 項 演 算 子 ) 条 件 演 算 子 は 三 項 演 算 子 とも 呼 ばれる 演 算 子 で 条 件 によって 処 理 を 分 けることが できます 書 式 は 次 の 通 りです す 条 件 式? 式 1 : 式 2 条 件 式 の 値 が true だった 場 合 に 式 1 を 処 理 し false だった 場 合 に 式 2 を 処 理 しま 21

文 字 列 の 連 結 + 演 算 子 は 算 術 演 算 子 の 加 算 や 単 項 演 算 子 としても 使 われていますが 文 字 列 に 対 して 使 用 すると 文 字 列 と 文 字 列 を 連 結 する 演 算 子 となります 文 字 列 1 + 文 字 列 2 次 の 例 を 見 てください System.out.println(" 目 覚 まし" + " 時 計 "); 上 記 では 目 覚 まし と 時 計 という 2 つの 文 字 列 を 連 結 しています 文 字 列 を 連 結 するというのは 左 側 の 文 字 列 の 後 ろに 右 側 の 文 字 列 をつなげた 文 字 列 となります よって 目 覚 まし 時 計 という 文 字 列 を 画 面 に 出 力 することになります 演 算 子 の 優 先 順 位 演 算 子 の 優 先 順 位 と 結 合 規 則 は 次 の 通 りです 優 先 順 位 高 演 算 子. [] () { ;, ++ -- ~! * / % + - << >> >>> < > <= >= ==!= & ^ && 低?: = *= /= %= += -= <<= >>= >>>= &= ^= = たとえば int a =2; int b = a + 3*a; 3 * a を 先 に 計 算 しますから + より * の 方 が 優 先 順 位 が 高 いといいます 22

上 記 の 演 算 子 の 表 は 上 にかかれている 演 算 子 のほうが 優 先 順 位 が 高 くなっていま す 優 先 順 位 と 異 なる 順 に 計 算 したい 場 合 は 丸 カッコを 用 いて 計 算 順 序 を 明 示 します (a+ 3) * a 2.9 制 御 構 造 複 雑 な 処 理 を 行 うプログラムを 作 成 するためには 制 御 構 造 (control structure) を 用 いる すなわち さまざまな 制 御 構 造 を 組 み 合 わせてプログラムを 作 成 することが できます これは いわゆる 構 造 化 プログラミングの 発 想 です 制 御 構 造 は 選 択 と 繰 り 返 しに 分 類 されます 2.9.1 If 選 択 文 If 文 の 処 理 一 : 条 件 式 を 評 価 した 結 果 に 応 じて 処 理 を 分 けたい 場 合 に 使 われるのが if 文 です 書 式 は 次 のようになっています if ( 条 件 式 ){ 実 行 する 文 1; 実 行 する 文 2; 条 件 式 が false だった 場 合 にはブロック 内 の 処 理 は 何 も 行 わず if 文 の 次 の 文 へ 処 理 が 移 ります 実 際 には 次 のように 記 述 します int x=0; if (x==1) System.out.println("x=1"); 上 位 の 例 では 変 数 x は1の 場 合 にはブロック 内 の 処 理 を 実 行 して x=1 と 画 面 に 表 示 します 23

If 文 の 処 理 二 : if 文 を 使 えば 条 件 式 が true の 時 だけ 行 う 処 理 を 記 述 できますが 条 件 式 が false だ った 場 合 の 処 理 も 合 わせて 記 述 することができます その 場 合 の 書 式 は 次 の 通 りです if ( 条 件 式 ){ true の 時 に 実 行 する 文 1; true の 時 に 実 行 する 文 2; else{ false の 時 に 実 行 する 文 1; false の 時 に 実 行 する 文 2; 条 件 式 を 評 価 し true だった 場 合 には 条 件 式 の 後 のブロック 内 の 文 を 実 行 し false だった 場 合 には else の 後 のブロック 内 の 文 を 実 行 します 条 件 式 の 評 価 は 必 ず true か false になるためどちらか 一 方 のブロック 内 の 文 だけを 実 行 することになります 実 際 には 次 のように 記 述 します int x=0; if(x==1) System.out.println("X=1"); else System.out.println("X!=1"); 上 位 の 例 では 変 数 x の 値 が 1 の 場 合 には x=1 と 画 面 に 表 示 します そして 変 数 x の 値 が 1 ではない 場 合 には x!=1 と 画 面 に 表 示 します この 処 理 流 れは 条 件 演 算 子 ( 三 項 演 算 子 )と 同 じです たとえば if(x>0) y=x; else y=-x; 条 件 演 算 子 で 書 き 換 えて 下 記 とおりです y = x>0?x:-x; 24

If 文 の 処 理 三 : ここまでは 一 つの 条 件 式 を 使 って 条 件 分 岐 を 行 ってきましたが 今 度 は 複 数 の 条 件 式 を 使 いより 複 雑 な 条 件 文 を 行 ってみます 書 式 は 次 の 通 りです if ( 条 件 式 1){ 条 件 式 1 が true の 時 に 実 行 する 文 1; 条 件 式 1 が true の 時 に 実 行 する 文 2; else if ( 条 件 式 2) { 条 件 式 1 が false で 条 件 式 2 が true の 時 に 実 行 する 文 1; 条 件 式 1 が false で 条 件 式 2 が true の 時 に 実 行 する 文 2; else if ( 条 件 式 3) { else{ 全 ての 条 件 式 が 共 に false の 時 に 実 行 する 文 1; 全 ての 条 件 式 が 共 に false の 時 に 実 行 する 文 2; 複 数 の 条 件 式 が 使 われている 場 合 は 上 の 条 件 式 から 順 に 評 価 していきます まず 条 件 式 1 を 評 価 し true だった 場 合 は 直 後 のブロック 内 の 処 理 を 実 行 して if 文 を 終 了 しま す 条 件 式 1 の 評 価 が false だった 場 合 だけ 次 の 条 件 式 2 を 評 価 します 条 件 式 2 が true だった 場 合 には 直 後 のブロック 内 の 処 理 を 実 行 し て if 文 を 終 了 します このように 順 に 条 件 式 を 評 価 し 全 ての 条 件 式 が false だった 場 合 に else の 後 のブロック 内 の 文 を 実 行 します 実 際 には 次 のように 記 述 します if (x==1) { System.out.println("X=1"); else if (x==2) { System.out.println("X=2"); else if (x==3){ System.out.println("X=3"); else { System.out.println("other"); 25

If 文 の 処 理 四 : もう 1 つもっと 複 雑 の 条 件 式 使 われている 場 合 があります if 文 のネスト( 入 れ 子 構 造 )といいます if( 条 件 式 1){ if( 条 件 式 2){ 条 件 式 2 が true の 場 合 の 処 理 else{ 条 件 式 1 が true で 条 件 式 2 が false の 場 合 else{ if( 条 件 式 3){ 条 件 式 1 が false で 条 件 式 3 が true の 場 合 else{ 条 件 式 1 も 条 件 式 3 も false の 場 合 このような 記 述 になります それぞれ if 文 の 中 にさらに if else 文 を else 文 の 中 にさらに if else 文 を 記 述 して ネストしています では 実 際 にサンプルプログラムを 見 ていきます if (x == 1) { if(y == 1) System.out.println("x = 1,y = 1"); else System.out.println("x = 1,y!= 1"); else if(x!=1) { if(y == 1) System.out.println("x!= 1,y = 1"); else System.out.println("x!= 1,y!= 1"); 26

2.9.2 Switch 選 択 文 ある 変 数 の 値 を 複 数 の 値 と 比 較 し 値 に 応 じた 処 理 を 行 うような 場 合 を 考 えてみま す if 文 を 使 って 記 述 すると 次 のようになります int num = 3; if (num == 1){ System.out.println(" 非 常 に 不 満 "); else if (num == 2){ System.out.println(" 少 し 不 満 "); else if (num == 3){ System.out.println("どちらとも 言 えない"); else if (num == 4){ System.out.println(" 少 し 満 足 "); else if (num == 5){ System.out.println(" 大 変 満 足 "); このように if 文 を 使 っても 記 述 できますが 対 象 となる 値 毎 に 処 理 を 分 けるには switch 文 を 使 って 記 述 することもできます switch 文 の 利 用 switch 文 は 対 象 の 式 を 評 価 した 結 果 の 値 に 応 じ 値 に 一 致 するラベルの 位 置 へ 処 理 を 移 すために 使 います 条 件 分 岐 とは 厳 密 には 少 し 違 いますが 同 じような 使 い 方 ができ る 文 ですす switch 文 の 書 式 は 次 のようになっています switch ( 式 ){ case 定 数 1: 実 行 する 文 1; 実 行 する 文 2; break; case 定 数 2: 実 行 する 文 1; 実 行 する 文 2; break; 27

switch 文 ではまず 式 を 評 価 します 式 には 単 に 整 数 の 値 が 代 入 された 変 数 などを 単 に 記 述 してもいいですし 計 算 式 などを 記 述 することも 可 能 です ただ いずれの 場 合 であっても 式 の 評 価 した 結 果 が 整 数 でなければなりません 浮 動 小 数 点 数 や 文 字 列 など は 記 述 できません また 整 数 であっても long 型 の 値 は 使 用 できません 式 には 例 えば 次 のように 記 述 します int num = 3; switch (num){ // 変 数 の 値 が 式 を 評 価 した 値 switch (num % 2){ // 演 算 結 果 が 式 を 評 価 した 値 次 に switch 文 の { から のブロック 内 に 実 行 したい 処 理 を 羅 列 していきます int num = 3; switch (num){ System.out.println(" 非 常 に 不 満 "); System.out.println(" 少 し 不 満 "); System.out.println("どちらとも 言 えない"); System.out.println(" 少 し 満 足 "); System.out.println(" 大 変 満 足 "); switch 文 は 式 を 評 価 した 値 に 一 致 するラベルへ 処 理 を 移 動 させるために 使 われま す そこでどの 値 だったらどの 処 理 を 行 うのかを 指 定 するためにブロック 内 にラベルを 記 述 していきます ラベルは 次 のような 形 式 となっています case 定 数 : ブロック 内 にラベルを 記 述 すると 式 を 評 価 した 値 と 一 致 するラベルのところへ 処 理 を 移 すことができます 28

例 えば 5 つのラベルを 記 述 すると 次 のようになります int num = 3; switch (num){ case 1: System.out.println(" 非 常 に 不 満 "); case 2: System.out.println(" 少 し 不 満 "); case 3: System.out.println("どちらとも 言 えない"); case 4: System.out.println(" 少 し 満 足 "); case 5: System.out.println(" 大 変 満 足 "); ラベルに 書 いた 値 が 1 2 3 4 5 ですので 式 の 値 が 1 から 5 の 場 合 に 対 応 するラベルの 位 置 へ 処 理 が 移 ります 今 回 の 場 合 変 数 num の 値 が 3 ですの で case 3: のラベルの 位 置 に 処 理 が 移 ります そしてその 後 に 記 述 された System.out.println("どちらとも 言 えない"); が 実 行 されます 注 意 して 頂 きたいのはあくまでラベルが 書 かれた 位 置 に 処 理 が 移 るだけというこ とです ラベルの 位 置 へ 移 動 した 後 は switch 文 の 最 後 までそれ 以 降 の 文 を 順 に 実 行 し ていきます よって System.out.println("どちらとも 言 えない"); が 実 行 された 後 は System.out.println(" 少 し 満 足 "); と System.out.println(" 大 変 満 足 "); が 実 行 されます もしもラベルの 位 置 へ 移 動 した 後 に 次 のラベルの 前 まで 来 たら switch 文 を 終 了 さ せたい 場 合 には break 文 を 使 います break 文 についてはまた 別 のページで 詳 しく 解 説 しますが switch 文 の 中 で break 文 が 実 行 されると switch 文 を 終 了 します 具 体 的 には 次 のように 記 述 します int num = 3; switch (num){ case 1: System.out.println(" 非 常 に 不 満 "); break; case 2: System.out.println(" 少 し 不 満 "); break; case 3: 29

System.out.println("どちらとも 言 えない"); break; case 4: System.out.println(" 少 し 満 足 "); break; case 5: System.out.println(" 大 変 満 足 "); break; 上 記 のように break 文 を 記 述 すると break 文 を 実 行 した 時 点 で switch 文 は 終 了 しま す よって 上 記 の 場 合 では System.out.println("どちらとも 言 えない"); が 実 行 された 後 に break; が 実 行 されて switch 文 は 終 了 します 以 上 が switch 文 の 大 まかな 使 い 方 です if 文 を 使 えば 同 じようなことが 記 述 できる 場 合 が 多 いのですが 一 つの 変 数 の 値 に 応 じて 処 理 を 分 けたい 場 合 には switch 文 の 方 が 見 やすく 記 述 できる 場 合 があります default 句 式 の 値 と 一 致 するラベルが 無 かった 場 合 は 何 も 実 行 せずに switch 文 を 終 了 します が 一 致 するラベルが 無 かった 場 合 に 何 か 実 行 させたい 処 理 がある 場 合 には default 句 を 使 います 書 式 は 次 の 通 りです switch ( 式 ){ case 定 数 1: 実 行 する 文 ; break; case 定 数 2: 実 行 する 文 ; break; default: 実 行 する 文 1; 実 行 する 文 2; 上 記 の 場 合 式 を 評 価 した 結 果 の 値 が 定 数 1 にも 定 数 2 にも 一 致 しなかった 場 合 には default: の 位 置 に 処 理 が 移 ります そしてその 後 に 書 かれた 文 が 順 に 実 行 されて いきます 例 えば 次 のように 記 述 します 30

int num = 3; switch (num){ case 4: System.out.println(" 少 し 満 足 "); break; case 5: System.out.println(" 大 変 満 足 "); break; default: System.out.println(" 満 足 していない"); 上 記 の 場 合 変 数 num の 値 が 4 または 5 以 外 の 場 合 には 全 て System.out.println(" 満 足 していない"); の 文 を 実 行 します 2.9.3 while 繰 り 返 し 文 主 に 指 定 した 回 数 だけ 繰 り 返 し 目 的 で 利 用 される for 文 に 対 して 条 件 が 満 たされ ている 間 は 何 度 でも 繰 り 返 す 目 的 で 利 用 されるのが while 文 です 書 式 は 次 の 通 りです while ( 条 件 式 ){ 実 行 する 文 1; 実 行 する 文 2; while 文 では 条 件 式 を 評 価 し true だった 場 合 には { から のブロック 内 に 記 述 された 文 を 実 行 します では 簡 単 な 例 を 使 い while 文 がどのように 処 理 されるのかを 確 認 してみます int x=1; while(x<3) { System.out.println("x="+x); x++; 注 意 :while( 条 件 式 )の 後 には;(セミコロン)は 不 要 です 31

do while 文 while 文 ではまず 条 件 式 を 評 価 してから 1 回 目 の 繰 り 返 しを 行 います その 為 場 合 によっては 一 度 も 繰 り 返 し 処 理 を 行 わないことがあります それ に 対 してまず 繰 り 返 しを 一 度 行 ってから 条 件 式 を 評 価 したい 場 合 に 利 用 されるのが do..while 文 です 書 式 は 次 の 通 りです do{ 実 行 する 文 1; 実 行 する 文 2; while ( 条 件 式 ); do..while 文 ではまず { から のブロック 内 に 記 述 された 文 を 実 行 します そ して 条 件 式 を 評 価 し true だった 場 合 には 再 度 ブロック 内 の 処 理 を 行 いますが false だっ た 場 合 には do..while 文 を 終 了 して 次 の 文 へ 処 理 が 移 ります 注 意 すべき 点 は 最 後 にセミコロン(;)を 付 ける 必 要 がある 点 です 2.9.4 for for 文 は 指 定 した 回 数 だけ 処 理 を 繰 り 返 す 時 に 使 われます 書 式 は 次 の 通 りです for ( 初 期 化 式 ; 条 件 式 ; 変 化 式 ){ 実 行 する 文 1; 実 行 する 文 2; for 文 では 条 件 式 を 評 価 し true だった 場 合 には { から のブロック 内 に 記 述 された 文 を 実 行 します そしてブロック 内 の 処 理 が 一 通 り 終 わると 改 めて 条 件 式 を 評 価 します そしてまた true だった 場 合 にはブロック 内 の 文 の 実 行 し false だった 場 合 には for 文 を 終 了 します ではまず 条 件 式 だけを 使 って for 文 を 記 述 してみます 次 の 例 を 見 て 下 さい for (int i = 0; i < 2; i++){ System.out.println(i); 32

この 例 では 条 件 式 i < 2 が true となる 間 繰 り 返 し 処 理 を 実 行 します 繰 り 返 し 処 理 を 1 度 実 行 するために 条 件 を 変 化 させなければ 無 限 に 繰 り 返 しを 行 ってしまいます ので 今 回 の 例 では 繰 り 返 しの 中 で 実 行 される 文 の 一 つとして 変 数 i の 値 を 1 ずつ 増 加 させています この 例 では 次 のように 文 が 実 行 されていきます 1)i = 0; 2) 条 件 式 を 評 価 i は 2 よりも 小 さいので 繰 り 返 しを 実 行 3) System.out.println(i); 4)i++; 5) 条 件 式 を 評 価 i は 2 よりも 小 さいので 繰 り 返 しを 実 行 6) System.out.println(i); 7)i++; 8) 条 件 式 を 評 価 count は 2 よりも 小 さくないので 繰 り 返 しを 終 了 このように for 文 ではまず 最 初 に 条 件 式 が 評 価 されます もしも 条 件 式 がいきなり false となった 場 合 には 繰 り 返 し 処 理 は 実 行 されません 条 件 式 が true だった 場 合 には for 文 の { から までのブロック 内 の 文 を 順 に 実 行 していきます ブロック 内 の 最 後 の 文 を 実 行 したら 1 回 目 の 繰 り 返 しが 終 了 です そして for 文 の 最 初 に 戻 り 改 めて 条 件 式 を 評 価 します true なら 再 度 ブロック 内 の 文 を 実 行 し false だ った 場 合 には for 文 の 次 の 文 へ 処 理 が 移 ります for 文 はこのように 条 件 式 の 評 価 とブロック 内 の 処 理 の 実 行 を 繰 り 返 す 為 のもので す 2.9.5 break break 文 は for 文 while 文 do..while 文 switch 文 のブロック 内 で 使 用 され break 文 が 実 行 されるとブロックを 抜 けて 次 の 処 理 へ 移 ります break 文 の 書 式 は 次 のように なっています break; switch 文 の 中 で break 文 をどのように 使 うのかについては switch 文 を 説 明 する 部 分 を 参 照 して 下 さい まずは for 文 での 使 い 方 を 確 認 します for 文 は 条 件 式 が true の 間 ブロック 内 の 処 理 を 繰 り 返 し 実 行 しますが break 文 が 実 行 されると for 文 を 終 了 し 次 の 処 理 へ 移 ります 33

for ( 初 期 化 式 ; 条 件 式 ; 変 化 式 ){ if ( 条 件 式 ){ break; if 文 などと 組 み 合 わせて break 文 を 記 述 します (if 文 などと 組 み 合 わせなければ 必 ず 1 回 目 の 繰 り 返 しの 途 中 で break 文 が 実 行 され for 文 が 終 了 してしまいます) 実 際 には 次 のように 記 述 します int sum = 0; for (int i = 1; i <= 100; i++){ sum += i; if (sum > 100){ break; System.out.println("sum = " + sum); この 場 合 1 から 100 までの 数 値 を 順 に 加 算 していきますが 合 計 が 100 を 超 えた 時 点 で break 文 を 実 行 し for 文 を 終 了 し 次 の 文 へ 処 理 が 移 ります while 文 の 場 合 も 基 本 的 に 同 じです 繰 り 返 しの 途 中 で break 文 が 実 行 されると while 文 を 終 了 し 次 の 処 理 へ 移 ります while ( 条 件 式 ){ if ( 条 件 式 ){ break; 実 際 には 次 のように 記 述 します 34

int num = 1; while(true){ System.out.println(num); num++; if (num > 100){ break; この 場 合 while 文 の 条 件 式 が true となっていますので 条 件 式 を 評 価 した 結 果 は 常 に true となりこのままでは 無 限 ループとなります ただし 変 数 num の 値 が 100 を 越 えたら break 文 が 実 行 され while 文 が 終 了 します do..while 文 の 場 合 も 基 本 的 には 同 じです 2.9.6 continue 文 continue 文 は break 文 と 同 じく for 文 while 文 do..while 文 のブロック 内 で 使 用 さ れ continue 文 が 実 行 されると 実 行 された 位 置 からブロックの 最 後 まで 残 りの 処 理 をス キップします continue 文 の 書 式 は 次 のようになっています continue; スキップという 意 味 が 分 かりにくいかもしれませんが 次 の 例 を 見 て 下 さい for (int i = 0; i < 10; i++){ if (i == 3){ continue; System.out.println(i); 上 記 では 変 数 i の 値 が 3 の 時 に continue 文 が 実 行 されます continue 文 が 実 行 さ れるとブロック 内 でそれ 以 降 に 記 述 された 処 理 を 全 て 行 わずに 次 の 繰 り 返 しの 条 件 判 断 に 進 みます つまり 上 記 の 場 合 は 変 数 i の 値 が 3 の 時 だけ System.out.println(i); が 実 行 されません なお for 文 の 場 合 は 変 化 式 が 別 途 用 意 されているので 気 にしなくても 大 丈 夫 ですが while 文 などでは 条 件 式 の 値 を 変 化 させる 処 理 も 含 めてスキップさせてしまわないよう 35

に 気 をつけて 下 さい 例 えば 次 のように 記 述 してしまうと 変 数 i が 3 になると 変 数 i の 値 を 変 化 さ せる 処 理 もスキップしてしまうため 次 の 繰 り 返 し 処 理 になっても 変 数 i の 値 が 変 化 せずに 無 限 ループとなってしまいます int i = 0; while(i < 10){ if (i == 3){ continue; i++; System.out.println(i); なお break 文 と 同 じく 繰 り 返 し 処 理 が 多 重 になっている 場 合 には continue 文 を 含 む 一 番 内 側 の 繰 り 返 し 処 理 をスキップして 次 の 繰 り 返 しへ 移 ります 任 意 の 繰 り 返 し 処 理 をスキップさせるには 次 のページで 解 説 するラベル 付 き continue を 使 って 下 さい 36

2.10 配 列 2.10.1 概 念 同 じ 基 本 データ 型 のデータをいくつかまとめて 一 方 向 または 多 方 向 に 並 べたデー タ 型 は 配 列 (array)と 呼 ばれます 配 列 には 要 素 を 一 方 向 に 並 べた1 次 元 配 列 (one-dimensional array)と 多 方 向 に 並 べた 多 次 元 配 列 (multi-dimensional array)があります 2.10.2 配 列 宣 言 配 列 を 使 用 するには まず 最 初 に 使 用 する 配 列 を 宣 言 しなくてはいけません 宣 言 は 次 のように 行 います 型 名 配 列 変 数 名 []; 変 数 の 場 合 と 同 じく 格 納 される 値 のデータ 型 と 配 列 を 区 別 するための 配 列 変 数 名 を 指 定 します 一 つの 配 列 には 同 じデータ 型 の 値 しか 格 納 することはできません 変 数 の 場 合 は 宣 言 するだけで 一 つの 値 を 格 納 できる 場 所 が 確 保 されましたが 配 列 の 場 合 では 値 を 格 納 する 場 所 を 必 要 な 数 だけ 後 から 確 保 する 必 要 があります 場 所 を 確 保 するには new 演 算 子 を 使 って 次 のように 行 います 型 名 配 列 変 数 名 []; 配 列 変 数 名 = new 型 名 [ 要 素 数 ]; 一 つの 配 列 に 確 保 される 一 つ 一 つの 場 所 を 要 素 と 呼 びます new 演 算 子 では 型 名 の 後 の [ から ] の 間 に 要 素 の 数 である 要 素 数 を 指 定 して 格 納 する 場 所 である 要 素 を 確 保 し それを 配 列 変 数 に 代 入 します これで 配 列 は 要 素 数 の 数 だけの 値 を 格 納 するこ とができるようになります なお 配 列 の 宣 言 と 要 素 の 確 保 はまとめて 次 のように 記 述 することもできます 型 名 配 列 変 数 名 [] = new 型 名 [ 要 素 数 ]; 例 えば int 型 の 値 を 5 つ 格 納 できる 配 列 を 用 意 するには 次 のように 記 述 します int a[]; a = new int[5]; int b[] = new int[5]; 上 は 配 列 の 宣 言 と 要 素 の 確 保 を 別 々に 行 った 場 合 下 は 要 素 の 宣 言 と 配 列 の 確 保 を まとめて 行 った 場 合 です 配 列 の 宣 言 の 別 の 方 法 Java では 先 に 記 述 した 記 述 方 法 の 他 に 次 の 書 式 を 使 うことができます 型 名 [] 配 列 変 数 名 ; 37

どちらの 書 式 であっても 配 列 の 宣 言 に 違 いはありません どちらかの 方 法 で 統 一 し て 使 うようにしていればいいと 思 います ただどちらかの 書 式 では 記 述 しにくい 時 もあ りますので 二 つの 記 述 方 法 があることは 覚 えておいて 下 さい この 書 式 を 使 って int 型 の 値 を 5 つ 格 納 できる 配 列 を 用 意 するには 次 のように 記 述 します int[] a; a = new int[5]; int[] b = new int[5]; 2.10.3 初 期 化 変 数 では 次 のように 宣 言 と 同 時 に 初 期 値 を 代 入 することができました 型 名 変 数 名 = 初 期 値 ; 配 列 の 場 合 で 配 列 の 宣 言 と 要 素 の 確 保 そして 各 要 素 への 初 期 値 の 代 入 をまとめて 行 うには 次 の 書 式 を 使 います 型 名 配 列 変 数 名 [] = { 値 1, 値 2, ; 配 列 の 各 要 素 に 代 入 する 初 期 値 を { から の 間 にカンマ(,)で 区 切 って 記 述 し ます 要 素 の 確 保 が 行 われていませんが 値 を 記 述 した 数 と 同 じ 要 素 を 自 動 的 に 確 保 し ます 実 際 には 次 のように 記 述 します int n[] = {18, 29, 36, 12; この 場 合 int 型 のデータを 扱 い 4 つの 要 素 を 持 つ 配 列 を 作 成 し 各 要 素 には 18 29 36 12 と 言 う 値 を 代 入 するということになります これは 次 のように 記 述 した 事 と 同 じです int n[]; n = new int[4]; n[0] = 18; n[1] = 29; n[2] = 36; n[3] = 12; この 書 式 はとても 便 利 ですが 配 列 の 要 素 数 の 分 だけ 必 ず 値 を 指 定 する 必 要 があり ます 8 個 の 要 素 が 必 要 だが 初 期 化 の 時 点 では 4 つ 要 素 だけ 初 期 値 を 代 入 したいといっ た 場 合 にはこの 書 式 ではなく 配 列 の 宣 言 を 行 って 要 素 を 確 保 してから 一 つ 一 つ 初 期 値 38

を 代 入 していくしかありません 2.10.4 配 列 の 長 さ 配 列 で 確 保 されている 要 素 の 数 を 調 べたい 場 合 があります 要 素 の 数 は 配 列 の 長 さ とも 呼 ばれますが 次 の 書 式 で 取 得 することができます 配 列 変 数 名.length 調 べたい 配 列 変 数 の 後 にドット(.)+length と 記 述 することで 配 列 の 長 さを 取 得 でき ます (なお length はフィールドではなく 特 別 な 構 文 です フィールドについてはクラ スの 説 明 の 時 に 行 います) 実 際 には 次 のように 記 述 します int n[] = {18, 29, 36, 12; System.out.println(n.length); 配 列 には 4 つの 要 素 が 確 保 されていますので 画 面 には 4 と 表 示 されます 配 列 の 長 さは 配 列 と 繰 り 返 し 処 理 を 組 み 合 わせて 使 用 する 場 合 によく 使 用 されま す 配 列 の 全 ての 要 素 を 順 に 処 理 したい 時 要 素 の 数 を 取 得 して 繰 り 返 しを 行 う 回 数 を 決 めます 次 の 例 を 見 てください int n[] = {18, 29, 36, 12; for (int i = 0; i < n.length; i++){ System.out.println(n[i]); 条 件 式 の 箇 所 で 配 列 変 数.length を 使 い 繰 り 返 し 回 数 を 決 めています 配 列 の 要 素 数 が 確 定 していれば 数 値 を 直 接 記 述 した 方 が 効 率 がいいのですが 配 列 変 数.length を 使 っておけば 後 で 配 列 の 要 素 の 数 が 変 更 になった 場 合 でも 修 正 は 必 要 ありません ま た 数 値 が 記 述 されているとなぜこの 数 値 なのか 後 から 分 からなくなる 可 能 性 もあり ますが 数 値 の 代 わりに 配 列 変 数.length が 記 述 されていれば 配 列 の 長 さだけ 処 理 したか っということがはっきりと 分 かります 2.10.5 多 次 元 配 列 配 列 は 複 数 の 値 をまとめて 管 理 できる 便 利 なものですが 配 列 の 各 要 素 に 代 入 する 値 に 別 の 配 列 を 使 うことができます 次 の 例 を 見 てください int kokugo[] = {80, 92, 45; int sansu[] = {75, 89, 54; 39

国 語 と 算 数 の 成 績 をそれぞれ 3 人 分 管 理 しています 3 人 分 の 国 語 の 成 績 を 管 理 す るの 配 列 を 一 つ 利 用 し 3 人 分 の 算 数 の 成 績 を 管 理 するのに 配 列 を 1 つ 利 用 しています ここでこの 二 つの 配 列 を 値 として 考 え 配 列 を 値 として 格 納 するような 別 の 配 列 を 用 意 します 配 列 の 宣 言 は 次 のようになっていました 型 名 配 列 変 数 名 []; 作 成 しようとする 配 列 に 格 納 されるデータ 型 は int 型 の 値 を 持 つ 配 列 です つまり データ 型 は int[]となります よって 配 列 を 値 として 持 つ 配 列 は 次 のように 記 述 すること ができます int[] seiseki[]; この 配 列 は 名 前 が seiseki で 型 名 が int[]です ただこの 記 述 方 法 でもエラーとは なりませんが 通 常 は 次 のいずれかの 記 述 方 法 を 使 います int seiseki[][]; int[][] seiseki; この 配 列 変 数 は 値 として 配 列 を 格 納 する 配 列 です この 配 列 変 数 を 使 うことで 3 人 分 の 成 績 を 格 納 した 配 列 を 値 として 持 つことができます このような 配 列 は 多 次 元 配 列 と 呼 ばれるます 2.10.6 多 次 元 配 列 の 要 素 の 確 保 多 次 元 配 列 であっても 配 列 と 違 いはないので 利 用 する 前 に 要 素 の 確 保 が 必 要 であ り 次 のように 記 述 します 型 名 配 列 変 数 名 [][]; 配 列 変 数 名 = new 型 名 [ 要 素 数 ][]; 例 えば 2 つの 要 素 を 持 つ 場 合 には 次 のようになります int seiseki[][]; seiseki = new int[2][]; これで 多 次 元 配 列 の 要 素 が 確 保 されました 次 に 要 素 に 値 を 格 納 していきますが 値 として 格 納 するのは 別 の 配 列 です 例 えば 次 のように 記 述 します int seiseki[][]; seiseki = new int[2][]; int kokugo[]; kokugo = new int[3]; kokugo[0] = 80; kokugo[1] = 92; kokugo[2] = 45; 40

int sansu[]; sansu = new int[3]; sansu[0] = 75; sansu[1] = 89; sansu[2] = 54; seiseki[0] = kokugo; seiseki[1] = sansu; 丁 寧 に 記 述 するとこのようになりますが 多 次 元 代 入 に 値 として 代 入 する 配 列 を 別 に 作 らなくても 次 のように 記 述 することができます int seiseki[][]; seiseki = new int[2][]; seiseki[0] = new int[3]; seiseki[1] = new int[3]; seiseki[0][0] = 80; seiseki[0][1] = 92; seiseki[0][2] = 45; seiseki[1][0] = 75; seiseki[1][1] = 89; seiseki[1][2] = 54; 慣 れないと 分 かりにくいと 思 いますが seiseki[0]を kokugo に seiseki[1]を sansu に 置 き 換 えてみて 頂 ければ 分 かると 思 います さらにまとめて 次 のように 記 述 することができます int seiseki[][]; seiseki = new int[2][3]; seiseki[0][0] = 80; seiseki[0][1] = 92; seiseki[0][2] = 45; seiseki[1][0] = 75; 41

seiseki[1][1] = 89; seiseki[1][2] = 54; この 場 合 int 型 の 値 を 持 つことができる 要 素 を 3 つ 分 確 保 した 配 列 を 値 として 持 つことができる 要 素 を 2 つ 確 保 した 配 列 を 作 成 します 結 局 のところ 多 次 元 配 列 におけ る 要 素 の 確 保 は 次 のように 記 述 できます 型 名 配 列 変 数 名 [][]; 配 列 変 数 名 = new 型 名 [ 要 素 数 ][ 値 の 配 列 の 要 素 数 ]; また 通 常 の 配 列 と 同 じように 配 列 の 宣 言 と 要 素 の 確 保 はまとめて 次 のように 記 述 することもできます 型 名 配 列 変 数 名 [][] = new 型 名 [ 要 素 数 ][ 値 の 配 列 の 要 素 数 ]; よって 先 ほどまでのサンプルは 次 のように 記 述 できます int seiseki[][] = new int[2][3]; seiseki[0][0] = 80; seiseki[0][1] = 92; seiseki[0][2] = 45; seiseki[1][0] = 75; seiseki[1][1] = 89; seiseki[1][2] = 54; 多 次 元 配 列 は 配 列 を 値 として 持 つような 配 列 であり 複 数 の 変 数 を 使 用 することで 繰 り 返 し 処 理 と 組 み 合 わせて 多 くの 値 をまとめて 処 理 することができるようになりま す なお 今 回 の 多 次 元 配 列 は 2 次 元 の 配 列 でしたが 2 次 元 の 配 列 を 値 として 持 つよう な 3 次 元 の 配 列 など 何 次 元 の 配 列 でも 作 成 は 可 能 です 2.10.7 多 次 元 配 列 の 初 期 化 配 列 の 各 要 素 に 初 期 値 を 設 定 する 方 法 は 次 のような 書 式 を 使 いました 型 名 配 列 変 数 名 [] = { 値 1, 値 2,..; 多 次 元 配 列 の 場 合 は 要 素 に 代 入 される 値 が 別 の 配 列 となりますので 次 のような 書 式 となります 型 名 配 列 変 数 名 1[] = { 値 1, 値 2,..; 型 名 配 列 変 数 名 2[] = { 値 1, 値 2,..; 型 名 配 列 変 数 名 [][] = { 配 列 変 数 名 1, 配 列 変 数 名 2; 別 途 作 成 された 配 列 を 値 のように 記 述 しています またさらに 次 のように 記 述 する 42

こともできます 型 名 配 列 変 数 名 [][] = {{ 値 1_1, 値 1_2,.., { 値 2_1, 値 2_2,..; 具 体 的 には 次 のように 記 述 します int num[][] = {{10, 8, 5, {9, 16, 4, {3, 7, 5; 通 常 の 配 列 では 値 をカンマ(,)で 区 切 って 記 述 していましたが 多 次 元 配 列 の 場 合 は 値 の 場 所 に 別 の 配 列 を 記 述 しています これは 次 のように 記 述 した 場 合 と 同 じです int num[][] = new int[2][3]; num[0][0] = 10; num[0][1] = 8; num[0][2] = 5; num[1][0] = 9; num[1][1] = 16; num[1][2] = 4; num[2][0] = 3; num[2][1] = 7; num[2][2] = 5; Java ではプログラムの 途 中 で 空 白 や 改 行 を 入 れることができますので 初 期 値 が 長 くなった 場 合 には 例 えば 次 のように 記 述 すると 分 かりやすいかもしれません int num[][] = { {10, 8, 5, {9, 16, 4, {3, 7, 5 ; 注 意 点 としては 通 常 の 配 列 と 同 じく 必 要 な 要 素 の 分 だけ 全 て 値 を 指 定 する 必 要 が あります 2.10.8 多 次 元 配 列 の 長 さ 多 次 元 配 列 の 場 合 も 配 列 変 数 名.length で 配 列 の 長 さを 取 得 することができます 配 列 変 数 名.length では 多 次 元 配 列 の 場 合 に 取 得 できる 値 を 確 認 してみます 次 の 例 を 見 てください int num[][] = {{1, 3, 5, {2, 4, 6; System.out.println(num.length); 43

多 次 元 配 列 における 要 素 の 数 なので この 場 合 は 2 と 出 力 されます もしも 要 素 として 代 入 されている 個 々の 配 列 の 要 素 数 を 取 得 したい 場 合 には 次 のように 要 素 に 対 して.length を 付 けて 取 得 して 下 さい 配 列 変 数 名 [インデックス].length 具 体 的 には 次 のように 記 述 します int num[][] = {{1, 3, 5, {2, 4, 6; System.out.println(num[0].length); System.out.println(num[1].length); この 場 合 は 多 次 元 配 列 の 要 素 に 代 入 されている 配 列 の 要 素 数 をそれぞれ 出 力 して いるため どちらも 3 と 出 力 されます 多 次 元 配 列 では 次 のページで 解 説 するように 要 素 に 代 入 する 配 列 の 長 さは 同 じで ある 必 要 がないため 各 要 素 に 代 入 されてる 配 列 の 長 さを 個 々に 取 得 する 必 要 がある 場 合 はこのように 多 次 元 配 列 名 [インデックス].length で 取 得 して 下 さい 参 考 資 料 (1) 丸 の 内 とら,いちばんやさしい Java 入 門, 技 術 評 論 社,2006 年 (2) 赤 間 世 紀,Java プログラミングの 基 礎 知 識, 技 報 堂,2002 年 インターネット (3) TATSUO IKURA,Java 入 門,JavaDrive(http://www.javadrive.jp/start/) (4) Eclipse で Java プログラミング 超 入 門, http://www.atmarkit.co.jp/ait/articles/0405/29/news021.html 44