Java Basic 中級編 ~③メインメソッドを修正しないで拡張する~

イントロダクション

前回は、メインメソッドを修正しない形での実装を行いました。

この段階では、まだ役割分担を行っただけでこれがどんな効果があるのか?というところがわからないと思います。

なので、今回は、「〇×あてゲーム」を拡張することを考えていきたいと思います。
作成したプログラムコードはGithubにアップしてあります。

メインメソッドを修正しないで拡張する

今までに「役割分担」を行ったので、この役割分担を活用していきます。
Lv2Mainクラスはメインメソッドを動かすクラスなので、これ以外のクラスを実装していきます。

  • Lv2Main
  • MarubatsuConsole
  • MarubatsuUtils

Lv2Mainを見る

まずは、メインメソッドを見てみます。Lv2Main

/**
 * Javaの基本レベル2:小さなレベルのプログラムを拡張する。
 * 今回は、〇か×か当てるゲーム。
 */
public class Lv2Main {
    /** 終了フラグ */
    private static boolean isFinish;

    public static void main(String[] arg) {
        isFinish = false;
        // 標準入力を受け取るクラスをインスタンス化
        Scanner scan = MarubatsuUtils.getScanner();

        while (true) {
            // ゲーム開始文言
            MarubatsuConsole.printGameStart();
            // 標準入力を受け取る
            int input = scan.nextInt();
            // isFinishがtrueならば処理終了。
            if (isFinish) {
                MarubatsuConsole.printTerminated();
                break;
            }
            // 0か1の値を返却する
            int res = MarubatsuUtils.nextInt(2);

            // 0: 〇 1: ×で当たったかどうかの判定
            boolean isAtari = MarubatsuUtils.judgeAtariOrNot(res, input);
            MarubatsuConsole.printAtatiorNot(isAtari, input);

            // 続けるのかどうか判定する
            if (MarubatsuConsole.printNextPlayOrNot(scan)) {
                break;
            }
        }
    }
}

コメントを並べただけですが、以下の順序で処理を行っています。

  1. 標準入力を受け取るクラスをインスタンス化
  2. ゲーム開始文言
  3. 標準入力を受け取る
  4. isFinishがtrueならば処理終了。
  5. 0か1の値を返却する
  6. 0: 〇 1: ×で当たったかどうかの判定
  7. 続けるのかどうか判定する

上の番号で行くと2~7がループ処理の中にあります。
なので、7の「続けるか判定する」部分でNo(続けない)を選択するまで無限ループします。

拡張ポイントを見つける

そして、役割分担を行ったところ、つまりは、下のクラスを使用している部分が拡張ポイントになります。
Githubにアップしてあります。

具体的には、以下のコメント部分です。

  • ゲーム開始文言
  • isFinishがtrueならば処理終了。の終了表示部分
  • 0か1の値を返却する
  • 0: 〇 1: ×で当たったかどうかの判定
  • 続けるのかどうか判定する

もしも、他の部分を拡張したいと思たのならば、メインメソッドを少し修正する必要があります。
何かの処理をほかのクラスに任せてある状態(MarubatsuConsole, MarubatsuUtilsを使用している状態)ならば
メインメソッドを修正する必要がありません。
しかし、直接メインメソッドを修正する必要がある場合はやはり、修正する必要があります。

このような実装方法を理解すると、下のようなプログラムが作れます。

※ビルドするのに3分くらい時間がかかっています。
このプログラムは、メインの処理部分も、別クラスにしているので、まったく別のプログラムを起動するように修正することもできます。
しかし、現状では、テキストRPGを作成するところに注力しているので役割分担を行いそれぞれの役割を拡張して実装しています。
具体的には、テキストファイルを読み、それをもとにデータ(ステータスやアイテム)を生成してそれをゲームの中で使用する形での実装を行っております。
ちょっと残骸が残っていますが。。。

拡張するとき

先に示したように、別のクラスを呼び出している(使用している)部分を拡張、つまり処理を追加することができるので、次の部分を拡張することができます。

  • ゲーム開始文言
  • isFinishがtrueならば処理終了。の終了表示部分
  • 0か1の値を返却する
  • 0: 〇 1: ×で当たったかどうかの判定
  • 続けるのかどうか判定する

具体的には、ゲーム開始文言を変更することができる。とか、当たったかどうかの履歴を付ける。とか
そこらへんは、実装者のアイディア次第でどこまでも広げることができます。

ゲームの開始文言を変更する

先ほど、拡張する例としてゲームの開始文言を変更するということを上げました。これを実際にやってみます。

やっている手順としては、以下の通りです。

  1. JUnitテストケースの作成
  2. 現状のプログラム実行確認
  3. プログラムの修正、実行確認(目視で確認)

最後の実行確認(目視で確認)に関しては、すべてプログラムで確認することができます。
そのためには、ちょっと面倒なことをする必要があるので、割愛しました。
具体的には標準出力の出力先を変更して(別のPrintStreamを使用)そのストリーム内の出力内容と期待値を比較するという形になります。

現状としては、単純に〇×あてゲームの初期表示文言を変更するだけなので、目視で確認しました。

0: 〇 1: ×で当たったかどうかの判定

この部分は上記の動画では、挙動がおかしくなっていました。なので、これを修正し想定通りの実行結果が得られるようにプログラムを修正します。

実行した結果は下のようになります。

******************************
*「〇×あてゲーム」 0: 〇 1: ×。 *
******************************
※0は「〇」を表し1は「×」を表します。
1
はずれ:×
続けますか? 0: 続ける  1: やめる
0
******************************
*「〇×あてゲーム」 0: 〇 1: ×。 *
******************************
※0は「〇」を表し1は「×」を表します。
1
はずれ:×
続けますか? 0: 続ける  1: やめる
1

その前に、問題点を明確にします。

今回の問題点は「あたりのときの値、つまりは、『〇』が当たりなのか?『×』が当たりなのか?」が明確でないというところです。
なので、これも修正します。

先ほどと同じようにまずは、修正ポイント(先ほどは拡張ポイントと記載しました。)を見つけます。
実行結果を見ると、「はずれ:×」のように当たりはどちらなのか?がわからない状態ですので、これを明確にします。

具体的には、「「〇」があたりです。「×」が当たりですなどの文言を表示するように修正」する形で対応しようと考えております。

当然、他に良いアイディアがあれば、それを実装するとよいと思います。

当たり判定処理の修正

今回作成した「当たり判定処理」は、MarubatsuUtils#judgeAtariOrNotで実装しているのでこれを修正します。

現状のプログラムは下のようになっています。

    /**
     * 生成した乱数と、入力値が等しいか判定する。
     *
     * @param res 生成した乱数
     * @param input 入力値
     * @return true: 等しい false: 違う
     */
    public static boolean judgeAtariOrNot(int res, int input) {
        // 0: 〇 1: ×で当たったかどうかの判定
        return res == input;
    }

このプログラムの問題点は、〇と×のどちらが当たりなのか表示されない点です。
なので、これを表示するようにプログラムを修正する必要があります。

テストケースを作成する

先ほど初期表示の文言を表示するテストケースを作成しました。
これに追加して、「〇と×のどちらが当たりなのか表示する」テストケースを実装します。

仕様から考える

今回の要件(どのように動いたらよいか?)は「〇と×のどちらが当たりなのか表示する」ということです。
これを確かめるプログラムを考えます。

確認項目をリストアップ

  1. あたりは「〇」「×」どちらか表示する
  2. 予想を入力したユーザーの入力は「〇」「×」どちらか表示する

簡単ですが、2項目になります。

これもテストケースを作成する

ちなみに、このクラスのテストケースは以前、他のテストケースを作成していたので、これに今回のテストケースを追加します。

やったことは、同じです。

  1. 現状のプログラム実行確認
  2. プログラムの修正
  3. プログラムの実行確認

ちょっと長めの動画になりましたが、行ったことをそのまま動画にしてあります。
ポイントとしては、テストケースのプログラムの実装、作成方法、考え方(この記事に記載)を実際に行った
動画にしてあります。
別な言い方をすると、自分がこの作業を行ったものを動画にしました。

でわでわ。。。

Java Basic 中級編 ~②メインメソッドを修正しない形を作る~

イントロダクション

前回アプリケーションを作り、それを運用すること、拡張することについて考えてみました。

まとめると次のようなことが必要になるということを記載しました。

  • 各プログラム間(Javaのクラス同士)の依存度を限りなく低くする。
  • プログラムを拡張するのに、元のプログラムをほとんど変更しない。
  • Javaを使えるレベルの知識(技術)がある人なら、誰が見てもわかるようなコードを書く。
  • 各クラス(部品)の単体テスト(UnitTest)ケースを用意しておき、修正したら即テスト、部品を取り換えるだけでよいように、作成した資源(プログラムのコード)を結合テスト・総合テストと実施できるような体制を整える

今回は、プログラムを拡張していくための基本になる考え方と実践方法について記載していきたいと思っています。
例として「〇×あてゲーム」を拡張していく形でプログラム(クラス)間の依存度を低くした形のプログラミング方法について記載していきたいと思います。

メインメソッドを修正しない形を作る

前回作成したプログラムは下のものになります。

public class Lv2Main {
    /** 終了フラグ */
    private static boolean isFinish;

    public static void main(String[] arg) {
        isFinish = false;
        // 標準入力を受け取るクラスをインスタンス化
        Scanner scan = new Scanner(System.in);

        while (true) {
            System.out.println("「〇×あてゲーム」 0: 〇 1: ×。");
            // 標準入力を受け取る
            int input = scan.nextInt();
            // isFinishがtrueならば処理終了。
            if (isFinish) {
                System.out.println("プログラムを終了します。");
                break;
            }
            // 0か1の値を返却する
            Random rdm = new Random();
            int res = rdm.nextInt(1);

            // 0: 〇 1: ×で当たったかどうかの判定
            boolean isAtari = res == input;
            String value = input == 0 ? "〇" : "×";
            if (isAtari) {
                System.out.println("あたり:" + value);
            } else {
                System.out.println("はずれ:" + value);
            }
            System.out.println("続けますか? 0: 続ける  1: やめる");
            int next = scan.nextInt();
            if (next == 1) {
                break;
            }
        }
    }
}

この状態のプログラムはよく見かける。。。と思われる形のプログラムです。
つまりは、処理を1つのファイル内にすべて書いている形のプログラムということです。

このブログ的に表現すると「Javaの基本:上巻」に当たるプログラムの書き方になります。

「Javaの基本:下巻」に当たるプログラムの書き方はこれから説明していきます。

Step1. 役割分担を行う

上のプログラムで行っていることを、例えばチームで作業をするように、役割分担を行いそれぞれのクラスにそれぞれの役割を与えます。

例えば、次のような役割分担を行います。

  1. 〇×あてゲームを起動する役割
  2. 標準入力を受け取る、などの標準入出力をコントロールする役割
  3. 〇×あてゲームの各種判定を行う役割

もともとのプログラムは、全部の処理が書いてあるので、これを切り貼りして改造します。

1-2. クラスを作成する

上記の通り、2つの役割を担当するクラスを作成します。

  1. 〇×あてゲームを起動する役割:Lv2Main ※作成済み
  2. 標準入力を受け取る、などの標準入出力をコントロールする役割: MarubatsuConsole
  3. 〇×あてゲームの各種判定、ユーティリティの提供を行う役割: MarubatsuUtils

これらのクラスに必要な処理を切り貼りして、各クラスに移植します。
その結果を以下に記載致します。

※リンクはGithubにアップしたコードです。
Lv2Main

package jp.zenryoku.tutorial.level2;

import java.util.Scanner;

/**
 * Javaの基本レベル2:小さなレベルのプログラムを拡張する。
 * 今回は、〇か×か当てるゲーム。
 */
public class Lv2Main {
    /** 終了フラグ */
    private static boolean isFinish;

    public static void main(String[] arg) {
        isFinish = false;
        // 標準入力を受け取るクラスをインスタンス化
        Scanner scan = MarubatsuUtils.getScanner();

        while (true) {
            // ゲーム開始文言
            MarubatsuConsole.printGameStart();
            // 標準入力を受け取る
            int input = scan.nextInt();
            // isFinishがtrueならば処理終了。
            if (isFinish) {
                MarubatsuConsole.printTerminated();
                break;
            }
            // 0か1の値を返却する
            int res = MarubatsuUtils.nextInt(2);

            // 0: 〇 1: ×で当たったかどうかの判定
            boolean isAtari = MarubatsuUtils.judgeAtariOrNot(res, input);
            MarubatsuConsole.printAtatiorNot(isAtari, input);

            // 続けるのかどうか判定する
            if (MarubatsuConsole.printNextPlayOrNot(scan)) {
                break;
            }
        }
    }
}

MarubatsuConsole>※修正した後のコードがアップしてあります。

package jp.zenryoku.tutorial.level2;

import java.util.Scanner;

public class MarubatsuConsole {
    /**
     * 〇×あてゲームの開始文言を表示
     */
    public static void printGameStart() {
        System.out.println("「〇×あてゲーム」 0: 〇 1: ×。");
    }

    /**
     * 〇×あてゲームの終了文言を表示
     */
    public static void printTerminated() {
        System.out.println("プログラムを終了します。");
    }

    /**
     * 当たったかどうかを表示する。
     * @param isAtari 当たり判定の結果
     */
    public static void printAtatiorNot(boolean isAtari, int input) {
        String value = input == 0 ? "〇" : "×";
        if (isAtari) {
            System.out.println("あたり:" + value);
        } else {
            System.out.println("はずれ:" + value);
        }
    }

    /**
     * 〇×あてゲームを続けるかを表示、Yes or Noを取得する
     * @param scan
     * @return true: 続ける  false: やめる
     */
    public static boolean printNextPlayOrNot(Scanner scan) {
        boolean playNext = false;
        System.out.println("続けますか? 0: 続ける  1: やめる");
        int next = scan.nextInt();
        if (next == 1) {
            playNext = true;
        }
        return playNext;
    }
}

MarubatsuUtils>※修正した後のコードがアップしてあります。

package jp.zenryoku.tutorial.level2;

import java.util.Random;
import java.util.Scanner;

public class MarubatsuUtils {
    /** 標準入力を受け取るクラス */
    private static Scanner scan;
    /** 乱数の生成クラス */
    private static Random rdm;

    /**
     * 標準入力を受け取るクラスを生成、取得する。
     * ※シングルトン実装
     * @return Scanner
     */
    public static Scanner getScanner() {
        if (scan == null) {
            scan = new Scanner(System.in);
        }
        return scan;
    }

    /**
     * 乱数生成クラスがインスタンス化されていなければ、インスタンス化します。
     * すでにインスタンス化しているときは、既存のインスタンスを使用します。
     * ※シングルトン実装
     *
     * @param bound
     * @return 生成した乱数
     * @see <a href="https://docs.oracle.com/javase/jp/8/docs/api/java/util/Random.html">Random</a>
     */
    public static int nextInt(int bound) {
        if (rdm == null) {
             rdm = new Random();
        }
        return rdm.nextInt(bound);
    }

    /**
     * 生成した乱数と、入力値が等しいか判定する。
     *
     * @param res 生成した乱数
     * @param input 入力値
     * @return true: 等しい false: 違う
     */
    public static boolean judgeAtariOrNot(int res, int input) {
        // 0: 〇 1: ×で当たったかどうかの判定
        return res == input;
    }

}

メインメソッドは、すっきりしたコードになったと思います。

メインメソッドでは、どんな処理をしているかが一目瞭然になり。各クラスはその処理だけが書いてある形になります。

もちろん、引数と返り血があるので、呼び出し元に多少なりとも影響が出ます。

しかし、これでメインメソッドを変更しなくても〇×あてゲームを拡張する準備ができました。

ポイント

メインメソッドには、大まかな処理の順序を書く。具体的には下のような形です。

// <無限ループ開始>
// ■ゲーム開始文言を表示
// ■標準入力を受け取る
// ■isFinishがtrueならば処理終了。
// ■0か1の値を返却する
// ■0: 〇 1: ×で当たったかどうかの判定
// ■続けるのかどうか判定する

<やったこと>

  1. これらの処理をはじめの状態では、すべてLv2Mainクラスに記述していましたが、これをクラス別に分けました。
  2. 作成した各クラスをメインメソッドで呼び出して実行する。この時に初めの動きと変わらないことを確認しました。

これにより、プログラムのコードがすっきりして(したと自分は思います。。。)、メインメソッドを修正しなくても次の部分の処理が、修正が可能になりました。

1. ■ゲーム開始文言を表示: MarubatsuConsoleの修正
2. ■標準入力を受け取る: MarubatsuUtilsの修正
3. ■0か1の値を返却する: MarubatsuUtilsの修正
4. ■0: 〇 1: ×で当たったかどうかの判定: MarubatsuUtilsの修正
5. ■続けるのかどうか判定する: MarubatsuConsoleの修正

「そのように作ったんだから当たり前だろ?」と思った方、正常でございます。
このような作り方が、クラスを拡張する、アプリケーションを拡張するときに、役立つのです。

今回の「〇×あてゲーム」のような小さなレベルのプログラムはファイル一枚で何も問題はありませんが、会社の業務で使用するような大きなアプリケーションでは、いろんな機能が必要なので、役割分担を行い、機能拡張がしやすい形で、プログラムを組んでいきます。

拡張する準備をする

初めに「必要になること」について記載したのですが、触れていない部分があります。次の部分です。

  • 各クラス(部品)の単体テスト(UnitTest)ケースを用意しておき、修正したら即テスト、部品を取り換えるだけでよいように、作成した資源(プログラムのコード)を結合テスト・総合テストと実施できるような体制を整える

具体的にどのようなことか?これについて、記載したいと思います。

JavaならばJUnit

JavaのテスティングフレームワークといえばJUnitです。
具体的に、どのように使うか記載したいと思います。

役割分担をしたクラスのテストクラス作成

作成した各クラスのテストケースを作成するためのクラスを作成します。
クラス名は、「対象のクラス名 + Test」の形で作成します。

  • MarubatsuConsole: MarubatsuConsoleTest
  • MarubatsuUtils : MarubatsuUtilsTest

作成したコードは次の通りです。ただし、MarubatsuConsoleTestは、標準出力の内容を取得して。。。とちょっと面倒なので、今回は実装しません。

<JUnit実行結果>

package jp.zenryoku.tutorial.level2;

import org.junit.jupiter.api.Test;

import java.util.Scanner;

import static org.hamcrest.core.Is.is;
import static org.junit.jupiter.api.Assertions.*;
import static org.junit.matchers.JUnitMatchers.either;

public class MarubatsuUtilsTest {
    /** テスト対象クラス(全てstaticメソッドなのでインスタンス不要) */
    private static MarubatsuUtils target;

    @Test
    public void testGetScanner() {
        Scanner scan = MarubatsuUtils.getScanner();
        // インスタンスが取得できていることを確認
        assertNotNull(scan);
    }
    @Test
    public void testNextInt() {
        int res = MarubatsuUtils.nextInt(2);
        // インスタンスが取得できていることを確認
        boolean isRondom = res == 0 || res == 1;
        assertTrue(isRondom);
    }

    @Test
    public void testIsAtari() {
        assertTrue(MarubatsuUtils.judgeAtariOrNot(0, 0));
        assertTrue(MarubatsuUtils.judgeAtariOrNot(1, 1));

        assertFalse(MarubatsuUtils.judgeAtariOrNot(0, 1));
        assertFalse(MarubatsuUtils.judgeAtariOrNot(1, 0));
    }
}

でわでわ。。。

Java Basic 中級編 ~①アプリケーション設計を考える~

イントロダクション

Javaの基本文法が理解できたところで、実際に動くものを作ってみたいと思うのが人情だと思います。
基本文法だけでも、簡単なプログラムを作ることができます。
例えば、下のようなものです。

単純なゲームループ

1. アプリケーションを作るために

今までに、Javaの基本を学習してきました。大まかに次のようなことを学習しました。

  1. メインメソッドを動かすこと
  2. Stringやintなどのデータ型があり、それぞれに意味があること
  3. 条件分岐、繰り返しなどの文法(if文、switch, while, forなど)
  4. 自分で作ったクラスもデータ型として宣言することが出来て、呼び出す(動かす)事ができること
  5. JavaAPIで提供しているクラス(java.lang.Math, java.util.Scannerなど)を使用できること

これらのことを、このブログでは「Java Basic」と呼んでいました。

この基本に対して1段上の領域があります。それは「オブジェクト指向」と呼ばれている考え方なのですが、これの解釈が人によって千差万別なので、この言葉は使わないようにしようと考えております。

2. アプリケーションを作り運用することも考える

どちらかといえば、「エクストリーム・プログラミング」のほうが近いように思います。

エクトリーム・プログラミングに関しては上記のリンク先を参照してください。
早い話が、次のようなものです。

ソフトウェア品質 を向上させ、変化する顧客の要求への対応力を高めることを目的としたソフトウェア開発プロセスである。アジャイルソフトウェア開発の一つとして、短い開発サイクルで頻繁に「リリース」することを推奨することで、生産性を向上させ、新しい顧客の要求を採用するためのチェックポイントを導入することを意図している。

これを実現するために、次のようなことが求められます。

  • 各プログラム間(Javaのクラス同士)の依存度を限りなく低くする。
  • プログラムを拡張するのに、元のプログラムをほとんど変更しない。
  • Javaを使えるレベルの知識(技術)がある人なら、誰が見てもわかるようなコードを書く。
  • 各クラス(部品)の単体テスト(UnitTest)ケースを用意しておき、修正したら即テスト、部品を取り換えるだけでよいように、作成した資源(プログラムのコード)を結合テスト・総合テストと実施できるような体制を整える

個人で実現するのは、結構な苦労ですが、一人でアプリのリリースまでやろうと考えるならやっておきたいところです。

3. 基本が大前提

Javaでなくてもそうですが、基本ができないと応用はできません。
基本というのは、上記でいうところの「Java Basic」は、たとえて言うならば、「Javaの基本」という本の上巻に当たります

「じゃ、実際どの部分が基本なの?」という疑問が出ると思います。
これは、自分の見解ですが、下のように考えています。

つまりは、Javaだけでなくプログラミングの基本には次のような段階があると思うということです。

  • 「Javaの基本:上巻」は小さなレベルのプログラム(アプリケーション)が作れるレベルの基本。
  • 「Javaの基本:下巻」は小さなレベルのプログラムを拡張して、どんどん新しい機能を追加していけるレベルの基本

今後は、「Javaの基本」という本の下巻に当たる部分を学習します。

今までの学習方法(古い時代の学習方法だと思います。。。)は、とりあえず何かしらのアプリケーションを組み続けてそこから、自分で上にも書きましたが、次のことを理解していきました。

  • 各プログラム間(Javaのクラス同士)の依存度を限りなく低くする。
  • プログラムを拡張するのに、元のプログラムをほとんど変更しない。
  • Javaを使えるレベルの知識(技術)がある人なら、誰が見てもわかるようなコードを書く。
  • 各クラス(部品)の単体テスト(UnitTest)ケースを用意しておき、修正したら即テスト、部品を取り換えるだけでよいように、作成した資源(プログラムのコード)を結合テスト・総合テストと実施できるような体制を整える

これらのようなことを理解するのには、自分の場合、大体3年くらいかかりました。
あくまでも、基本が理解できたというレベルです。

そこから、このような基本を応用し、実践していくことが必要になりますが、それこそは実際にやってみるしかありません。

基本ができたら、そこから先は自分の作りたいものをどんどん作っていくということが最大の課題になると思います。自分も時間を見つけてやっています。いまだに完成までいかないものがあります。。。

やはり、「モチベーションの維持と、健康の維持」が大きな課題となります。

4. 小さなレベルのプログラムを拡張する

先ほどから、「小さなレベルのプログラムを拡張する」と記載していますが、これは一体どういうことなのか?これについて、記載したいと思います。

基本はプログラムを修正しない

小さなレベルのプログラムを拡張するときに、なるべくプログラムを修正しないようにプログラムを組んでいくというところが、このレベルでの基本になります。
それには、クラスとクラスの関係をうまく作るということがカギになるのですが、具体的なコードを見ていくほうが早いので、サンプルコードを見ていきましょう。

〇×あてゲーム

単純なアプリケーション「〇×あてゲーム」を作成しました。下のようなコードで動きました。
※コードはGithubにあります

/**
 * Javaの基本レベル2:小さなレベルのプログラムを拡張する。
 * 今回は、〇か×か当てるゲーム。
 */
public class Lv2Main {
    /** 週r等フラグ */
    private static boolean isFinish;

    public static void main(String[] arg) {
        isFinish = false;
        // 標準入力を受け取るクラスをインスタンス化
        Scanner scan = new Scanner(System.in);

        while (true) {
            System.out.println("「〇×あてゲーム」 0: 〇 1: ×。");
            // 標準入力を受け取る
            int input = scan.nextInt();
            // isFinishがtrueならば処理終了。
            if (isFinish) {
                System.out.println("プログラムを終了します。");
                break;
            }
            // 0か1の値を返却する
            Random rdm = new Random();
            int res = rdm.nextInt(2);

            // 0: 〇 1: ×で当たったかどうかの判定
            boolean isAtari = res == input;
            String value = input == 0 ? "〇" : "×";
            if (isAtari) {
                System.out.println("あたり:" + value);
            } else {
                System.out.println("はずれ:" + value);
            }
            System.out.println("続けますか? 0: 続ける  1: やめる");
            int next = scan.nextInt();
            if (next == 1) {
                break;
            }
        }
    }
}

次回

このプログラムをなるべく修正しなくても機能拡張できるように修正していきます。
現状のプログラムは、修正しようとしたら必ずメインメソッドを修正する必要があります。これを解消するために試行錯誤します。

でわでわ。。。

Java SpringBoot + Thymeleaf 画面を作成する ~ControllerからHTMLまで~

イントロダクション

前回はSpringBootでの開発セットアップを行いました。

前回の状態では、エラーページしか確認できませんでした。

これは、サーバーが起動していることを確認するという意味で、必要な確認なのですが。。。動かないのでは面白くありません。

SpringBoot + Thymeleafで画面を作る

毎度おなじみ、「ハローワールド」をやってみようと思います。

作成するもの

  1. Javaファイル(コントローラークラス)
  2. HTMLファイル(Thymeleaf使用)

コントローラークラスを作る

まずは、作成して動かすことに注力します。
プロジェクトを作成したら初めに「SampleWebAppApplication」というクラスが作成されていると思います。

このクラスがアプリケーションを起動するクラスです。しかし、このクラスはいじる必要がありません

Controllerがアプリを動かすために

自動生成された「SampleWebAppApplication」はアプリケーションを起動するためのクラスなので、本当にアプリを起動するだけなのです。

起動確認するときに、エラーページしか出ないのは表示するものが何もないからです。

それでは、早速コントローラークラスを作成します。まずは、ルールがあるのでそれに注意します。
先ほど自動生成されたクラス「SampleWebAppApplication」はパッケージ「com.example.demo」というパッケージに作成されています。

パッケージはウィンドウズでいうところの「フォルダ」に相当します。上に貼り付けているものは、パッケージを表示していいます。

一番上にある「src/main/java .... 」の部分はフォルダ構成上下のようになっています。

  1. プロジェクトのフォルダがあります。
  2. その中に、srcというフォルダがあります。
  3. 同様にmainというフォルダ
  4. javaというフォルダ
  5. そして、ここからが「パッケージ」と呼ばれるフォルダになります。「com」フォルダ
  6. 「example」フォルダ
  7. 「demo」フォルダ

このようにフォルダ構成が出来上がってるのですが、これを「パッケージ」と呼び下のように表現することで、どのファイルのクラスを参照するかわかるようにしています。
Javaのプログラムでいうと「インポート文」がそれにあたります。

import con.example.demo.*;

上のインポート文は「con.example.demo」パッケージにあるクラスを全てインポートするという意味です。

Controllerのみで動かす

パッケージに関して意味が分かったところで、上記で記載した「ルール」に関してお話ししたいと思います。
自動生成されたクラス「SampleWebAppApplication」よりも下のパッケージ内にコントローラーなどの読み込むクラスを作成するというルールがあります。

なので、今回作成するコントローラークラスはパッケージ「com.example.demo.controller」に作成することにします。
パッケージの作成方法は下のように行います。

  1. 作成するパッケージの親になるパッケージを右クリック※com.example.demoパッケージを右クリックしました。
  2. そして、「パッケージ」という文言が見つかればよいのですが、残念ながら表示されていませんので「その他」をクリックします。すると下のようなウィンドウが開きます。
  3. そこでパッケージを選択してやれば作成できるというところです。

さらに、ここからクラスも作成します。手順は上と同じですが、選択するものが「クラス」になります。

そして、ここでは「HelloController」というクラスを作成します。

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

@RestController
public class HelloController {

    @RequestMapping("/")
    public String index(ModelAndView mav) {
        return "Hello World";
    }
}

<表示結果>

ここでは、HTMLの作成は必要がありません。

実は、上記の「@RequestMapping」アノテーションを付けたメソッドは返却文字列を指定した場合はHTMLになります。なので下のようにコードを変更してやると。。。

@RequestMapping("/")
public String index(ModelAndView mav) {
    return "<html>"
            + "<title>Hello World</title>"
            + "<body><h1>こんにちは</h1>"
            + "<p>~PGボックスより~</p>"
            + "</body>"
            + "</html>";
}

<表示結果>

このように表示できます。しかし、「もっとオシャレに!」「もっと機能的に!」ということを考えるとHTMLファイルを使用して動かした方が効率的です。

もちろん、ウェブデザイナーさんの協力を頂き、その実力を発揮してもらうならナチュラルなHTMLがベストです。JSPなどは専門外のはず。。。

HTMLを作成する

そこで「Thymeleaf」というフレームワークを使用します。これはコントローラーとHTMLを橋渡しするためのフレームワークです。
具体的に見ていきましょう。まずはHTMLをみてみましょう。

<!DOCTYPE html>
<html>
<head lang="ja" xmlns="http://www.thymeleaf.org">
    <meta charset="UTF-8">
    <title>Sample Index Page</title>
</head>
<body>
    <h1>Recommended index</h1>
    <p>おススメの漫画・アニメを検索できます。</p>

</body>
</html>

上のようなHTMLを作成します。この状態ではコントローラーとのやり取りがない状態です。
しかし、まずはこの状態で動かしてみます。作成したHTMLファイルは「src/main/resources/templates」フォルダの下に作成しましょう。

そして、コントローラーも書き換えます。

@RequestMapping("/")
public ModelAndView index(ModelAndView mav) {
    mav.setViewName("book");
    return mav;
}

<実行結果>

このように動いたところで、コントローラーから値を渡すことを考えます。

コントローラーからHTMLへ。。。

今回のJavaプログラムはサーバーサイド・プログラムなので(※クライアントでも動かすことができます。)サーバー側での処理を行うことができますが、クライアント(ブラウザ上)でのプログラムはJSとかHTMLに任せることになります。

なので、サーバーでの処理結果をクライアントに渡すにはちょっとテクニックが必要になります。
具体的には、以下の通りです。

  1. リクエストパラメータを使用する
  2. レスポンスに処理結果を埋め込む(渡す)

こんなことを言われても「???」となってしまう人は正常です。ご安心ください。

具体的に下のようなコードで処理の結果を渡します。プログラムは微妙に修正しています。
<Java>

@RequestMapping("/")
public ModelAndView index(ModelAndView mav) {
    mav.setViewName("book");
    mav.addObject("key", 12);
    return mav;
}

<HTML>

<!DOCTYPE html>
<html>
<head lang="ja" xmlns="http://www.thymeleaf.org">
    <meta charset="UTF-8">
    <title>Sample Index Page</title>
</head>
<body>
    <h1>Recommended index</h1>
    <p>おススメの漫画・アニメを検索できます。</p>
    <p th:text="${key}">ここに値が入ります。</p>

</body>
</html>

<実行結果>

赤枠で囲った部分がJava側からHTMLへ渡した値です。

とりあえずは、ここまでに致します。

でわでわ。。。

<<< 前回

Java SpringBoot セットアップ ~Eclipse All in Oneでやると早い~

SpringBootの開発 セットアップ

SpringBootのセットアップを行うのに、いろいろな手順があり、混乱するので(自分の行った中で)もっとも簡単な方法を記載します。

使用するIDE(開発ツール)はEclipseのAll in Oneです。

大まかな手順

  1. プロジェクトを作成するときにSpringBootのスタータープロジェクトを作成する
  2. プロジェクト作成時に、ThymeleafとDB(H2DB)とSpringWebを追加する
  3. プロジェクト作成後にPOMファイルを「Maven install」で実行する
  4. Mavenプロジェクトの更新

プロジェクトの作成

Eclipseを起動してから、下のようにプロジェクトを右クリックし「新規」をクリック以下の手順に従います。

  1. Springスタータープロジェクトを選択し、「次へ」をクリック

  2. プロジェクトの名前などを入力する。使用するJDKによって「Javaバージョン」の値を変更する
     ※JDK1.8であれば「8」を選択する

  3. 使用するDBやフレームワーク(ツール)を選択する、今回はDBに「H2DB」、画面の作成に「Thymleaf」を使用するのでそれぞれのチェックボックスにチェックを入れる
    そして、Spring Webにチェックを入れる

  4. 最後に完了を押下する

※画像には「MySampleWebbApp」とあったが、「SampleWebApp」プロジェクトを作成した形で手順を進めます。

作成したプロジェクトは下のような形でEclipseのプロジェクトエクスプローラー、もしくは、パッケージエクスプローラーに表示されるはずです。
作成後のプロジェクト名が「MySampleWebbApp」になっていますが、「SampleWebbApp」での作成も確認しています。

プロジェクトを作成したばかりの状態では、バックグラウンド処理で何かしらのインストールが走っているので、ちょっと待ちます。

最後にプロジェクトを右クリック、実行、Spring Bootアプリケーションをクリック
これだけで、セットアップは完了です。

そして、ブラウザを開き、http://localhost:8080 にアクセスします。
ここでは、エラーページしか出ませんが、Tomcat(Webサーバー)が動いていることを確認するのが目的なのでこれでよいのです。

Eclipseでウェブ開発を始める~Java Servlet 二歩目 Servletを動かす~

イントロダクション

前回はEclipseを使用して、JavaServletの起動環境を作成しました。

観光構築だけで、起動確認はしていなかったので、これを確認するところから始めます。

Servletを動かす

前回作成したサーブレットは下のようなもの(コード)です。

/**
 * Servlet implementation class SrvLesson1
 */
@WebServlet("/SrvLesson1")
public class SrvLesson1 extends HttpServlet {
    private static final long serialVersionUID = 1L;

    /**
     * @see HttpServlet#HttpServlet()
     */
    public SrvLesson1() {
        super();
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.getWriter().append("Served at: ").append(request.getContextPath());
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
}

これを実行すると、下のような表示ができます。

「?????」と表示されているのは、文字コード(charset)が指定されていないからです。
これを指定するには下の王なコードを書きます。

response.setContentType("text/html; charset=UTF-8;");

そして、実行結果は下のようになります。

Tomcatについて

TomcatはWebコンテナ、APサーバーなどと呼ばれる分類に入る「サーバー」です。
サーバーは複数個所から、アクセスを受けて、それぞれのリクエスト(入力やボタン押下)に対する処理を行い、レスポンスという形で処理の結果をクライアントに返します。

絵にすると下のような感じです ※画力が。。。

コード解説

JavaServeltの実装にはいくつかのポイントになる部分があります。

  1. クライアントとサーバーの関係がある。
    クライアント(ブラウザ(IEやChrome, FireFox, Safariなど))とサーバー(Javaで作成したサーブレットが動くTomcatのようなアプリケーション)。クライアントはサーバーにリクエストを送信、サーバーはクライアントへレスポンスを送信する。

  2. HTMLのFormタグにある「action」属性にサーブレットを指定する。
    action="SukiriWeb2/SrvLesson1"などのように指定すると対象のURLに指定したサーブレットが起動する。

  3. レスポンスは、HTMLでブラウザに表示される。

コード内容

リクエストの種類には「GET」と「POST」があり、サーブレットに実装(オーバーライド)している「doGet()」と「doPost()」がそれぞれに対応する。
つまり。GETリクエストの時は「doGet()」POSTリクエストの時は「doPost()」が動く。

それぞれの処理の最後に「response.getWriter()」とあるが、これは返却するレスポンスに、返却する内容を追加するためのオブジェクトを取得するということです。

具体的には、PrintWriterクラスですが、このクラスにHTMLを書きこむことで、ブラウザに表示するHTMLを返却することができます。

つまりは、そのような仕組みになっている(フレームワーク化されている)ということです。

コードをいじってみる

返却する値を作成しているのは、サンプルにあるコードは下のようなものです。

StringBuilder build = new StringBuilder();
build.append("<!doctype html>");
build.append("<html>");
build.append("    <head>");
build.append("        <title>aaa</title>");
build.append("<body>はじめのサーブレット</body></html>");

そして、HTMLを返却するだけでなく今まで学習してきた処理を行うこともできます。

try {
    PreparedStatement pre = H2dbManager.getInstance().createPreparedStatement(SQLConst.INSERT_USER_TABLE);
    pre.setString(1, userName);
    pre.setString(2, passwd);
    pre.setInt(3, 1);
    if (pre.execute()) {
        throw new SQLException("ユーザー登録に失敗しました。");
    }
} catch (SQLException e) {
    // TODO 自動生成された catch ブロック
    e.printStackTrace();
    return false;
}

「一度書けばどこでも動く」というのがJavaのウリです(笑)

上の処理は、H2DBへのアクセスを行うための「H2dbManager」クラスを作成したので、そこからSQLを発行するために以下のようなことを行っています。

  1. PreparedStatementクラスを取得
  2. 実行するSQLの設定(パラメータを設定できるようにしている)
  3. パラメータの設定
  4. SQLの実行

ユーザー登録の処理です。詳細に関しては、以下に記載します。

H2DBManagerクラス

/**
 * プライベートコンストラクタ、H2DBのコネクションを取得する。
 * {@link H2dbManager#getInstance()}
 */
private H2dbManager() {
    try {
        Class.forName("org.h2.Driver");
        // 「~」はマイドキュメントを示す。
        con = DriverManager.getConnection("jdbc:h2:tcp://localhost/~\\workspace\\SukiriWeb2\\WebContent\\WEB-INF\\database");
        Statement stmt = con.createStatement();
        stmt.execute(SQLConst.CREATE_USER_TBL);
        stmt.execute(SQLConst.CREATE_ITEM_TBL);
        stmt.execute(SQLConst.CREATE_ITEM_TYPE_TBL);
    } catch (SQLException e) {
        e.printStackTrace();
        System.exit(-1);
    } catch (Exception e) {
        e.printStackTrace();
        System.exit(-1);
    }
}

/**
 * このクラスのインスタンスを取得する。
 * @return H2dbManagerインスタンス
 */
public static H2dbManager getInstance() {
    if (instance == null) {
        instance = new H2dbManager();
    }
    return instance;
}

Eclipseでウェブ開発を始める~Java Servlet 初めの一歩~

イントロダクション

ウェブシステムを開発するのにPHPが広く使われていますが、Javaでもできます。
というかでかいシステム(業務用など)は大体Java言語で作成されたシステムが多いのです。

理由

Javaはスピードと安定性においてほかの言語(PHPなど)に比べて処理スピードが速いようです。
以下のサイトを参考にしました。

  1. PHP vs Java
  2. Node vs. PHP vs. Java vs. Go

ほかに、適当なサイトが見つからなかったもので。。。
ちなみに、2のサイトではGo言語が1位でした。しかし、こちらのサイトで処理の内容をおみてみるとJavaのプログラムはスピード向けの実装になっていない。。。

自分の、感想としては、簡単なコードで実装するのであればGoの方が速いと思いました。
まぁ、簡単なコードの方がよいのですが、実装方法に関してはその人のスキルになるので何とも言い難しですね。。。

Javaの魅力は、ほぼ大体のことができ、指定した言語を取り込む(C言語で書かれたコードをJava言語として実行する)ことや、
実行するOSから別のスレッドで他のアプリケーションを起動できたりします。

開発準備

気を取りなおして、Javaの開発を進めます。
まずは、インストールするものがあります。それはEclipseです。こちらのサイトからできます。

こちらから最新のものを選択してインストールしてください。
詳細に関しては、こちらのページに記載しています。

設定方法に関しては、こちらにあります

ウェブ開発を始める

具体的に・・・

下のようなイメージのアプリケーションを作成します。

・自分のPC上でアプリケーション・サーバーを動かす
・いつものブラウザで、アプリケーション・サーバーにアクセス
・指定したサーブレットクラスを動かす。
・新しいURLの指定し方やり方

環境構築(Eclipseのプロジェクト)

  1. プロジェクトを新規で作成する

  1. 作成したプロジェクトにフォルダーを追加します。
    「classesフォルダ」を作成し以下のようにビルドパスに追加する

  1. Serveltクラスを作成する

    /**
    * Servlet implementation class SrvLesson1
    */
    @WebServlet("/SrvLesson1")
    public class SrvLesson1 extends HttpServlet {
    private static final long serialVersionUID = 1L;
    
    /**
     * @see HttpServlet#HttpServlet()
     */
    public SrvLesson1() {
        super();
    }
    
    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.getWriter().append("Served at: ").append(request.getContextPath());
    }
    
    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
    }
  2. サーバーを追加する(Tomcat8.XXXX)

  1. 作成したプロジェクトをサーバーに追加する

  2. サーバーを起動する。

  3. 作成したサーブレットが動くことを確認。

まとめ

これが作成できたら、あとは、どのようなものを作成するのか考えていきます。
現状では、Javaでサーバー側のプログラム、サーブレット(サーバー処理)を実行できるような状態になっています。

仕組みとしては、「@WebServlet("/SrvLesson1")」で指定しているURL「/SrvLesson1」にアクセスしたときにこのサーブレットが動く状態です。
実際にURLにアクセスするときは下のような形で指定します。

「localhost:8080/プロジェクト名/指定しているURL」 => 「localhost;8080/SukiriWeb2/SrcLesson1」

まずは、一区切りということで。。。

でわでわ。。。

Java Basic 総復習編 〜基本と基本文法編〜

Java Basic 総復習

今まで、Javaを学習してきて、なんとなくはわかったけどクラスとかオブジェクトという言葉が出てきたら頭がこんがらがってきた。という事象があるかと思います。

<プログラミングのチュートリアル(説明)動画>

自分も昔そうでした。。。そうだったような気がします。

それならば、整理すれば良いのです。簡単な話です。

復習内容リスト

  1. プログラムの流れ
  2. 変数の扱い
  3. 式と演算子
  4. if文
  5. switch文
  6. while文
  7. for文

プログラムの流れ

まずは、プログラムの流れについて復習します。クラスやメソッドなどが出てきて処理があちこちに飛ぶように感じられると思いますが、そんなことはありません。順序立てて動いています。

まずは、メインメソッドが動く

どのクラスにも作成することができますが、1つのアプリケーションとして動かすときは、「必ずメインメソッドが動く」ということを忘れないでください。

例えば、下のようなコードがあったとします。

public class First {
 public static void main(String[] args) {
       System.out.println("Hello World");
       First main = new First();
       main.hello();
   }
   public void hello() {
       System.out.println("Second Hello World");
   }
}

この時に、メインメソッドの中では、クラスをnewしてやらないとメンバメソッド(インスタンスメソッド)は起動できません。
それは、「static」がついているメソッドは、特別なメソッドなので、インスタンスメソッドと区別されます。

ここでの、処理の順番は、以下のようになります。

  1. メインメソッドが動く
  2. 「Hello World」をコンソールに出力
  3. Firstクラスをインスタンス化
  4. インスタンスメソッドの「hello()」を呼び出す

このように動きます。ここでの注意ポイントは「First」クラス型の変数「main」です。

変数の扱い

変数はプログラムを動かすために必要になるものですが、あまり細かいところまで解説をすることが少ないです。
実際に、覚えることはint型は「整数」とか、「double」型は少数。。。
というように、データ型の用途に対する説明のみになってしまうからです。

変数には「プリミティブ型」と「参照型(クラス型)」がありますが、参照型に関しては自作クラスも参照型として分類されるので
プリミティブ型のように「これは整数型です」というような言い方ができません。

ただし、String型はクラス型です。他にも、int型を参照型にしたものがあります。それぞれ下のようになっています。
<プリミティブ型 -> 参照型>

  • int -> Integerクラス
  • double -> Doubleクラス
  • boolean -> Booleanクラス
  • long -> Longクラス
  • float -> Floatクラス

<リテラルに関する解説>

変数の定義方法は全て同じ

今までよく目にしている、下のような変数の宣言は理解できていると思います。

int num = 0;
String str = "はじめの一歩";

変数の宣言・初期化は必ず「データ型 変数名 = 代入する値」という形で行います。

これは変数のデータ型がどんなものになっても変わりません。

<変数の扱い方>

データ型とは

以下のものがあります。

  1. int, double, float, lognなどのプリミティブ型と呼ばれる(分類される)変数の型
  2. String, 配列(int[], double[], String[], クラス名[])などの参照型と呼ばれる(分類される)変数の型

例. 変数宣言(初期化)

int num = 0;
String str = "はじめの一歩";
First main = new  FIrst();
List<String> list = new ArrayList<String>();
Scanner scan = new Scanner(System.in);
Random rnd = new Random();

上から順に

  1. int型の変数numを0で初期化
  2. 文字列型(String型)の変数strを"はじめの一歩”で初期化
  3. First型の変数mainをFirstクラスのインスタンスを生成して初期化
  4. List\<String>型の変数listをArrayList\<String>クラスをインスタンス化して代入
  5. Scanner型の変数scanにScannerクラスをインスタンス化して代入
  6. Random型の変数rndにRandomクラスをインスタンス化して代入

式と演算子

演算子には以下のようなものがあります。
算術演算子:「+」 「-」 「*」 「/」 「%」 「^」 「++」 「--」
比較演算子:「==」 「!=」 「「<」 「>」 「<=」 「>=」
論理演算子:「&&」 「||」

そのほかの演算子
instanceof」:クラス型の比較を行います。

String st = "aa";
if (st instanceof String) {
    System.out.println("同じString型です。");
}

代入演算子:「=」値を代入します。

int num = 0; // int型の変数に0を代入
First first = new First(); // First型の変数firstにFirstクラスのインスタンスを代入
String st = "aaa"; // String型の変数stに文字列「aaa」を代入

ここで注意して欲しいのが、「1」と「"」がついていないもの、リテラル(値)は「数値」として扱われる
逆に「"」で囲われているもの、リテラル(値)は文字列としてある変われる

この「=」が、いまいち、ピンとこない人に向けて例を以下に書きます。

public static void main(String[] args) {
    String st = getString();
}
public static String getString() {
     return "String";
}

上のコードは、クラスを省略して書いていますが、メインメソッドから「getString()」というメソッドを呼び出します。
この「getString()」は返り値(戻り値)にString型(文字列型)を定義しています。

なので、「getString()」のメソッドを呼び出したらString型の値を受け取ることができます。

これに対して、クラスをnewして実行した時に関しても同じです。ちょっと長いですが。。。

public class Sample {
    /** フィールド変数 */
    private int field_int = 0;
    private String field_String = "もじれつ";
    //////// 注意(教科書の書き方はほぼ使わない) /////
    // String package_String = "使わない";

    public static void main(String[] args) {
        // Sampleクラス型の変数mainにSampleクラスをインスタンス化して代入
        Sample main = new Sample();
        // 返り値(戻り値)が「void」の場合は変数を受け取る必要がない
        main.hello();
        staticHello();

        // 返り値(戻り値)が定義されている場合(voidになっていない場合)
        // 返り値(戻り値)を受け取ることができる
        Sring result = getString();
        System.out.println("getString()の戻り値は" + result);
    }

    public static void staticHello() {
        System.out.println("Hello World");
    }
    /**
     * <コンストラクタの書き方>
     * アクセス修飾子 クラス名(引数) { ... }
     *
     * newした時の処理を書く
     */
    public Sample() {
        this.field_int = 5;
        this.field_String = "aaaa時の値";
    }

    /**
     * コンストラクタのオーバーロード
     * @param num
     * @param str
     */
    public Sample(int num, String str) {
        this.field_int = num;
        this.field_String = str;
    }

    /**
     * ハローメソッド
     */
    public void hello() {
        System.out.println(this.field_String);
        this.hello("こんにちは、フィールド変数:" + this.field_int);
        this.hello2();
    }
    /**
     * ハローメソッド
     */
    public void hello2() {
        System.out.println(this.field_String);
        this.hello("こんにちは、フィールド変数:" + this.field_int);
        String st = "aa";
        String gg = "ss";
        if (st instanceof String) {
            System.out.println("同じString型です。");
        }
    }

    public String getString() {
        return "String";
    }
}

上記のコードのうち戻り値が「void」のものは以下になります。

  • helllo()
  • hello2()
  • staticHello()

そして。返却値(戻り値)の指定があるもの(voidではないもの)は以下の通りです。

  • getString()

このgetString()メソッドはString型の値を返しますので、呼び出し元(メインメソッド)ではString型の変数resultで受け取っています。
当然受け取らなくても良いので、下のように書いてもエラーは出ません。

getString();

上記の場合は、String型の値を受け取っても、変数に代入していないのでメインメソッドでは使用することができません。
使用する必要がなければ、このようなメソッドの呼び出しもOKです。

if文

条件分岐処理の構文です。

if (論理式) {
   // trueの場合の処理
} else {
  // falseの場合の処理
}

実際に使用するときは下のように書く

String st = "aa";
if (st instanceof String) {
    System.out.println("同じString型です。");
}
if ("aa".equals(st)) {
    System.out.println("stはaaです。");
} else if ("bb".equals(st) ) {
    System.out.println("stはbbです。");
} else {
    System.out.println("stはその他の値です。");
}

それぞれif (論理式) { ... }の「論理式」の部分で値が「true / false」が帰ってきたところで処理の流れが変わります。

論理式

返り値としてbooleanが返される式のことです。以下の指揮がそれにあたります。

boolean isTrue = "aaa".equals("aaa");
boolean isFalse = "aAb".equals("aaa");
isTrue = 1 == 1;
isFalse = 2 == 1;
isTrue = 1 < 2;
isFalse = 1 != 2;

「返る」というのは「=」の反対側に値を渡すという意味です。

switch文

上記のif文と同じ処理がかけます。下のようになります。

switch(st) {
case "aa": 
    System.out.println("stはaaです。");
    break;
case "bb":
    System.out.println("stはbbです。");
    break;
default:
    System.out.println("stはその他の値です。");
}

while文

繰り返し処理の最もシンプルなものです。
下のように論理式の結果が「true」の間繰り返し処理を行います。

int num = 0;
while (num < 10) {
     System.out.println("num = " + num);
     num++;
}

上のコードは「num = 0」〜「num = 9」までを表示します。

for文

繰り返し処理の最もおポピュラーなものです。

for (int i = 0; i < 10; i++) {
     System.out.println("num = " + num);
}

上のコードは「num = 0」〜「num = 9」までを表示します。

大まかに基本文法と変数の扱い方などを記載しました。

Java H2DB〜インストールからテストテーブル作成と表示〜

H2 データベースのインストール

ダウンロード先
上記のリンクから、下のようなページに遷移できます。

H2DBのダウンロード

そして、赤枠の部分をクリックします。

同様に、赤枠の部分をクリックします。

そうすると、「h2-XXXX-XX-XX.zip」のような名前のファイルがダウンロードできます。
サンプル:「h2-2019-10-14.zip」

h2DBのJARファイルをビルドパスに通す

Eclipseを開きプロパティ -> ライブラリ・タブを開きます

そして、赤枠にある「外部JARファイルの追加」をクリックします。
そこに、h2*.jarというファイルがあるのでそれを追加します。

bat(sh)ファイルを起動する

h2*.jarファイルの隣にある「h2.bat(Windows用)かh2.sh(Mac, Linux用)」のファイルを起動する(ダブルクリック)

http://localhost:8082」にアクセスするとしたのような画面が見れます

日本語の表示もできました。そしたら「~/test」と書いてある部分を自分の指定したパスに変更します。現状では、マイドキュメント直下です。

次のようなパスを入力しました。

jdbc:h2:/Users/ユーザー名/Java/jars/h2/db_file

そして「接続」ボタンをクリック少し待つとしたのような画面が見れます。

これで、DBの作成が完了です。

テーブルを作成する

テスト用のテーブルを作成します。
画面にある「SQLステートメントのサンプル」の下の部分をクリックします。

するとSQLが生成されて下のような表示に変わります。

そして、をクリックしますとテストテーブルが作成できます。

実行結果は下のようなものです。

JDBCで接続してみる

Javaプログラムをしたのように作成します。

  1. H2Dao.java

    public class H2Dao {
    private final String DB_URI = "jdbc:h2:/Users/takk/Java/jars/h2/db_file/test.mv.db";
    private Connection con;
    
    public H2Dao() throws SQLException {
        try {
            // DriverManager.getConnection(URI   , ユーザー名, パスワード(なし))
            con = DriverManager.getConnection(DB_URI, "sa", "");
            Statement stmt = con.createStatement();
            createTables(stmt);
            ResultSet result = stmt.executeQuery("select * from test;");
    
            while(result.next()) {
                int id = result.getInt(1);
                String name = result.getString(2);
                System.out.println("ID: " + id + " Name: " + name);
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            throw e;
        }
    }
    
    public void createTables(Statement stmt) throws SQLException {
        String sql = "DROP TABLE IF EXISTS TEST;\n" + 
                "CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255));\n" + 
                "INSERT INTO TEST VALUES(1, 'Hello');\n" + 
                "INSERT INTO TEST VALUES(2, 'World');\n" + 
                "SELECT * FROM TEST ORDER BY ID;\n" + 
                "UPDATE TEST SET NAME='Hi' WHERE ID=1;\n" + 
                "DELETE FROM TEST WHERE ID=2;";
        stmt.execute(sql);
    }
    public void finalize() {
        try {
            con.close();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            con = null;
        }
    
    }
    }

そして、このクラスを動かします。今回は、JUnitを使用します。

public class H2DaoTest {

    @Test
    public void testConstractor() {
        try {
            H2Dao dao = new H2Dao();
        } catch (SQLException e) {
            fail("エラーになりました");
        }

    }
}

これで、実行した結果が緑になればOKです。

練習

ここまできたら、上記のコードpublic void createTables(Statement stmt) throws SQLException にあるSQLを改造してSQLを実行してみましょう。

ヒント

更新系の処理と検索(データの取得)系の処理では、呼び出すメソッドが違います。

  • 更新系:Statement#execute()
  • 検索系:Statement#executeQuery()

<更新系>

    private void execute(String sql) {
        try {
            Statement stmt = con.createStatement();
            stmt.execute(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

<検索系>

    private List<String> executeQuery(String sql, boolean isRetuen) {
        System.out.println("*** executeQuery ***");
        List<String> list = new ArrayList<String>();
        try {
            Statement stmt = con.createStatement();
            ResultSet result = stmt.executeQuery(sql);
            ResultSetMetaData meta = result.getMetaData();
            int colCount = meta.getColumnCount();
            while(result.next()) {
                for (int i = 1; i <= colCount; i++) {
                    System.out.print(i + ": " + result.getString(i) + " ");
                }
                System.out.println();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        if (isRetuen) {
            return list;
        }
        return null;
    }

でわでわ。。。

Java を支えるクラスたちに目を向ける 〜Java API〜

イントロダクション

今まで、Javaを学習してきて、何気なく使用していたクラスがあります。

気づかいない間に使用しているものもあります。これらはjava.langパッケージに入っているクラス群で、importしなくても使用することができます。

その代表的なクラス(Java API)がStringクラス(文字列)です。

Java を支えるクラスたち

Java APIというとJava言語自体のことを指すのですが、解釈のしかたは人によって違うようです。

しかし、はっきりしているのは「Java言語で使用するクラス群のこと」だということです。

Stringクラスを使う

まずは、プログラムをガンガン実行するための準備をします。

<==プロジェクトの作成とJUnitの設定==>

そうすると、JUnitが使用できるようになります。

==JUnitを使った動画(再生リスト)==

<ミッション1>
以下のクラスを作成して、実行した結果が想定通りになることを確認してください。

手順

  1. 以下の「作成するパッケージ」を作成する
  2. 同様に「作成するクラス」を作成する
  3. 同様に「A. テストケースの作成」を作成する
  4. 同様に「B. 作成するクラスのフィールド」を作成する
  5. 同様に「C. 作成するメソッド」を作成する

== 作成するパッケージ ==
practice.自分の名前.util

==作成するクラス==
srcフォルダに、StringUtilsクラスを作成
testフォルダに、StringUtilsTestクラスを作成

==A. テストケースの作成==
以下の処理を確認するテストケースを作成します。

⑴ 2つの引数がどちらも空(から)文字("")、もしくは null の場合、定数EMPTY「0」を返す(retunする)
⑵ 2つの引数が等しい場合、定数EQUAL「1」を返す(returnする)
⑶ 2つの引数が、大文字小文字の区別をしないで、等しい場合、定数IGNORE「2」を返す(returnする)

<テストケース(メソッド)の書き方>

@Test
public void testStringUtils01() {
    StringUtils target = new StringUtils();
    // 作成するメソッドの<処理>の1の内容を確認する処理
    // assertEquals(想定する結果の値, 検証する値);
   assertEquals(StringUtils.EMPTY,  target.stringTest01("", null));
}

*上の例に習い、2、3の処理を確認する処理を作成しましょう。

==B. 作成するクラスのフィールド==

  1. 定数EMPTYを整数型「0」で初期化
  2. 定数EQUALを整数型「1」で初期化
  3. 定数IGNOREを整数型「2」で初期化

==C. 作成するメソッド==

  1. 戻り値(返り値): 整数型(int型)
  2. メソッド名: stringTest1
  3. 引数リスト: 文字列型 leftStr, 文字列型 rightStr
  4. 処理内容:

 <処理>
 a. 引数にある文字列が空("")であれば、定数EMPTYを返す
 b. 引数にある文字列 leftStrとrightStrが等しいのであれば、定数 EQUALを返す
 c. 引数にある文字列が leftStrとrightStrがであれば、定数IGNOREを返す

<ミッション2>
ミッション1で作成した、StringUtilsTestクラスに、以下のテストケースを追加
・「引数に渡した文字列を大文字に変換することを確認する」
・「引数に渡した文字列を小文字に変換することを確認する」

以下、手順に従いテストケースの作成及び、クラスの作成を行う

手順

*String#toUpperCase()の実装

  1. StringUtilsクラスのconvertUpper()メソッドの引数に、
      文字列「"aaa"」を渡し、結果が「"AAA"」と等しいことを確認する

*String#toLowerCase()の実装

  1. StringUtilsクラスのconvertLower()メソッドの引数に、
      文字列「"TeStA"」を渡し、結果が「"testa"」と等しいことを確認する

*String#startWith()とendWithの実装

  1. StringUtilsクラスのstartEndWith()メソッドの引数に、
      文字列「"starts"」を渡し、結果が「true」と等しいことを確認する
  2. StringUtilsクラスのstartEndWith()メソッドの引数に、
      文字列「"start"」を渡し、結果が「false」と等しいことを確認する5. StringUtilsクラスのstartEndWith()メソッドの引数に、
      文字列「"atarts"」を渡し、結果が「false」と等しいことを確認する
  3. StringUtilsクラスのstartEndWith()メソッドの引数に、
      文字列「"strings"」を渡し、結果が「true」と等しいことを確認する

*String#IndexOf()の実装

  1. StringUtilsクラスのfindStr()メソッドの引数に、
      文字列「"Tesea"」と「"e"」を渡し、結果が「1」と等しいことを確認する
  2. StringUtilsクラスのfindStr()メソッドの引数に、
      文字列「"Tesea"」と「"T"」を渡し、結果が「0」と等しいことを確認する

*String#lastIndexOf()の実装

  1. StringUtilsクラスのfindLastStr()メソッドの引数に、
      文字列「"Takashimaya"」と「"a"」を渡し、結果が「1」と等しいことを確認する
  2. StringUtilsクラスのfindLastStr()メソッドの引数に、
      文字列「"Tesea"」と「"e"」を渡し、結果が「3」と等しいことを確認する
    11 StringUtilsクラスのfindLastStr()メソッドの引数に、
      文字列「"Takashimaya"」と「"a"」を渡し、結果が「10」と等しいことを確認する

*String#substring()の実装
12 StringUtilsクラスのsubString()メソッドの引数に、
  文字列「"abcdefg"」、整数「0」、整数「3」を渡し、結果が「abc」と等しいことを確認する
13 StringUtilsクラスのsubString()メソッドの引数に、
  文字列「"abcdefg"」、整数「3」を渡し、結果が「efg」と等しいことを確認する
14 StringUtilsクラスのsubString()メソッドの引数に、
  文字列「"abcdefg"」、整数「3」、整数「7」を渡し、結果が「defg」と等しいことを確認する

*String#trim()の実装(スペースが入っているので注意しましょう)
15 StringUtilsクラスのtrimStr()メソッドの引数に、
  文字列「" abcd "」を渡し、結果が「abcd」と等しいことを確認する
16 StringUtilsクラスのtrimStr()メソッドの引数に、
  文字列「" a bcd "」を渡し、結果が「a bcd」と等しいことを確認する

*String#replace()の実装
17 StringUtilsクラスのreplaceStr()メソッドの引数に、
  文字列「"abcd"」、文字列「”c"」、文字列「"あ"」を渡し、結果が「abあd」と等しいことを確認する
18 StringUtilsクラスのreplaceStr()メソッドの引数に、
  文字列「"abcda"」、文字列「”a"」、文字列「"C"」を渡し、結果が「abCd」と等しいことを確認する

*String#replaceAll()の実装
19 StringUtilsクラスのreplaceStr()メソッドの引数に、
  文字列「"abcda"」、文字列「”c"」、文字列「"あ"」を渡し、結果が「abあd」と等しいことを確認する
20 StringUtilsクラスのreplaceStr()メソッドの引数に、
  文字列「"abcda"」、文字列「”a"」、文字列「"あ"」を渡し、結果が「あbcdあ」と等しいことを確認する

解答例

<StringUtils.java>

public class StringUtils {
    /** 定数 */
    public static final int EMPTY = 0;
    public static final int EQUAL = 1;
    public static final int IGNORE = 2;
    public static final int ERROR = -1;

    public int stringTest01(String str1, String str2) {
        if ("".equals(str1)) {
            return EMPTY;
        }
        if ("".equals(str2)) {
            return EMPTY;
        }
        return ERROR;
    }

    public int stringUtils02(String str1, String str2) {
        int result = ERROR;
//      if (this.isEmpty(str1, str2)) {
//          return ERROR;
//      }
        if (str1.equals(str2)) {
            result = EQUAL;
        } else {
            result = ERROR;
        }
        return result;
    }

    public boolean isEmpty(String str1, String str2) {
        if (str1 == null || str2 == null) {
            return true;
        }
        if ("".equals(str1) || "".equals(str2)) {
            return true;
        }
        return false;
    }
}

< StringUtilsTest>

public class StringUtilsTest {
    @Test
    public void testStringUtils01() {
        StringUtils target = new StringUtils();
         // 作成するメソッドの<処理>の1の内容を確認する処理
        // assertEquals(想定する結果の値, 検証する値);
        assertEquals(StringUtils.EMPTY,  target.stringTest01("", null));
    }

    @Test
    public void testStringUtils02() {
        StringUtils target = new StringUtils();
        assertEquals(StringUtils.EQUAL, target.stringUtils02("aaa", "aaa"));
        assertEquals(StringUtils.ERROR, target.stringUtils02("aaa", "aab"));
        //assertEquals(StringUtils.ERROR, target.stringUtils02(null, "aab"));
        assertEquals(StringUtils.IGNORE, target.stringUtils02("aaa", "AAA"));
    }
}

クラスの扱い方の練習

問題

  1. プロジェクト「JavaExamTrain」を作成してください、すでにプロジェクトが存在する場合は何もしなくて良いです。
  2. 以下のパッケージを作成してください
    ・ practice.exam.mondai
    ・ practice.exam.mondai.logic
  3. 同様に、添付のファイルをダウンロードもしくはコピーしてソースフォルダ「resources」に「sample.csv」を作成してください、またresourcesフォルダにビルドパスを通してください。
  4. 以下のクラスを作成してください
    ・practice.exam.mondai.MondaiMain
    ・practice.exam.mondai.logic.ExamLogic
  5. ExamLogicクラスに、以下のような実装をしてください。
    ・返り値(戻り値):なし、メソッド名:printMessage、引数:なし
    ・String型の配列hako を文字列「50」「sy」「s_」「jo」「5f」「3d」「es」で初期化してください。
    ・int型の配列hintを数値「3」「1」「2」「4」「0」「5」「6」で初期化してください。
    ・拡張for文を使って、変数hintの値に対応する番号(添え字)の、変数hakoの文字列を標準出力に出力してください。
  6. ExamLogicクラスに、以下のようなコンストラクタを実装をしてください。
    ・引数なし
    ・String型のフィールド変数nameに文字列「タイガー」を代入する
    ・int型のフィールド変数ageに数値「19」を代入する
    ・ExamSwordクラス型のフィールド変数swordにExamSwordクラスのインスタンスを代入する
    ※ExamSwordクラスはMondaiLogicクラスと同じパッケージに作成する
  7. ExamLogicクラスに、以下のようなコンストラクタを実装をしてください。
    ・引数:文字列
    ・String型のフィールド変数nameに文字列引数の文字列を代入する
    ・int型のフィールド変数ageに数値「19」を代入する
    ・ExamSwordクラス型のフィールド変数swordにExamSwordクラスのインスタンスを代入する
    ※ExamSwordクラスはMondaiLogicクラスと同じパッケージに作成する
    ・次のような文字列を表示してください。「[name]」「[age]」はそれぞれフィールド変数を示すものとする
    「私の名前は[name]です。[age]才です。エモノは[ExamSword#name]です。」
    ※[ExamSword#name]はExamSwordクラスのフィールド変数nameを示すものとする。
  8. MondaiMainクラスに以下のような実装をしてください。
    ・ExamLogic型のフィールド変数logicを作成してください。
    ・コンストラクタでフィールド変数logicにExamLogicのインスタンスを代入してください。
    ・メインメソッドで、logicクラスのインスタンス・メソッド「printMessage」を呼び出してください。