Java Basic ミニゲーム作成〜コンソールゲーム〜

イントロダクション

コマンドプロンプト(Windows), ターミナル(Mac, Linux)で文字ベースでのゲームを作成しようと試みました。結局ゲームの内容までは届きませんでしたが、入力〜出力までの一連の流れを実装しました。

つまり、ゲームのイメージがあればこのまま完成まで行けるのでは？

別物ですが、こんなものも作ってみました。

Console app sanple....

Introduction

I will create a text based game on terminal or command prompt. But I implemented only from Input to output.

I mean if you have idea then you can implement game?

実際に作ったもの

作成したJarファイルはこちらです。ダウンロードして「java -jar ファイル名」の形でコマンドをたたいて動かすことができます。
コマンドプロンプトから起動してください。

Macの場合はターミナルです。コマンドは下のように使います。コマンドの実行例です。
ダウンロードしたディレクトリに移動

cd ダウンロードしたディレクトリ
java -jar ./CmdRpg.jarで起動することができます。
GitからプロジェクトをそのままPullしてきてもおっけ
プロジェクトのPull方法を参照してください。(Java Git clone in Eclipse 〜サンプルの取得〜)

ゲームの処理概要としては以下の様になります。ソースはこちら

/**
 * ゲームを起動する </br>
 * 標準入力の受付、「bye」コマンドでAPを終了する</br>
 *
 * @param args プログラム引数
 */
public static void main(String[] args) {
　　　// 初期化処理
　　　init();
　　　try {
　　　　　　// ゲーム起動(GameLoop開始)
　　　　　gameLoop();
　　　} catch(IOException ie) {
　　　　　　ie.printStackTrace();
　　　}
　　　// リソースの解放
　　　terminated();
}

このクラスは、どんどん拡張(追加で実装)できる様に
筆者なりに考えて作成いたしました。
これを土台にするもしないも自由にやってもらって結構です。

一応、記載しておきます。余計であれば読み飛ばしてください。

【考え方】

起動するメインメソッド→ゲームを起動する部分だけを記述したい。

Execute main method → I would like to write olnly game execution.

メインメソッドから呼び出したい(処理の範囲を切り分け)
処理を「staticメソッド」で定義。
処理を「初期化」
「ゲームループ」
「終了(リソース解放)」とカテゴリ分けをする。
静的メソッド(メインメソッドを含む)とメンバメソッドを切り分ける→
staticが付いているものとそうでないものを使用方法のサンプルとして記述

Static method is called by main method → separates implementation as “init”, “game loop”, “terminated”.

Separates static and member method→as sample for use these.

staticはメインメソッドから直接呼べる

メンバメソッドはインスタンスを作ってからでないと呼べない。

フィールドとか、クラスなど、実際にはどの様に使うの？
って部分をソースの方に記載しています。
※わかりずらかったらゴメンなさい

private static void gameLoop() throws IOException{
　　　// mainメソッドと同様にクラスをnewする必要あり
　　　game = new RpgMain();　// コンストラクタで入力部品を生成
　　　/*
　　　 *  <ゲームループ>
　　　 *  1.入力
　　　 *  2.データ更新、
　　　 *  3.レンダリング(今回はコマンドなので文字出力)　　　
　　　 *  4.「bye」コマンドでゲームを終了する
　　　 */
　　　　while(true) {
　　　　　　　　String command = game.listenInput();
　　　　　　　　// command変数がnullになる可能性があるため定数.equals()の形にする
　　　　　　　　if(TERMINATE_GAME.equals(command)) {
　　　　　　　　　　　　　break;
　　　　　　　　}
　　　　System.out.println("コマンド入力値: " + command);
　　　　}
}

プログラムの内容

ゲームを起動して、入力→「コマンド：入力値」を表示する
というシンプルなゲーム？です。
「bye」と入力するとゲーム終了となります。
ここで、コンストラクタを開設いたします。
コンストラクタ→newした時に起動する処理を定義する
メソッドの時と同じ様に引数を与えることができる。

詳細はおいおい理解していきましょう。

今回使用しているのは、
フィールド→staticのものとメンバフィールドがあります。
メソッド →フィールドに同じ、newしてから使用するのが「メンバ」
メインメソッドから呼ばれているのがstaticです。

ソースに細かいコメントなどをつけております。
参考になればと思います。

カスタムするなら

上記のソース赤字の部分を修正してどの様に入力を受けて何を表示するか？

を自分で考えて作成するのも１つの方法です。

ちなみに、簡単なコンソールゲームを作って見ました。
余計な音が入っています。

プラスαの一覧

JavaDoc

Java Discord

JavaFX

JUnit関連

Java Basic JUnit 〜テストスイートの作り方〜

Git

イントロダクション

インターフェース・クラスや、
ポリモーフィズムについて学習していきます。
ポリモーフィズムは、日本語で「多様性」と言う意味らしいです。
インターフェースクラスの前に通常のクラスについて理解したい場合は、こちらの記事を参照ください。

ポリモーフィズムの使用例

よく聞く「デザインパターン」と言うのはこのポリモーフィズムを応用した設計手法のことです。

#Java #Python #php #javascript #プログラミング #エンジニアと繋がりたい #駆け出しエンジニアと繋がりたい #PGボックス
【２週目】
23あるデザインパターンの1つ
Builderパターン
[意味]
動的なオブジェクトの生成を可能にするhttps://t.co/IpxkQVjUPE pic.twitter.com/E8MU1g4eFV

— たくのじ (@java_takunoji) March 6, 2023

＜インターフェースクラスの使い方サンプル＞

余談

JavaAPIの中にはすでに実装されています、
Listインターフェース・クラスにある。iterate()はイテレートパターンと言うデザインパターンの実装になります。

インターフェース・クラス

インターフェース・クラスに関してはListインターフェースがこれにあたります。まずはこのインターフェースクラスを見てみましょう。

List<String> list = new ArrayList<String>();

List<String> list = new LinkedList<String>();

上のように、別クラスを同じ型(クラス)変数として使用することができます。

これがまずは、基本的な考え方になります。これは、ArrayListがListインターフェイスをimplementsしているのでこのような使い方が出来ます。JavaDocを見ると他にも実装(implements)しているクラスを確認できます。

インターフェースクラスを作成すると、このインターフェースクラスを一つのグループとして使用することができます。

ListインターフェースクラスのJavaDocを見てみると「既知の実装クラス」の部分にあるクラスが実装(implements)しているクラスです。つまり1つのグループとして扱うことができるというわけです。

自作のインターフェースを使う

自作のインターフェースを使ってみます。
概要としては以下のようなクラスを用意します。

TestIF(インターフェース)
TestCls1(インターフェースの実装クラス)
TestCls2(インターフェースの実装クラス)

なお、各実装は以下のように定義します。作成したメソッドには処理の実体がありません。このようなメソッドを抽象メソッドと呼び、「abstract」をつけるのですが、インターフェイスクラスではつけなくても良いことになってます。その代わり抽象クラスを作った時は「abstract」を付ける必要があります。
＜TestIF＞

public interface TestIF {
    // 抽象メソッドを定義、処理の中身はなし
    public abstract void hello();
    // 上と同じように抽象メソッドの定義
    public void execute();
}

インターフェイスのメソッドをオーバライドして処理の実体を作成します。
＜TestCls1＞

public class TestCls1 implements TestIF {
    @Override
    public void hello() {
        System.out.println("Hello World");
    }
    @Override
    public void execute() {
        int ans = 1 + 1;
        System.out.println("足し算の結果: " + ans);
    }
}

＜TestCls2＞

public class TestCls2 implements TestIF {
    @Override
    public void hello() {
        System.out.println("Good morning World");
    }
    @Override
    public void execute() {
        int ans = 5 * 2;
        System.out.println("掛け算の結果: " + ans);
    }
}

これを、変数testに格納して起動してみます。コードは下のようなものです。

public static void main(String[] args) {
    // インターフェースクラスを宣言する
    TestIF test1 = new TestCls1();
    test1.hello();
    TestIF test2 = new TestCls2();
    test2.hello();
}

実行結果

それぞれ、「Hello World」と「Godd morning World」が表示されます。
このように、インターフェースクラスを使用して、一つのクラス型(データ型)でいろんな処理を実装することを「多様性」という意味の
ポリモーフィズムという言葉が使用されています。しかし、エンジニア同士の会話の中で認識を合わせるための言葉なので
自分なりのちゃんとした理解があれば、認識を合わせることができると思います。

「単語」にとらわれていると「スタティックおじさん」事件のように、カオス化してしまうので注意しましょう。

Gitにアップしたソースについて

作成したクラスなどは、Githubにアップしてあるのでそちらを参照ください。ルートになるフォルダはこちらになります。
作成したものjp.zenryoku.sample.basic.lv2パッケージになります。※上記のものと違っているかもしれません。

インターフェースの書き方

public interface インターフェース名 {
   /** 抽象メソッドの定義 */
   // implementsするクラスで処理内容を記述
   public abstract void execute();
　 // 上のメソッドと同じ(メソッド名は違う)
   public void setName();
}

クラスへの実装(implements)方法

public class クラス名 implements インターフェース {
   // クラスの記述
   // 上記の抽象メソッドを実装する
　 @Orverride
   public 抽象メソッド() {
      //処理
　 }
}

インターフェースを使用した。
サンプルコードには上記の実装方法を使用しています。
実際の使用の仕方はサンプルを見てください。

インターフェースを実装したクラスは、そのインターフェース型の
変数として使用することができます。
つまり、同じ名前のメソッドを呼び出した時に違う処理を実行することがでいます。
下の「action()」の実行結果が以下になります。
listにはPlayer型のクラスが設定されています。
処理詳細は、サンプルコードをご覧ください。

作成したインターフェースクラスを今後作成するクラスに実装(implements)することで、下のようなコードでどのクラスの「execute()」メソッドも実行することができます。

public void test() {
   // SomeClsにTestIFを実装(implements)した場合
   TestIF ttt = new SomeCls();
   ttt.execute();
   ttt.hello();
   // OtherClsにTestIFを実装(implements)した場合
   TestIF tt1 = new OtherCls();
   tt1.execute();
   tt1.hello();
}

CommandIFを使ったポリモーフィズム

CommandIFというインターフェースクラスを作成し、これを実装(implements)したクラスを、入力した文字列によって呼び出す形のプログラムを実装しました。参考にどうぞ

次回、これだけではわかりづらいかもしれないので
他もパターンも記載いたします。

Java Basic API Listインターフェイスの使い方〜Step2_2〜

Listの使い方

よく世間では「リスト」と言う言葉を使用します。「〜のリスト作っておいて！」などといったりします。しかし、左のリストとここでいうリストは別物で、JavaAPIにある「Listインターフェースクラス」のことです。

まずは実装してみたので、こんな感じかな？と言うのをみてもらうのが早いと思います。

このリストはJavaAPIに存在していて完全クラス名はjava.util.Listです、そして、詳細な説明があるJavaDocはこちらのリンク先にあります。

クラスと言いましたが、これは「インターフェース・クラス」実体のないクラスです。これは実体のあるクラスを格納できる変数だと思ってもらえれば、ある程度はわかりやすいと思います。そして、実体とは処理の中身のことをいいます。

更にういなら、実体のない時はメソッドの型のみで、実体のある時は中かっこがついてます。

Listインターフェース・クラス

List<String> list1 = new ArrayList<String>();

他にも下のような実装もできます。

List<String> list1 = new LinkedList<String>();

JavaDocにある既知の全ての実装クラスと言う部分に記載のあるクラスは同じように扱うことができます。

Listの扱い方

Listインターフェースクラスの実装に関して、既知の実装クラスでよく使用されるのが「ArrayList」クラスです。このクラスは、可変長配列の実装です。なので配列の長さを気にせずに、配列にデータを追加、削除することができます。
つまり、昔の配列は配列の長さを調節する処理が必要だったわけです。先人たちの苦労を無駄にしないようにクラスという形で残っていると思うと少し感慨深いですね。

Listインターフェースクラスのサンプル実装


public void test03() {
    // OK牧場(笑)
    List list = new ArrayList();
    list.add("test01");
    list.add("test02");
    list.add("test03");
    List list1 = new LinkedList();
    list1.add("public1");
    list1.add("public2");
    list1.add("public3");

    this.systemOut(list);
    this.systemOut(list1);
}
private void systemOut(List list) {
    // FOR文
    for(int i = 0; i < list.size(); i++) {
        System.out.println("リスト(" + i + "): " + list.get(i));
    }
    // 拡張FOR文
    for(String value : list) {
        System.out.println("リスト: " + value);
    }
}   ```
上記のように、扱い方は同じですが、微妙に違いがあります。

* ArrayList: サイズ変更可能な配列の実装です。※可変長配列
* LinkedList: 両端で要素の挿入および削除をサポートする線形コレクション

【配列の扱いあれこれ】
配列を使用して様々なデータを検証、編集など
色々な処理を行いますが何かと不便なこともあります。
String[] args = new String[5];
の様に初期化した場合→test01();
サンプルソースのダウンロードができます。
この場合は、配列の数が決まるので困る時があります。
例：標準入力を受けるとき
byte[] b = new byte[5];
System.in.read(b);
上記の場合は、5文字までを受け取ることができます。
少なかったり多かったりすると上手くないのです。。。
なので前回は、BufferedReaderを使用してそこを解消しました。
そこで、初めの配列(byte[] b)をString[], int[]などに変更した場合
かつ標準入力出ない場合はどうしたら良いでしょうか？
【Listクラスを使用する】
ここで、Listが出てきます。完全修飾名(完全クラス名)は
「java.util.List」クラスです。正しくはインターフェースクラスになります。
このインターフェースは以下のクラスに実装されています。
他にもあるけれど、使用頻度の高いものを記載します。
・java.util.ArrayListクラス(完全修飾名)
・java.util.LinckedListクラス(完全修飾名)
・java.util.Vectorクラス(完全修飾名)
これらのクラスにはclass名の後に「implements java.util.List」
が記載されています。
これが「実装する」という意味です。
// インターフェースの定義
public interface List { ....}の様に記載します。
実際のjava.util.Listインターフェースの内容は
Eclipseを使用しているならListの文字の上で「F3」を押下すると
ソースを見ることができます。
実際のインターフェース定義は以下になります。
public interface List<E> extends Collection<E> {
    // Query Operations
インターフェース定義でも「extends」とありますが

とりあえず置いておきます。
ではインターフェースって何？となると思います。

インターフェースはクラスに実装(implements)することにより

インターフェースで複数のクラスを一つの変数で扱えます。
例として、ListはArrayListとLickedListをListの変数で使用できます。

List<String> list = new ArrayList<String>();

// OK牧場(笑)

List<String> list1 = new LinkedList<String>();

の様に別のクラスでも同じ変数で使用することができます。

【追伸】

List<変数の型>の「変数の型」の部分は、ジェネリクスと言います。

コードが長くなってくるとこのリストの中身はなんだった？

とわからなくなってしまいます。それを解消したのがこの

「ジェネリクス」です。

その他Map, Set, Vectorなどで使用します。
でわでわ。。。

Java Basic クラスとは〜Step2_1〜

イントロダクション

Java言語での文法をちょっとやると「クラス」という言葉が出てきます。「インスタンス」とか、「オブジェクト」なんて言葉も一緒に出てきます。
これらの言葉は、目に見えないことが多く、初学者、ある程度学習した人でも認識が、あやふやになっていることが多いです。

しかし、難しく考えることはありません。いろんな人がいろんな言葉でモノを言うのでこんがらがりますが、シンプルに考えて問題ありません。
扱っているものは、所詮、機械なのですから。

クラスとは

今までに、書いてきた、プログラム(クラス)は下のようにmainメソッドだけでした。

public class AAA {
   public static void main(String[] args) {
   }
 }

なので、クラスをクラスとして使用していませんでした。

具体的にはクラスには以下の要素があり、それぞれの機能を持たせることができます。

１：フィールド変数
２：メソッド

これらを使用して現実にある様々なものを表現できます。

例えば、全てを表現すると難しいので、部分的に「ゲーム機」をクラスで表現しようとすると、下のようになります。

クラス名: 某社〇〇ッチ
フィールド変数: カセットを入れるソケット
メソッド：ボタンを押す、ボタンを離す、ボタンを長押しする

部分的ではありますが、このように表現できます。注意点としてはこれらの名前が複数あるというところです。C言語で表現するときは「フィールド変数」は「メンバ変数」、メソッドのことは「メンバメソッド」などのように言語による違いが「言葉の違い」になり、それがまた混乱のもとになっていると思います。

そして、フィールド変数とメソッドがあれば、それはクラスであり、それ以上でも、それ以下でもない。というところを認識してください。
いろんな人が、いろんなことを言うので混乱することが多いと思います。※筆者が若いころは混乱しました。。。

例えば人間を表現してみます。※ほんのさわり部分のみです

public class Human {
   /** 年齢 */
   private int age;
   /** 性別 */
   private int sex;
   /** 挨拶する */
   public void greet() {
       System.out.println("Hello!");
   }
}

人間にはその人の年齢があり、性別他にもたくさんありますが、それぞれ「人間」と言う生き物に共通する要素があります。
それを「フィールド変数」として定義してやります。
そして、取りうる行動を「メソッド」として表現することができます。

例えば自転車ならば。。。

public class Bicycle {
    /** ハンドルのサイズ */
    private double handleSize;
    /** 車輪のサイズ */
    private double wheelSize;
    /** スピード */
    private double speed;
    /** 停止しているフラグ */
    private boolean isStop;
    /** 自転車をこぐ */
    public double start(int power) {
       speed = power * wheelSize;
       isStop = false;
    }
    /** 自転車の動き */
    public void bicybleState() {
        // 何かしらの処理。。。
    }
}

とまぁキリがなくなってきたので、ここら辺で自転車の実装を終わりにしますが、つまるところは。。。

フィールド変数とメソッドがあれば、「現実にあるもの」を「クラス」として表現できる。※あくまでも「文字や言葉を使って表現できる」
言い方を変えると、属性と操作があれば、何でも表現することができる ※部分的になりますが。。。
ちなみに、「属性と操作」は日本語で、英語にするならば「アトリビュート(Attribute)とオペレーション(Operation)」になります。

日本語だと意味が広いから混乱してしまうように思いますので、英語(カタカナ)で理解するのもよい方法だと思います。

と言うところがクラスの存在意義です。
そして、クラスがJavaプログラミングの基本になります。
そして、実行してみました。コードはこちらにあります。

#### UML
ちなみに図で表現することもできます。それをUMLというものがありこのルールで記述したものは世界中のだれもが読めます。
下のような図です。
![](http://zenryokuservice.com/wp/wp-content/uploads/2022/03/ClassSample1.png)

### 初めのプログラムの解説

インスタンスとは

クラス(ファイルに記述したもの)の「コンストラクタ」の処理を通った後に出来る、オブジェクト。

<例>

ホームページにログインするとインスタンスが1個作られます。→ログイン処理でユーザーをあらわすクラスのコンストラクタでDBから取得した情報を保持します。この保持するためのオブジェクトの事をインスタンスと呼びます。

オブジェクトとは

構造体、クラスの事。データをセットしたり、ゲットしたり、何かの処理を行ったりします。構造体はクラスと同じ様な意味です。細かい所は混乱するので省きます。

オブジェクトはインスタンス化したもの。→コンストラクタを通ればオブジェクト。

<サンプルコード>

public class MyCls {
   //フィールド変数
   private String name;
   private int age;

   //コンストラクタ
   public MyCls() {
      this.age = 3;
   }

   //メソッド
   public void setName(String name) {
      this.name = name;
   }
}

カプセル化とは

上記の様にフィールドへのアクセス(name)にはクラスの外からアクセス出来なくする事MyCls.name = “”;はエラーになる。

ちなみにフィールドをpublic String name;と書くと外部からアクセス出来る。MyCls.name = “”;はエラーにならない

2. データと処理をひとまとめにして、「役割」を果たすために外部へ提供する機能と、内部で使用する機能を分けて作成したクラス

クラスの構成のコメントをつけております。

サンプルはこちら

/** 外部の提供されているクラスをインポートする */
package jp.zenryoku.sample.cls;
java.io.BufferedReader;
java.io.IOException;
java.io.InputStreamReader;

/**
* javaAPIの使い方
* <span class="s2">@author</span> <span class="s3">takunoji</span>
*/
// クラス定義
public class Step2_1 {
// フィールド変数：クラスの全てのメソッドからアクセスできる
private String FIELD_HENSU="クラスの外からはアクセスできません。";
public String FIELD_HENSU2="クラスの外からはアクセスできます。";

// メインメソッド（必ずこの書き方になる)
public static void main(String[] <span class="s4">args</span>) {
　　　　Step2_1 step = new Step2_1();
　　　　// 入力を受け取り切らない場合は次のStreamに読み込まれる
　　　　//123456step.arrayTest1();
　　　　step.arrayTest2();
}
// 自作のメソッド(メンバメソッドともいう)
public void arrayTest1() {
　　System.out.println("test1 入力開始");
　　// バイト型の配列をサイズ５で作成する
　　byte[] moji = new byte[5];
    // エラーハンドル用のくくり
　　try {
        // 標準入力から入力を受け取る
        System.in.read(moji);
　　} catch(Exception e) {
             e.printStackTrace();
　　}
    // 入力は「バイト型」のデータなのでString型(参照型)を生成する
　　System.out.println("入力じた文字:" + new String(moji));
}

public void arrayTest2() {
　　System.out.println("test2 入力開始");
　　// 読み込み用のクラスを宣言する<br/>
　　BufferedReader read;<br/>
    // InputSreamReaderからBufferedReaderを作成する
    // System.in→標準入力、読み込むために上のクラスでラッップ(包む)して
    // 使用する。ラップとは System.inをInputSreamReaderで包む(拡張)する
    // ことを言います。
    read = new BufferedReader(new InputStreamReader(System.in));
　　String line = "";
　　try {
        // BufferedReader.readLineメソッドで１行読む。<br/>
        // Fileなどを読み込む時にも使用する<br/>
        line = read.readLine();
　　　　} catch (IOException e) {
            e.printStackTrace();
　　　　}
        System.out.println("入力じた文字:" + line);
　　　　}
}

「public class クラス名」全ての人がアクセスできるクラスですよ、と定義する＝＞パブリック・スコープ
「private class クラス名」クラスの中からのみアクセスできるクラスと定義する＝＞プライベート・スコープ
「class クラス名」同じパッケージ内からアクセスできるクラスと定義する＝＞パッケージ・スコープ

「public 返却値メソッド名」クラスの外からもアクセスできるメソッド
「private 返却値メソッド名」クラスの中からのみアクセスできるメソッド

フィールド変数に関して、今回は使用していません。

Systemクラスについて
標準入力、出力、Javaの強制終了などJavaシステムの
基盤的なアプリケーションの機能を実装している。

クラス変数名 = new クラス名();という書き方では
メソッドを使用できません。→その様に実装しているからです。

#### Systemクラスの説明
クラス名：System
フィールド変数：out
フィールド変数(クラス)のメソッド：println()
※[PrintStreamクラスの詳細はJavaDoc](https://docs.oracle.com/javase/jp/8/docs/api/java/io/PrintStream.html)を見ます。
```
public final class System extends Object {
/** PrintStreamというクラス */
public static final PrintStream out;
}

```

スタティックメソッドはクラスをnewしないで直接
クラス名.メソッド名の形で呼び出します。System.out.println()の場合は
スタティックフィールドoutを直接呼び出していますので**System.out**になります。
そしてPrintStreamクラスのメソッドprintln()を使用している。というわけです。

## まとめ
Javaプログラムを動かすには「クラス」が必要で、クラスをnewすると、オブジェクト(インスタンス)ができて、メンバメソッドが呼び出せる。
そして、クラスには「フィールド変数」と「メソッド」が定義出来て、フィールド変数、メソッドを必ずしも定義しなくてもよい。
アクセス修飾子やstaticメソッド修飾子などもあり、クラスにアクセスする方法を分けることができる。

これらの基本ルールを土台にして、プログラムを組み上げて一つのアプリケーションを作成することができる。

#### LWJGLのデモ動画
マイクラでも使っているフレームワーク**LWJGL**というものがあります。これはJava言語でできています。

Java Basic try catch文〜Step1_3_3〜

イントロダクション

忘れ去られがちですが、エラーハンドル(エラー時に何をするかコントロールする)を行うのには、この文法が基本となります。

実装して動かしてみました。余計な音が入っています。

Exceptionの種類によりコントロールすことができます。コントロールと言ってもExceptionの種類によって処理をかえるというものです。
ちなみにしたの場合は、どんなエラーでもキャッチします。

具体的には、下のように「catch(Exception e)」と書くことですべての例外をキャッチします。


try {
    // 例外が予想される処理
    // throws文のあるメソッド呼び出し
} catch(Exception e) {
    // 例外の内容を表示
    e.printStackTrace();
}

参照するファイルが見つからないときの例外をキャッチしたいとき＋すべての例外をキャッチ。

try {
    // 例外が予想される処理
    // throws文のあるメソッド呼び出し
} catch(FileNotFoundException e) {
    // 例外の内容を表示
    e.printStackTrace();
} catch(Exception ex) {
    // 例外の内容を表示
    e.printStackTrace();
}

入出力関連のエラー(例外)をキャッチ＋すべての例外をキャッチ。

try {
    // 例外が予想される処理
    // throws文のあるメソッド呼び出し
} catch(IOException e) {
    // 例外の内容を表示
    e.printStackTrace();
} catch(Exception ex) {
    // 例外の内容を表示
    e.printStackTrace();
}

他にもあるのでそれに合わせたExceptionをキャッチしてやれば、どんな例外にも対応が可能！

ちなみにIF文と同じで、Exceptionをキャッチする行を上に持ってくると、下のキャッチ文に届きません。。。

try catch文

基本的な使い方としては、入出力や様々なところでエラーハンドルを行うために使用します。他にも「throw new Exception("メッセージ")」のように独自のメッセージを例外とともに投げることが出来ます。ちなみに「投げる」というのはthrowするという意味です。

実際には、どんな例外も受け取るExceptionクラスを使用しても良いのですが、個別に例外をキャッチするとエラーハンドルがやりやすいと思います。

try{処理}catch(例外の種類){エラー処理}のようにcatchの部分にキャッツする例外を記述します。

見やすくするとこんな感じ

スクリーンショット 2018-10-21 18.44.41.png

サンプルコードはこちら

実装例

try-catch文を場合分けして、サンプルコードを書きました。色々な例外クラスがあるのでJavaDocで調べてみるのも一つです。

例1：標準入力を受け取るのに例外が投げられる可能性がある時

入出力系の例外はIOExceptionでキャッチします。

// try部分に例が発生するメソッド処理を記載する 
try {
    System.in.read(b);
 } catch(IOException e) {
    // 例外が起きた時にはキャッチ文ところで処理
    e.printStackTrace();
 }

キャッチする例外を分けたい場合は
対応する例外クラスがJavaAPIにあるのでそれをキャッチするように
します。

例2: 例外を別々に受け取る

入出力系の例外とそのほかの例外を場合分けしてキャッチする実装です。

// 5バイト(5文字)分 byte[] b = new byte[5]; 
try {
    // 入出力の例外を投げる
    System.in.read(b);
 　　// 文字列を受け取る 
  String result = new String(b); 
  // 文字列に'a'が見つからない場合 
　if (result.indexOf("a") == -1) {
      // 例外を投げる 
    throw new Exception("入力違反です");
  }
 } catch(IOException ie) { 
   // 初めに標準入力の例外を受け取る様にする 
   ie.printStackTrace(); 
} catch(Exception e) { 
   // 自分で投げる例外をキャッチ  
   e.printStackTrace();
 }

ちなみに例外を扱う方法は他にもあって
メソッドで「例外をなげますよ」と指定する方法があります。

// Exceptionを投げる可能性があるメソッドを示す
public void testException() throws Exception {
  // 何かの処理
}

この時にはtry catch文は記載する必要がありませんが
このメソッドを呼び出す側がtry catchする必要があります。

そして、以下の様な場合はmainメソッドで例外を検知できません。

public static void main(String[] args) { 
   testPrint(); 
}  
/** 
 * メインメソッドから直接(クラスをnew しないで)呼び出す時 
 * はメソッドの修飾子に「static」をつける 
 */ 
public static void testPrint() { 
   try { 
      throw new Exception("必ず例外を投げます"); 
   } catch(Exception e) { 
     e.printStackTrace(); 
   }
}

呼び出し元に例外を検知させたくない場合に
上記の様な書き方を行います。

イントロダクション

Introduction

実際に作ったもの

【考え方】

staticはメインメソッドから直接呼べる

プログラムの内容

カスタムするなら

プラスαの一覧

JavaDoc

Java Discord

JavaFX

JUnit関連

Git

イントロダクション

ポリモーフィズムの使用例

余談

インターフェース・クラス

自作のインターフェースを使う

実行結果

Gitにアップしたソースについて

インターフェースの書き方

CommandIFを使ったポリモーフィズム

Listの使い方

Listインターフェース・クラス

Listの扱い方

【配列の扱いあれこれ】

【Listクラスを使用する】

イントロダクション

クラスとは

インスタンスとは

オブジェクトとは

カプセル化とは

関連ページ

イントロダクション

try catch文

実装例

例1： 標準入力を受け取るのに例外が投げられる可能性がある時

例2: 例外を別々に受け取る

関連ページ

関連ページ

例1：標準入力を受け取るのに例外が投げられる可能性がある時