Ajile開発手法

イントロダクション

Ajile開発のワークショップに行ってきました。
とても、有意義かつ、勉強になったワークショップでした。
そんなわけで、学んだことをまとめます。

Ajile開発とは

Wikiを参照すると下のようなものでした。

アジャイルソフトウェア開発手法の多くは、反復 (イテレーション) と呼ばれる短い期間単位を採用することで、リスクを最小化しようとしている。 1つの反復の期間は、プロジェクトごとに異なるが、1週間から4週間くらいであることが多い。
アジャイル開発手法においては、開発対象を多数の小さな機能に分割し、1つの反復 (イテレーション) で1つの機能を開発する(⇒反復型開発)。そして、この反復のサイクルを継続して行うことで、1つずつ機能を追加的に開発してゆくのである。また、各々の反復は、小規模なソフトウェア開発プロジェクトに似ている。なぜなら、計画、要求分析、設計、実装(コーディング)、テスト、文書化といった、ソフトウェアプロジェクトに要する全ての工程を、1つの反復内で行うからである。

そして、まとめると開発の作業範囲を限定して、細かく作業を分けて、その単位で開発を行うということです。

具体的に

例えば、コンソール出力版テキストRPGを作成するプロジェクトがあったとします。その時に作成するべき内容は以下の通りです。※自分で作成するのにこのような仕様にしました。

作成する項目(仕様)(TextRPG)

  1. 戦闘シーンを作成する(単体のモンスターと)
  2. 複数モンスターとの戦闘
  3. 仲間を加え戦闘することができるようにする
  4. プレーヤーがレベルアップできるようにする
  5. ストーリー展開のシーンを表示できるようにする
  6. タイトルを表示をできるようにする
  7. ストーリー展開と戦闘シーンの切り替えをできるようにする
  8. タイトルとストーリー展開シーンの切り替えをできるようにする
  9. タイトル~戦闘シーンまでの切り替えをできるようにする
  10. ストーリー展開シーンの中でストーリーを進行させることができるようにする
  11. 装備などでステータスを、変更できるようにする
  12. 町などで、買い物ができるようにする
  13. アイテムの使用ができるようにする(戦闘シーンも含む)
  14. エンディングを表示できるようにする

上記のように、各仕様に対してその実装を行うのですが、その使用でちゃんとアプリケーションが動くように作成していきます。

ここでポイントになるのがテスト駆動開発です、それは、各仕様を実装していくのに、実装した部分を修正し続けていく必要があるためです。

ここで、テスト仕様から作成し、動きを確かめながら実装してくのもそうですが、修正するときに「テストが通ればどんな修正でもOK]という形にしておけば修正も楽だしレビューだって楽にできる状態になります。
つまり、レビューワーはテスト仕様がちゃんと組まれているか?を確認、テストの実行結果もOKということを確認するだけでよいのです。

「楽」というのは、作業時間が少なくて済むということです。空いた時間はほかの作業を行えばよいので仕事にも余裕ができます。

スクラムフレームワーク

アジャイル開発の現場では「スクラム」というフレームワークを使用することが多いようです。リンク先はWikiです。
このフレームワークは、下のようなフローで作業を行うと作業効率がよく、作業員が成長できるというスグれものです。

スクラムに登場する役割

  • 開発チーム: プログラマーチーム
  • プロダクトオーナー: 製品の総責任者。 顧客の意思の代表としての役割を担う。
  • スクラムマスター: チーム内外の組織間調停( ファシリテーション )と外部妨害を対処することとされる。顧客側で担当することが多い。

作業その1:バックログの作成

製品に対する「要求」を作成すること、上の仕様がこの部分に当たる。
上の仕様は、大まかなものなので、これらの仕様を実現するための仕様(タスク)を実現するために「スプリント」という期間を作り、対応する。

作業その2:スプリントの作成

スプリントは上記の「要求」を実現するための「タスク」を切り出して、特定の期間内で完了するための作業です。
スプリントプランニング

  1. チームはスプリントで実現するバックログの項目を選択
  2. 選択したバックログ項目を実現するためのタスク化を行う
  3. チームが共同でタスク化する過程で、チーム内メンバーの認識差異がないことを最終確認する。

デイリースクラム

  1. 毎日スクラム会議を開く。
  2. 平日の決まった時間に決まった場所で行う。また、15分以内で完了させなければならない。
  3. スクラムマスターは、必ず出席、チーム全員に対して、以下の質問を行う
      1. 「前回のスクラム会議以降、何をしたか」
      1. 「問題はあるか」
      1. 「次回のスクラム会議までに何をするか」
  4. 問題があると報告された場合、スクラムマスターは、即座に意思決定する責任を負う。問題が外的要因によるものである場合、スクラムマスターが、その解決の責任を負う。

プロダクトバックログリファインメント
実際に行う作業の見積もりを行う、作業量がどのくらいか?期間内で完了できるか?を見積もるのにポイントを振り分ける。
初めて、行う作業に関しては、実際にポイントを振って行いその結果「XXポイント」でどのくらいの時間が必要だったか?の平均をとり、おおよその見積もりを取る。
(例)

  1. タスクA,B,Cとあったときに基準にするタスクを決めポイントを割りふる。
  2. 基準にしたタスクから「これぐらい」という見積もりをチームのメンバー内で話し合いで決める。
  3. 実行してみて、その結果、ポイントの消化がどれくらいでできたか?の平均値を取り基準にする

スプリントレビュー
スプリントレビューでは、スプリントで開発されたソフトウェアのレビューが行われ、必要に応じて、新たなバックログ項目が追加される。
このレビューには、顧客、マネージャ、開発者が参加する。
なお、場合によっては、営業やマーケティング関係者も参加する場合もある。

スプリントレトロスペクティブ(振り返り)
振り返りを行う。その振り返りのフレームワークとして以下のものがある。
各項目に対して意見をメンバーで出して、それを話し合い次のスプリントへつなげる

  • KPT: Keep, Problem, Try
  • YWT: やったこと、わかったこと、次にやること
  • FDL: Fun(面白かったこと), Done(やったこと), Learn(学んだこと)

モブプログラミング

実装者一人、他は全部レビューワー。の形で実装を進める方法。

実装者のレベルが近く、互いに切磋琢磨できる関係ができていればとても有意義なプログラミング手法

実際にやってみて面白かった。

ペアプログラミング

これも、上記同様実装者一人、レビューワー一人で実装を行う。

まとめ

スクラムフレームワークを使用してチーム開発を行うときに下のようなツールを使用するとやり易い。

  1. Gitなどのバージョン管理ソフト
  2. 意見交換するためのツール、ウェブホワイトボード、スケッチブックなど
  3. 時間の管理を行うタイムキーパー
  4. チームの活動を見守る人

今回のワークショップは仕事ではなく、「学習」だったのでとても楽しかったが「仕事だと楽しくないよな。。。」という意見もありました。

最も作業効率が良く、生産性の高い現場というのは、「楽しく仕事ができる」というところだと思いました。

でわでわ。。。

関連ページ一覧

EclipseセットアップWindows版

Eclipse セットアップ

  1. Java Install Eclipse〜開発ツールのインストール〜
  2. TensorFlow C++環境〜EclipseCDTをインストール〜
  3. Setup OpenGL with JavaJOGLを使う準備 for Eclipse
  4. Eclipse Meven 開発手順〜プロジェクトの作成〜
  5. Java OpenCV 環境セットアップ(on Mac)
  6. Eclipse SceneBuilderを追加する
  7. JavaFX SceneBuilder EclipseSceneBuilder連携~

Java Basic一覧

  1. Java Basic Level 1 〜Hello Java〜
  2. Java Basic Level2 〜Arithmetic Calculate〜
  3. Java Basic Level3 〜About String class〜
  4. Java Basic Level 4〜Boolean〜
  5. Java Basic Level 5〜If Statement〜
  6. Java Basic Summary from Level1 to 5
  7. Java Basic Level 6 〜Traning of If statement〜
  8. Java Basic Level8 〜How to use for statement〜
  9. Java Basic Level 8.5 〜Array〜
  10. Java Basic Level 9〜Training of for statement〜
  11. Java Basic Level 10 〜While statement 〜
  12. Java Basic Swing〜オブジェクト指向〜
  13. Java Basic Swing Level 2〜オブジェクト指向2〜
  14. サンプル実装〜コンソールゲーム〜
  15. Java Basic インターフェース・抽象クラスの作り方
  16. Java Basic クラスとは〜Step2_1〜
  17. Java Basic JUnit 〜テストスイートの作り方〜

Git関連

  1. Java Git clone in Eclipse 〜サンプルの取得〜
  2. Eclipse Gitリポジトリの取得 GitからソースをPullしよう〜
  3. IntelliJ IDEA GitGitリポジトリからクローン〜

JavaFX関連ページ

  1. Eclipse SceneBuilderを追加する
  2. JavaFX SceneBuilder 〜EclipseとSceneBuilder連携~
  3. JavaFX SceneBuilder〜ボタンにメソッドを割り当てるワンポイント〜
  4. Java プロコンゲーム 〜見た目の作成(SceneBuilderの使用)〜

ステップアップ関連ページ一覧

  1. Java 初めてでも大丈夫〜ステップアッププログラミングのススメ〜
  2. ステップアッププログラミング〜Java FxでHelloWorld解説〜
  3. Java StepUpPrograming〜JavaFX で四則計算〜
  4. Java StepUpPrograming〜JavaFXで画面切り替えを作る1〜
  5. Java StepUpPrograming〜JavaFXで画面切り替え2ボタン作成〜
  6. Java StepUpPrograming〜JavaFXで画面切り替え3アクション〜
  7. Java StepUpPrograming〜JavaFXで画面切り替え4Pane切り替え〜
  8. Java StepUpPrograming〜JavaFXで画面切り替え5WebEngine

JavaFX + ND4Jで機械学習準備

  1. JavaFX + ND4J〜数学への挑戦1:ND4Jのインストール〜
  2. JavaFX + ND4J〜数学への挑戦2: 行列の計算〜
  3. Java + ND4J 〜数学への挑戦3: ベクトル(配列)の作成方法〜

オブジェクト指向関連ページ

  1. [オブジェクト指向の概念1〜OracleDocのチュートリアル1〜](https://zenryokuservice.com/wp/2019/10/301. /%e3%82%aa%e3%83%96%e3%82%b8%e3%82%a7%e3%82%af%e3%83%88%e6%8c%87%e5%90%91%e3%81%ae%e6%a6%82%e5%bf%b5-%e3%80%9coracledoc%e3%81%ae%e3%83%81%e3%83%a5%e3%83%bc%e3%83%88%e3%83%aa%e3%82%a2%e3%83%ab%ef%bc%91/)
  2. オブジェクト指向の概念2〜クラスとは〜

Java オブジェクト指向 ~設計図と実装のイメージをつなげる~

イントロダクション

下のようなツイートをしてみたところ。。。

複数の「いいね」をもらったので、自分の知っていることを記載します。

1. 設計と実装のつながり
2. 設計(クラス図)について
3. オブジェクト指向

結論から言うと「設計図(クラス図)は実装を示している」という認識です。
しかし、「オブジェクト指向で躓く人が多い」というウワサから想像するに、この部分は多くの人がつまずく部分だと思われます。

「躓いた数なら日本一」の自信がある自分としては、以下のものが不明瞭な認識のままではなかろうかと思います。
1. 設計と実装のつながり
2. クラス同士の関係
3. クラスのインスタンス化
4. 処理の追いかけ方

サンプルとして下のようなコンソールアプリを作成しました。
※ 以前作成したのものがありました。。。

これのクラス図も作成しました。

![](http://zenryokuservice.com/wp/wp-content/uploads/2020/11/import1-5.png)

これらを材料にして設計(クラス図)と実装のつながりを見ていこうと思います。

# 1. 設計と実装のつながり
実装をしてない状態では、上記のイメージ(クラス図)のように、詳細な処理が書かれていない状態です。
この部分は「自分で考える」必要があります。

具体的には、**単純に疑問点を明確にしていく作業**があるということです。クラス図の内容を箇条書きにすると下のようになります。

1. MainBankクラスはCalculationクラスを持っている(属性を持っている)
2. MainBankクラスはメインメソッドを持っている(操作を持っている)
3. MainBankクラスはatm()を持っている(操作を持っている)
4. Calcurationクラスはyokingaku()を持っている(属性を持っている)
5. CalcurationクラスはgetYokingaku()を持っている(操作を持っている)
6. CalcurationクラスはsetYokingaku()を持っている(操作を持っている)
6. Calcurationクラスはnyukin()を持っている(操作を持っている)
7. Calcurationクラスはvalidate()を持っている(操作を持っている)
8. Calcurationクラスはcalcurate()を持っている(操作を持っている)
9. InputCheckerクラスはvalidNyukinHikidashi()をもっている(操作を持っている)

上のような内容だと**処理の内容が**わかりません。それもそのはず、コーダー(実装者)が行うべき仕事だからです。

早い話が、自分で考えましょうということです。

上のわかっていることで**確定しているところは「属性」**です。なので属性はそのまま実装していしまいます。

#### ポイントその1
フィールド変数に関しては明確になっている、一例ですが下のような部分です。
> 1. MainBankクラスはCalculationクラスを持っている(属性を持っている)

というのは、フィールド変数にCalculationクラスをもっていて、クラス図にある「-」はアクセス修飾子が「private」ということです。

<[MainBank.java](https://github.com/ZenryokuService/PracticeJava1/blob/master/PracticeJava1/src/jp/zenryoku/apps/atm/MainBank.java)>

public class MainBank {
    /** 金銭管理クラス */
    private Calcuration cal;
}

<[Calcuration.java](https://github.com/ZenryokuService/PracticeJava1/blob/master/PracticeJava1/src/jp/zenryoku/apps/atm/Calcuration.java)>

public class Calcuration {
    /** 預金額 */
    private int yokingaku;


<[InputChecker.java](https://github.com/ZenryokuService/PracticeJava1/blob/master/PracticeJava1/src/jp/zenryoku/apps/atm/check/InputChecker.java)>

public class InputChecker {
}

## 2.設計(クラス図)について
設計(クラス図)について考えていきます。

#### 不明点のポイント
どのように実装したらよいか?というところに焦点を当てます。
不明点の残る「操作」に関してはとりあえずメソッドだけ作ってしまいます。
上のクラス図には詳細な返却値などの指定がないので、この部分も不明点 -> 自由に実装してよいところ、となるわけです。

メインメソッドは最後にします、それはこれから作成する「操作」をそろえてから、「不足する操作(メソッド)」を作ってから考えるべきだからです。※不足分を後で追加すると面倒なのです。。。

料理に例えると、先に作成する料理の、材料をそろえるようなイメージです。

まずは、不明点の洗い出しを行います。操作の内容が不明な状態なのでメソッドの一覧を作成することになります。

1. MainBank#main()に関してはメインメソッドなので最後にします。
2. MainBank#atm()は、名前からしてコーダー銀行アプリを起動するメソッドにします。
2. Calcuration#getYokingaku()は名前からしてフィールドの値を取得するメソッドにします。
3. Calcuration#setYokingaku()も名前からしてフィールドの値を設定するメソッドにします。
4. Calcuration#nyukin()メソッドは、名前からしてお金を入金するときのメソッドにします。
5. Calcuration#validate()メソッドは、名前からして入力チェックのメソッドにします。
6. Calcuration#calcurate()メソッドは、名前からして計算処理を行うメソッドにします。

ここまで作成したら、処理のイメージが湧いてくるかと思います。

大まかに、Calcurationクラスで、入金(出金)を行い、預金金額の管理も行う。というところです。

そのためには「入金(出金)(nyukin())」メソッドを用意して、計算処理のメソッド(calcurate())を用意して。。。

というような実装イメージがわくと思います。

具体的にメソッドの枠を作ってみましょう、具体的にはメソッドを空実装(中身の実装をしない)をしてみます。

### 実際の業務として実装するときは
「この部分に関しては「このように実装します。よろしいでしょうか?」などのように上長に確認しましょう。

### 操作の実装
早速、実装していきます。まずは入力(IN)と出力(OUT)を明確にします。この部分は設計の工程になります。
業務としては、この詳細な設計部分は設計書に記載されていることがほとんどですが、たまに「よろしく!」といわれることがあるので、そのときは、自分で考えます。

「このように実装します」という報告は忘れないようにしましょう。

まずは、設計図(クラス図)でもメソッドの量が多いので、CalcurationクラスのI/O(INとOUTのこと)を決定します。「空実装」を行うという意味です。しかし、ゲッターとセッターに関しては処理が決まっているので実装してしまいます。

ここまでの実装は以下になります。

public class Calcuration {
    /** 預金額 */
    private int yokingaku;

    /** コンストラクタ */
    public Calcuration() {
    }

    /** 
     * 預金金額のゲッター
     * @return the yokingaku
     */
    public int getYokingaku() {
        return yokingaku;
    }

    /**
     * 預金金額のセッター
     * @param yokingaku the yokingaku to set
     */
    public void setYokingaku(int yokingaku) {
        this.yokingaku = yokingaku;
    }

    /** 
     * 入金処理 or 引出し
     * @param input 標準入力
     * @param isNyukin
     */
    public void nyukin(Scanner input, boolean isNyukin) {
    }

    /**
     * 入力チェック処理
     * @param in
     * @return true: 入力エラー false: 入力OK!
     */
    private boolean validate(String in) {
        return false;
    }

    /**
     * 
     * @param in 数字文字
     * @param isNyukin ture: 入金処理 false: 引出し処理
     */
    private boolean calcurate(String in, boolean isNyukin) {
        return true;
    }
}

### クラス同士の関係
上のクラス図にあるクラスは以下の3つです。
1. MainBank
2. Calcuration
3. InputChecker

これらの関係性を考えると、下のような役割を持たせてやるとよい関係が築けそうです。
1. MainBank => メインメソッドを実行する
2. Calcuration => 預金金額の計算、管理を行う。
3. InputChecker => 入力チェック処理を管理する。チェック処理はここに書くということです。

今回の実装では、メインメソッドでMain#atm()を呼び出しています。このatm()メソッドがメインになる処理に当たります。

こうする事で、メイン処理を行う前に何かしらの準備処理などを追加しても作成したメイン処理に影響が出ません。ちょっとしたテクニックです。

この部分(クラスの関係)は、アイディアの良し悪しが入ってくる部分ですのでプログラミングの面白いところでもあります。上記のような関係よりも良い関係があればそのように実装するべきです。

そして、それぞれのクラスの役割が決まってきたら次は、空になっているメソッドの実装を行います。

## 3.オブジェクト指向
ここで、頭の中を設計レベルに戻します。

具体的には、どのような処理を行うか?を考えるというところです。

以下のような、手順で考えるとよいと思います。

1. メインメソッドにコメントで処理の順番を記述する

public static void main(String[] args) {
    // 1.MainBankクラスのインスタンス化
    // 2.MainBank#atm()メソッドを呼び出す 
}


2. MainBank#atm()メソッドにコメントで処理の順番を記述する

public void atm() {
    // 1. コーダー銀行の受け付け開始文言を出力
    // 2. 無限ループを開始
    // 3. 初期画面の文言を出力
    // 4. 標準入力を受け付ける
    // 5. "bye"と入力があった場合は処理を終了する
    // 6. 入力チェックをする
    // 7. "in"と入力があった場合は入金処理を行う
    // 8. "out"と入力があった場合は出金処理を行う
}

ここで、"in" もしくは "out" が入力されたときは入金処理を呼び出します。入金時と、出金時を区別するための引数も付けます。

3. 各部品クラス(Calcuration, InputChecker)に実装コメントを書く

この様にすると、不明点を明確にすることができるのではないでしょうか?

あくまでも自分の考えた「設計」なので、もっと良い「設計」があるかもしれません。

この様に、下のクラス(オブジェクト)に役割を持たせ、必要な処理(メソッド)を実装します。処理はなるべく周りに影響が出ないように、実装しているクラスのみに影響範囲が収まるように実装します。

具体的には、メソッドでほかのクラスの処理を呼び出す、用途が限定されるなどのような実装にならないようにするということです。しかし、他のクラスの処理を**必ず呼び出さない**というのも不適切な判断なので、この部分はフレキシブルに実装するべきです。

つまりは、実装の経験(自分で実装してみるなどの経験)により、より良い方法を身に着けることができます。

この様なところが**「知識」ではなく「技術」**なのです。

### クラスのインスタンス化
上記で出てきたクラスについて、考えます。
> 1. MainBank => メインメソッドを実行する
2. Calcuration => 預金金額の計算、管理を行う。
3. InputChecker => 入力チェック処理を管理する。チェック処理はここに書くということです。

ここで、特殊なのは「メインメソッド」です。これは**static**修飾子がついているので、MainBankクラスの中にあっても、定義したメソッド(メンバ・メソッド)を実行するためには、インスタンス化が必要です。
つまり「new」する必要があるということです。

インスタンス化するというのは、**PCのメモリ上に「クラス」で定義したオブジェクトを作成する**ということです。この部分は、とても抽象的なので理解に苦しみました。

自分の場合は、絵にするとわかりやすかったので絵にすると上記のようなクラス図と似たものになりました。
![](http://zenryokuservice.com/wp/wp-content/uploads/2020/11/import1-5.png)

今回の実装では、インスタンス化するクラスは1つなので、複数ある場合を顧慮しなくてよいですが、ただ一つインスタンス化していないクラスつまり、「new」していないクラスがあります。

InputCheckerクラスです。このクラスのメソッドはstatic修飾子がついていて、インスタンス化しなくてよいのです。

staticはクラスの「インスタンスに依存しない」ということなので、起動するあっぷりケーションには必ず1つです。

具体的にはメインメソッドが必ず一つです。そして、staticをつけたXXXメソッドはクラスに一つです。

例えば、上記のCalcurationクラスを複数作成した場合、預金額はCalcurationクラスのインスタンスの数だけ存在します。

public stataic void main(String[] args) {
    Calcuration calA = new Calcuration();
    Calcuration calB = new Calcuration();

    calA.nyukin(); // ここで、入金処理
    calB.nyukin(); // ここで、入金処理

    System.out.println(calA.getYokingaku());
    System.out.println(calB.getYokingaku());
 }

のように実装した場合は、calAとcalBで保持している預金金額の値が**別々に**計算されます。

逆に、預金金額の修飾子にstaticがついていた場合は、calAとcalBで保持している預金金額の値が**同じに**なります。

### 処理の追いかけ方
これは、そのまま読むしかないのですが、まずは決まっているところから記載します。
**まずはメインメソッド**から、処理が始まります。これは絶対です。
なので、メインメソッドの処理を追いかければそのまま処理を追いかけることになります。

詳細に関しては、すでに記載しているので割愛します。

以上で、設計図と実装のつながりが理解できたと思います。

如何でしょうか?

でわでわ。。。

Javaプログラマ Bronze SE 〜資格試験のテキストを学習〜

イントロダクション

Javaを勉強する目的の1つとして「資格を取る」というのがあると思います。

資格試験の学習をすることになりましたので、折角だから内容に関して、自分なりの解説と、練習問題を作成しました。

プログラムとは

早い話が、アプリケーションを作成するものです。色々と記載がありましたが、早い話がそういうことです。

「電卓アプリの場合」
①電卓アプリを起動する → 電卓画面を作成し表示する
そして入力されたことを一時的に記憶する
②数字の「2」をクリックする → 表示エリアに「2」を表示する
そして入力されたことを一時的に記憶する
③「+」をクリックする → 表示エリアに「2+」を表示する
そして入力されたことを一時的に記憶する
④数字の「3」をクリックする → 表示エリアに「3」を表示する
そして入力されたことを一時的に記憶する
⑤「=」をクリックする → 記憶していた「2+3」を元に演算処理を行う
⑥演算結果の「5」を表示する、一時的に臆していた「2+3」を消す

Javaテクノロジーの特徴

①Write Once, Run Anywhere(一度書けばどこでも動く)
②Java仮想マシン(JVM)による処理
③オブジェクト指向

それぞれに細かい説明がありますが、早い話が、JVMをインストールしたデバイス(PC, スマートフォン, スマートデバイス etc...)ならどのデバイスでも動かすことができるというものです。

少し昔の話ですが、Windowsでないと動かない、Macでないと動かない。。。などのような問題があり、アプリケーションを作る方も大変でしたが、昨今はJavaでどのプラットホームでも動くようになりました。
ちなみに、C / C++(言語)では「クロスプラットホーム」などと言って、同じコードをWindows, Linux, MacなどのOSで動くアプリケーションを作成する手段を持っています。

「クロスコンパイル」という方法でアプリを作成します。

Javaでも同じようなことができます。最近だとGLUONでアンドロイド、iOSのどちらでもアプリケーションが作成できるというテクノロジーがあります。

JavaSE

JavaSEとは、Javaテクノロジーのベースになるもので、演算処理のほとんどをこのテクノロジーで実行します。

まとめると、JavaSEの上にJavaMEやJavaEEが乗っている形になります。
「乗っている」というのは土台に「JavaSEがないと動かない」という意味です。

まぁJavaSEの理解ありきでJavaMEとかJavaEEとかやりましょうということです。

JavaME

携帯電話や、家電、コンピュータ以外のプラットホーム向け開発環境

JavaEE

Webアプリケーションを含む、大規模開発向けの開発環境
※大規模アプリケーション=大手百貨店のECサイト、顧客管理、在庫管理などのシステム

開発環境構築

Javaを使用して開発を行うのには(どの言語でも同じですが)開発環境構築が必要になります。

多くの開発現場で使用されているのがEclipseという開発ツール(IDE)です。

行う事は以下の通りです。

1.アプリケーションなので、インストールして使用します。詳細は下のリンクに記載しました。

開発環境構築~Windows版Eclipseの設定~

2.JDKのインストール、JVMが入っています。その他便利なツールがセットになっています。DerbyというDBも入っています。

3.パス(Path)を通す。これは環境変数のPathにJDKに入っているJVM(Java.exe)へのパスを設定します。こうする事で、パソコンはJAVA_HOMEという環境変数の名前でJVMへアクセスすることができます。

プログラムの実行まで

  1. ソースコードを書く
  2. コンパイル
  3. プログラム実行

上の様な手順で実行します。

小さなプログラムであれば作成する、ファイルも少なくオブジェクト指向での実装をしなくても問題ありませんがチームでの開発時には、オブジェクト指向での実装がやりやすいと思います。

そのために、文法やデータ型の理解で学習を終わらせず、クラスの作成〜継承を学習して簡単なアプリを作成するとより実戦的な学習ができると思います。

下のリンクは、簡単なゲームを作成した時の記事です。クラス別に役割を与え実装しました。設計時にどの様に役割分担するか、決めて置くところがポイントです。

Java テキストRPG(戦闘シーンのみ)を再作成する~LWJGLを参考に作り直す~

Java テキストRPG(戦闘シーンのみ)を再作成する2~設計からやり直す~

JavaME 環境調査 ~JavaでIOTを始める~

イントロダクション

JavaでIOTをやりたいと思いラズパイなど色々とちゃくしゅしてみましたが、なかなかに良いものが見つかりませんでした。
現状、実行しているのは、以下のものです。

  1. ラズパイにEJDKインストール
  2. ラズパイ上で動くJavaFXでユーチューブプレーヤー

JavaでIOT

まずは、Java MEに対する理解が全然ないので、調査します。目的は、「Java MEはどのデバイスで使用可能か?」を明確にすることです。

Java MEテクノロジー

JavaMEテクノロジーに関しては、左のリンクからOracleのページに行けば見れます。
このページを参考に調査していきます。

Java MEプラットフォームは以下のコンフィグレーションに分けれらるようです。

使用できるデバイス

  1. Arm(ラズパイ、Arduinoなど色々とある)
  2. 小型デバイス

Arnに関しては、有名なので詳細は割愛します。

そして問題の「小型デバイス」に関しては、調査結果を記載します。

実行環境(OS)の一覧(一部)

  1. MIDP for Palm OSというものがあり、携帯端末で使用することが多いようです。(ちょっと古い)
  2. ITRON
  3. VxWorks
  4. LynxOS
  5. QNX
  6. Enea
  7. Android
  8. Symbian OS
  9. iOS(英語)

調べた結果

JavaMEにはコンフィグレーションによって使用できる環境が変わってくる

  1. 小型デバイス向けコンフィギュレーション - Connected Limited Device Configuration (CLDC)※KVMは数十バイトのメモリでも起動可能
  2. 多機能デバイスとスマートフォン向けコンフィギュレーション - Connected Device Configuration (CDC)
  3. コンバージドサービス用 Java ME プラットフォーム(ネットワーク接続が途切れがちな小型の制限デバイスからオンライン機能をもつモバイルデバイスまで、すべてを対象)

上記のような、分類になっていて、組み込み系システムにも十分行けるようです。KVM(CLDC)に関しても通常のマイコンで起動できそうです。

つまるところ、電子部品を調べて使用可能かどうか?というところから始めればOKというところです。

普通に電子工作するときは電子部品の調査から始めるそうです。

Java Card

参考にするページはオラクルのホームページです。

まずは、実装されているもの、現実に製品化されているものは何か?というところで、以下のようなものがあります。

これらの指輪には、Java Cardのテクノロジーで実装されたアプリがインストールされています。

この部分で、気になるのが、実装方法です。
この部分は、調査が必要ですが、開発ツールはこちらのリンクからダウンロードすることができます。まだまだ調査が必要です。。。

中途半端ですが、

こんなところで失礼します。

でわでわ。。。

Java オブジェクト指向基礎 ~オブジェクト指向コンセプト~

 ## イントロダクション
オブジェクト指向という言葉は皆さん聞いたことがあると思います、これについてちゃんと理解しようと思います。

オブジェクト指向コンセプト

1.なぜオブジェクト指向か

システム開発における課題

開発期間の短縮

顧客の要求やサービスは、早いサイクルで変化します。そのためシステム開発に多くの時間を
かける余裕がありません。それどころか、開発が進んでいる最中に、要求やサービスの内容が
変わっても期間内の対応が求められます。

つまり、仕様変更があっても開発期間が変わらないので、多くの開発者が会社にお泊りすることが
多々ありました。

システムの仕様変更に伴うコストの削減

前述の通り、開発途中で顧客の要求する内容が変わることもありますが、そのたびに初めから
作成していては、期間が延びるだけでなく、費用がかさみます。顧客は最小コストで最大限の
成果を期待します。

この様な問題点に対応するためには、システム開発において、次のことを実現するべきです。

1.1.3実現するべきこと

  1. 以前に作成したプログラムを再利用する
  2. 大勢のエンジニアで共同開発を行う
  3. プログラムの変更箇所をいち早く特定し対応する
  4. あるプログラムの変更がほかのプログラムに影響しないようにする

もし、巨大な1本のプログラムとして構築したら、これらを実現するのは、困難です。しかし、システムを管理しやすい単位で分割し、それらを組み合わせる形式で構築すれば、これらを実現することができます。

この分割の単位をオブジェクトとするのが、オブジェクト指向による開発です。

2. オブジェクトとは

それでは、システム分割単位である「オブジェクト」とは、いったいどのようなものでしょうか。
ここでは、「エアコン」を制御するプログラムを例にそれを見ていきます。

下の図ではエアコンが持つ情報や機能を書きだしたものです。「電源」は電源の情報(状態)、「設定温度」や「運転モード」は使う人が操作した情報(状態)を示すものです。
一方、「電源をON(あるいはOFF)にする」「運転モードを切り替える」「設定温度を変更する」などは、エアコンを操作するための機能です。

エアコンを例にすると。。。

<エアコンの場合>

表1<エアコンの制御プログラム>

係(役目) 情報(状態) 機能
電源係 電源 電源をON、OFFにする
温度係  設定温度 設定温度の変更
温度係  現在の室温 現在の室温を測る
運転係  運転モード 運転モードを切り替える
運転係  運転モード 温度差によって動作を変える

エアコンを制御するプログラムは、こうした情報(状態)を保持し、参照しつつ使う人の操作に応じてエアコンをどうさせます。

<ポイント>

情報(状態)と機能は密接にむずびついて1つの係・役割を担い、それ以外の情報(状態), 機能から互いに独立しているということです。
そして、エアコンが操作されるとそれぞれの係は、互いに要求を行い、連携して動作します。

運転モードの着替え時の場合

運転モードを「冷房」から「ドライ」に変更する操作が行われたら、「運転係」から「温度係」へ設定温度の変更をする「要求」が行われます。また、「運転係」は現在の室温と設定温度を確認しないと動作(冷やす、温める)を決められないので、「温度係」にそれらの情報(状態)を問い合わせます。

この場合、「係」に相当するのが、システムにおけるオブジェクトです
また、「温度係」が電源のON/OFFを切り替えたり、「運転係」が設定温度を変更したりしません。
それぞれの係は自分のすべきことが明確に分かれています(独立性)。

子の係の独立性のおかげで、オブジェクト指向による開発では、作業もオブジェクトごとに独立して進めることができます。開発を終えたオブジェクトは、他のオブジェクトから簡単に利用することができます。また、おかしな動作を押する箇所が出ても、オブジェクト単位で調査・修正するので、利用しているオブジェクトへの影響を軽減することができます。
これにより上記の実現するべき点をかなえることが得できます。

オブジェクト指向言語の機能

属性と操作

Java言語を使用した場合、オブジェクトをどのように表現するのか見ていきましょう。ここでもエアコンの制御プログラムを例に確認します。

先ほどの表(下の図)を見ながら読み進めてください。


表1<エアコンの制御プログラム>

係(役目) 情報(状態) 機能
電源係 電源 電源をON、OFFにする
温度係  設定温度 設定温度の変更
温度係  現在の室温 現在の室温を測る
運転係  運転モード 運転モードを切り替える
運転係  運転モード 温度差によって動作を変える

前節では、係がオブジェクトに相当することを説明しました。さらにオブジェクト指向では、上の図
にある情報(状態)のことを属性と呼び機能のことを操作と呼びます。
例えば、電源系(電源オブジェクト)は「電源」という属性と「電源をONにする」「電源をOFFにする」
という操作が一つのセットにな手出来ています。
温度係(温度オブジェクト)も運転係(運転オブジェクト)も同様です。

つまり、オブジェクトは属性と操作を一体化することで表現されます。

属性と操作

属性と操作について詳しく見ていきましょう。属性は変数として、表現され、名前と値を持ちます。

  • 属性「室内温度」⇒値「30度」
  • 属性「設定温度」⇒値「27度」

属性をプログラムで表現する場合の例

/** 温度係 */
public class Temparature {
  /** 室内温度 */
  int roomTemparature;
  /** 設定温度 */
  int settingTemparature;

 /** コンストラクタ */
  public Temparature() {
    // 例なのでコンストラクタで値を設定する
    roomTemparature = 30;
    settingTemparature = 27;
  }  
}

操作は、他のオブジェクトや自分自身(自オブジェクト)から呼び出されることにより動作し、
そのオブジェクトの状態を変えたり、さらにそこからほかのオブジェクトの操作を呼び出したり
できます。下の図Aでは、温度オブジェクトに「設定温度を変更する」という操作(メソッド)
が定義されています。エアコンの設定温度を変更したい場合には、属性へ直接悪背うするのではなく
この操作を呼び出します。
図A

属性と操作をプログラムで表現する場合の例

/** 温度係 */
public class Temparature {
  /** 室内温度 */
  int roomTemparature;
  /** 設定温度 */
  int settingTemparature;

 /** コンストラクタ */
  public Temparature() {
    // 例なのでコンストラクタで値を設定する
    roomTemparature = 30;
    settingTemparature = 27;
  }

  /** 設定温度を変更する */
  public void setSettingTemparature(int setTamparature) {
    this.setTamparature = setTamparature;
  }
}

カプセル化とデータ隠蔽

オブジェクト指向では、そのオブジェクトが持つ属性と操作を一体化して表現すると説明しましたが、
これをカプセル化と呼びます。

カプセル化には次のようなメリットがあります。

  1. オブジェクトの内部構造を知る必要がない
  2. 属性値の変更は、操作経由に制限できる
  3. 操作名が同じなら、内部構造が変わっても利用する側にそれを意識させない
  4. 属性に不整合な値が入らないよう、操作でチェックできる

エアコンの温度オブジェクトで、カプセル化のメリットを見ていきましょう。

エアコンの設定温度を変更する場合、リモコンなどから、エアコンの「設定温度を変更する」機能
を呼び出します。この時、エアコンの内部構造や制御プログラムなどを知る必要はありません(1)。

そして、それらに直接触れることもありません。ただリモコンで操作するだけです(2)。

もし、後継機種などで「設定温度を変更する」機能の仕組みが変わっても、操作方法が同じなら
そのことで困ることはないでしょう(3)。

さらに温度設定を100度にしたり、零下40度したりはできません。「設定温度を変更する」が、
そのような設定を受け入れないからです(4)。

また、2, 4により、属性を外部から保護することをデータの隠蔽と呼びます。

図B

クラスと継承

クラス

今度は、電源オブジェクトについてみていきます。
前述では、伝げのぶじぇくとの情報(状態)として「電源」、機能として「電源をONにする」と
「電源をOFFにする」を取り上げました。しかし、エアコンの種類によっては、電源をつけると
電気代を表示する機能や、フィルタの汚れ具合を確認し掃除ランプを表示する機能がついている
ものもあります。
これらすべてを電源オブジェクトとして表現したとき、「共通している属性や機能」と
「独自に持っている属性や機能」とに分けられます。

まず、この共通している部分に着目し、土台となるひな型を作成します。
この作業を抽象化と呼びます。また抽象化した結果、オブジェクトを作成するための土台となる

ひな型をクラスと呼びます。

下の図は電源オブジェクト(電気代), 電源オブジェクト(フィルタ)の属性と機能をそれぞれ洗い出した
結果、共通項目が見つかった様子を表しています。

図C

こうしたオブジェクトの共通項目を集め、定義した門が一般的な「電源」クラスとなります。

インスタンス化

クラスは、オブジェクトを作詞得するためのひな型です。つまり設計図にすぎません。
「電源」の設計図ができても、私たちが使える「モノ」ではないのです。
子の設計図であるクラスをもとにして、実際に使うことができる「モノ」にするにすることを
インスタンス化と呼びます。

例えば、下の図Dのようにエアコンを表現するためには、電源クラス、温度クラス、運転クラスが
必要です。それらをまとめるクラスとして、エアコンクラスが必要です。各クラスをもとにインスタンス化することで、それぞれオブジェクト(実際に使うことができる「モノ」)が作成され、実際のエアコンを表現することができます。

また、クラスをもとに複数のインスタンス化を行えば、複数のオブジェクトを作成することができます。
ふたつのエアコンオブジェクトが作成されれば、エアコンオブジェクトを二つ動かすことができます。

これらのオブジェクトは同じクラスから作成されているため、同じ属性・操作を持ちます、しかしエアコンオブジェクトは別々に動きます。

具体的には、上のエアコンオブジェクト二つをエアコンAとエアコンBとしたとき、Aの電源をONにしてBの電源をOFF似しておくこともできます。もちろんエアコンAは設定温度20度、エアコンBは設定温度30度として二つとも動かすことができます。

継承

先ほど説明した電源オブジェクトは、電気代を計算したり、ランプを表示する機能がついていません。
そして、この二つの機能を付けた電源オブジェクトを作成するときに定義する電源クラスを作成する
ためには、新たに電源クラスを作成しなくてもよいのです。

つまり、一度作成した電源クラスを拡張して新しいクラスを定義することができます。
これを継承と呼びます。

オブジェ駆使項では、継承の元となるクラスをスーパークラス(親クラス)と呼び、
拡張したクラスのことをサブクラス(子クラス)と呼びます

継承により定義されたサブクラスは、スーパークラスの属性、操作を受け継ぎます。
そのため、サブクラスでは独自に持つ属性、操作のみを定義するだけで済みます。
サブクラスをインスタンス化すれば、スーパークラスの属性・操作を引き継いだオブジェクトを
が生成されます。

下の図Cのように、共通項目を洗い出し、新たに拡張したクラスを作成する手段として継承
あります。

図C

具体的には下のように実装します。

<電源クラス>

/** 電源クラス */
public class PowerSupply {
  /** 電源 */
  private boolean power;

  /** 電源ON */
  public void switchOn() {
    this.power = true;
  }  

  /** 電源OFF */
  public void switchOn() {
    this.power = false;
  }    
}

<電源クラス(電気代)>

/** 電源クラス(電気代) */
public class ElectricBillPowerSupply {
  /** 電気代 */
  private int electricBill;

  /** 電気代計算 */
  public void calcBill() {
    // 電気代計算の処理
  }
  /** 電気代表示 */
  public void calcBill() {
    // 電気代表示の処理
  }
}

インターフェースとポリモフィズム

私たちは日常でも、たくさんのオブジェクト(モノ)を利用しています。
それらの中には、全く物は別だが、同じ操作方法で利用できるものがあります。

例えば携帯電話はメーカー各社からたくさんの製品が開発・発売されていますが、「電話をかける」
や「電話を切る」という操作はマニュアルを見なくてもできるのではないでしょうか。
また、MDコンポ、CDコンポ、MP3プレーヤーはそれぞれ内部構造も再生する媒体も異なる機械
ですが、「再生」「停止」などの操作に迷わないと思います。

この様に、オブジェクトを利用する側に公開すべき操作をまとめたクラスの仕様のことを
インターフェースと呼びます。

また、共通のインターフェースを持つ操作でも、実際にはオブジェクトごとに振る舞いや動作が異なる
ことをポリモフィズム(多様性・多相性)といいます。

同じ再生ボタンでも、MDコンポ、CDコンポ、MP3プレーヤーの内部で行われることはそれぞれ違います。
もし、MDコンポ、CDコンポ、MP3プレーヤーでインターフェースを統一させていないとしたらどうでしょう。

使用者は、音楽を聴くためのオブジェクトを変える度に違う操作をしなくてはいけません。
これでは面倒で使いづらいでしょう。

プログラムの作成でも同じことが言えます。処理内容は異なるが目的は同じという機能であれば、
オブジェクトに対して、共通のインターフェースを定義し、ポリモフィズムを実現することで、
操作方法が統一され、利便性を高めることができます。ほかのプログラムを再利用することも容易です。

また、後でプログラムを手直ししてでも、機能を呼び出す方法が変わらなければ、
それを呼び出すプログラムには、なにも影響しません。これもインターフェースのメリットの一つです。

でわでわ。。。

関連ページ一覧

Eclipse セットアップ(Mac版)

  1. Java Install Eclipse〜開発ツールのインストール〜
  2. TensorFlow C++環境〜EclipseCDTをインストール〜
  3. Setup OpenGL with JavaJOGLを使う準備 for Eclipse
  4. Eclipse Meven 開発手順〜プロジェクトの作成〜
  5. Java OpenCV 環境セットアップ(on Mac)
  6. Eclipse SceneBuilderを追加する
  7. JavaFX SceneBuilder EclipseSceneBuilder連携~

Java Basic一覧

  1. Java Basic Level 1 〜Hello Java〜
  2. Java Basic Level2 〜Arithmetic Calculate〜
  3. Java Basic Level3 〜About String class〜
  4. Java Basic Level 4〜Boolean〜
  5. Java Basic Level 5〜If Statement〜
  6. Java Basic Summary from Level1 to 5
  7. Java Basic Level 6 〜Traning of If statement〜
  8. Java Basic Level8 〜How to use for statement〜
  9. Java Basic Level 8.5 〜Array〜
  10. Java Basic Level 9〜Training of for statement〜
  11. Java Basic Level 10 〜While statement 〜
  12. Java Basic Swing〜オブジェクト指向〜
  13. Java Basic Swing Level 2〜オブジェクト指向2〜
  14. サンプル実装〜コンソールゲーム〜
  15. Java Basic インターフェース・抽象クラスの作り方
  16. Java Basic クラスとは〜Step2_1〜
  17. Java Basic JUnit 〜テストスイートの作り方〜

Git関連

  1. Java Git clone in Eclipse 〜サンプルの取得〜
  2. Eclipse Gitリポジトリの取得 GitからソースをPullしよう〜
  3. IntelliJ IDEA GitGitリポジトリからクローン〜

JavaFX関連ページ

  1. Eclipse SceneBuilderを追加する
  2. JavaFX SceneBuilder 〜EclipseとSceneBuilder連携~
  3. JavaFX SceneBuilder〜ボタンにメソッドを割り当てるワンポイント〜
  4. Java プロコンゲーム 〜見た目の作成(SceneBuilderの使用)〜

ステップアップ関連ページ一覧

  1. Java 初めてでも大丈夫〜ステップアッププログラミングのススメ〜
  2. ステップアッププログラミング〜Java FxでHelloWorld解説〜
  3. Java StepUpPrograming〜JavaFX で四則計算〜
  4. Java StepUpPrograming〜JavaFXで画面切り替えを作る1〜
  5. Java StepUpPrograming〜JavaFXで画面切り替え2ボタン作成〜
  6. Java StepUpPrograming〜JavaFXで画面切り替え3アクション〜
  7. Java StepUpPrograming〜JavaFXで画面切り替え4Pane切り替え〜
  8. Java StepUpPrograming〜JavaFXで画面切り替え5WebEngine

JavaFX + ND4Jで機械学習準備

  1. JavaFX + ND4J〜数学への挑戦1:ND4Jのインストール〜
  2. JavaFX + ND4J〜数学への挑戦2: 行列の計算〜
  3. Java + ND4J 〜数学への挑戦3: ベクトル(配列)の作成方法〜

オブジェクト指向関連ページ

  1. オブジェクト指向の概念1〜OracleDocのチュートリアル1〜
  2. オブジェクト指向の概念2〜クラスとは〜

業務アプリの内訳〜どんなモノを作るか?〜

業務アプリの内訳

業務アプリは、企業体が業務の遂行に使用するアプリケーションの総称です。大まかに以下のようなモノがあります。

作成するアプリ(システム)

  1. グループウェア(社内SNS)
  2. スケジュール(営業)管理システム
  3. 在庫・販売管理システム
  4. スマホアプリ(Android, iOSなどの携帯やタブレット)

システム概要

グループウェア

社内での、勤怠管理や、勤怠報告(日報)などに加えて、チャットでの相談やスケジュール調整機能などを実装

具体的にはNotesが有名です。

スケジュール管理システム

営業の仕事を助けるため、スケジュール管理と必要な部署へのリンクや地図サービスと連携して位置情報を付随させるなど多岐に渡り機能をつけている。在庫管理システムとの連携も多い

上記のアプリは、ほぼ全ての企業(社員300人以上)が使用しているであろうアププリケーションで、必要になる技術をまとめてみました。

ITエンジニアと言ってもやる事は多種多様です。実態としては、各企業の業務内容に依存するために作業は多種多様になります。

上記のモノは、会社として、多くの企業が使用しているであろうモノです。

「〜であろう」というのは、自分の経験上、自分はJavaエンジニアで、受ける仕事は、大体上記の分類になるという意味です。

珍しいのは、組み込み系(C/C++で多い案件だが、オブジェクト指向を理解しているので、Javaエンジニアの自分にも紹介が来た)とか、画像処理(医療機器アプリ)などがありました。

使用する技術

上記の4.スマホアプリを除いては、以下のような技術を使う事が多かったです。

大まかに、以下のような技術を使用します。

画面(ブラウザ表示)の作成

HTMLとJS(Java Script)

これらの技術を併用して、画面やボタン簡単なアニメーションを作成します。スマホやPCのディスプレイサイズの違いによって、表示レイアウトを変更する、CSSでのレスポンシブデザインなんて手法もあります。この部分は

MVCモデルのV(View)に相当する部分です。

リクエストハンドル

Java, PHP

同様に、これらの技術を使用して、ユーザーからアクセスされたページに遷移させる処理の事です。

MVCモデルのC(コントロール)にあたる部分です。

主に、ログインユーザーかどうか判定し、会員以外は全てアクセス出来ないようにするなど、セキュリティのために使用したり、新規・既存の画面への画面遷移コントロールなどに使用します。

そして、あまり耳にしないかもしれませんが、アプリのログ出力や、セッション(サーバー上で管理するユーザー情報オブジェクト)のチェックを行うフィルター処理やAOPと呼ばれる技術を使用して、サーバーサイドのメソッド呼び出し前後に共通処理を挟み込む事もあります。

しかし、最近ではRESTful実装が流行りで、画面=V(View)側から直接コントローラを呼び出す実装方法が増えてきています。というかほぼこれかも?

ちなみにPHPでもこの実装方法は実現可能です。ワードプレスのライブラリ読み込みでちょいと処理が遅いけど、作りました。以下のリンクがそうです。ヘッダー部分のカテゴリを選択すると対応する記事の一覧を取得します。ちなみにAngularJSも使用しました(笑)

https://zenryokuservice.com/#!/pgbox

モデル

うまい表現が見つからなかったのでウィキから引用します。

アプリケーションデータ、ビジネスルール、ロジック、関数

という表現をしていました。詳細は、コントローラーから呼び出されるサービス処理=ビジネス・ロジック(業務処理)がそうです。コントローラーはリクエストを受け付けるのが役割なので、DBにアクセスしたり、細かい計算をするのはモデル(M)の役目になります。

これらの処理は、フレームワークというものを使用してやると実装する量を格段に減らす事が出来ます。

有名なところでは、以下のようなものがあります。

これらのフレームワークを使用して上記のようなアプリを作成する事が多くあります。古いのだとS2Strutsなんてのもあります。

丁度この頃にAOPという技術も出て来て、よく混乱しました(笑)

まとめ

早い話が、MVCモデルがわかれば大体の業務アプリは、対応が可能になるという事です。

そのために、理解する必要があるのは「オブジェクト指向」です。

XXXを行う処理を作成しで下さいというような問題では、あくまでも各機能の小さな一部の処理のみの話です。

この一部の処理を作れる必要はありますが、アプリケーション設計〜テスト迄の大まかな内容を理解するには、クラス間のやり取り、関連性を構築する技術が必要ようです。

そのために、下のリンクにあるようなフローでJavaを学ぶと効率的だと思い学習フローなんぞ作成しました。

Java Basic 学習フロー

ハローワールドに始まり、クラスの作成、役割分担などオブジェクト指向の考え方と実装方法に関して記載した記事のリンクと補足を記載しています。

シンプルに簡単なコンソールアプリを作成してみるのも良いと思います。

Java ミニゲーム ソース 〜じゃんけんゲーム in Console 〜

でわでわ。。。

Java テキスト 〜はじめてのJava コンソール表示〜

はじめてのJava

はじめてJava言語を使用してプログラミングを始めようとしている方向けです。Javaというプログラミング言語はC言語から生まれた言語で、現在(2020-11-11)は多くのアプリケーションで使用されています。具体的には以下のようなものにしようされています。

  1. 証券の取引や銀行のATMなど
  2. Androidアプリ
  3. 大手企業の基幹系システム

挙げればきりがないので、この辺にしておきますが、日本では多くの分野で使用されています。

有名なところだと、マインクラフトでもLWJGLというフレームワーク(Java製)を使用しています。下のような感じで動かせます。

Javaを動かしてみよう

Javaは以下のように、コードの作成~コンパイル~実行と行います。

  1. Javaコードを人力で書く(人間が読めるファイルができる)
  2. コンパイルする(人間が読めないファイルができる)
  3. 作成したプログラム実行

Hello World

まずは写経から入ります。以下のコードを書き写して動かしてみてください。テキストエディタでFirst.javaというファイルを作成します。

public class FirstCls {
  public static void main(String[] args) {
    System.out.println("Hello World");
  }
}

実行方法は以下の通り

  1. 上のコードを映してFirstCls.javaファイルを作成する
  2. 「ウィンドウズボタン+R」を押下して「cmd」と入力、コマンドプロンプトを開く
    コマンドプロンプト
  3. javacコマンドでクラスファイルを作成する
  4. javac FirstCls.java
  5. javaコマンドで作成したクラスファイルを実行する
  6. java FirstCls

これで、実行できたと思います

サンプルアプリの実行

  1. 以下のZIPファイルをダウンロード
  2. 展開後に/xylophone/src/xylophone/Xylophone.javaをEclipseプロジェクトにコピー、実行できるようにする
  3. Eclipseプロジェクト/resporces/の下に/xylophone/src/xylophone/audioをコピー
  4. 実行 ※エラーが出たら以下の部分を直してみる
    Xylophone.java:67行目にエラーが出たとき
  5. new AudioClip(Xylophone.class.getResource("audio/Note1.wav").toString());
  6. の「audio/Note1.wav」を「/audio/Note1.wav」に修正してみる

1章:ようこそJavaの世界へ

1.1 Javaによる開発の基礎知識

1.1.1 開発の流れ

①ソースコードの作成。

public class FirstCls {
  public static void main(String[] args) {
    System.out.println("Hello World");
  }
}

②コンパイル
javaファイルをclassファイルに変換することです。下のコマンドを使用します。

javac FirstCls.java

③実行
作成したクラスファイルを実行します。下のコマンドを使用します。

java FirstCls

1.1.2 開発環境の整備

※Eclipseはインストール済みの想定。

外観を変更する

  1. ウィンドウ→設定→一般→外観→色とテーマの順にクリック
  2. ここで好きなテーマを選択する
    ※大半の人がデフォルトで使用している
    色・テーマの設定

文字コードの変更(確認)

  1. ウィンドウ→設定→一般→ワークスペースの順にクリック
  2. 「テキスト・ファイル・エンコード」がUTF-8になっていることを確認

JDKの確認

  1. ウィンドウ→設定→一般→Java→インストール済みのJREの順にクリック
  2. JDKを指定して、使用するJREを決定する
    JRE

1.2 Javaプログラムの基本構造

1.2.1 プログラムの骨格

ルール:クラス名とファイル名は同じ名前にする
「クラスの中にメソッドがある」

/** クラスの説明 */
public class クラス名 {
  /** メソッドの説明 */
  public static void main(String[] args) {
    // 何かしらの処理
  }
}
  • 中かっこ(「{」「}」)のことを「スコープ」と呼びます。スコープで囲っている部分を「ブロック」などと呼んだりします。
  • このスコープ(=「ブロック」)を開いたら(開始したら)、必ず閉じる(終了する)ことを意識する
  • 中かっこ(「{」「}」)で囲っている部分がそれぞれクラスの範囲、メソッドの範囲を決めている

上のサンプルコードでは「クラス名」クラスの中に「メインメソッド」がある

ちなみに、インデント(スペースやタブで位置をずらすこと)を入れないと、とても見にくい

何が見にくいというと、クラスの範囲と、メソッドの範囲を区別しずらいのです。

<インデントなし>

/** クラスの説明 */
public class クラス名 {
/** メソッドの説明 */
public static void main(String[] args) {
// 何かしらの処理
}
}

1.2.2 プログラムの書き方

Java言語(C言語も)の場合は、メインメソッドが起動しますので、クラスの中にメインメソッドを作成する

Javaはメインメソッドが動く

  1. どのようなプログラムを作りたいかを考えます。
  2. プログラムの名前を決めます。
  3. 「クラス名.java」という名前でファイルを作ります。
  4. 下のような、ソースコードの外側を記述します。
  5. /** クラスのJavaDocコメント */
  6. public class クラス名 {
  7. /** メインメソッドのJavaDocコメント */
  8. public static void main(String[] args) {
  9. // 処理の中身:通常のコメント
  10. /*
  11.  * これも通常のコメント、あまり使われない。
  12.  */
  13. }
  14. }
  15. ソースコードの中身を描きます。
  16. System.out.println("Hello World!");
  17. 1.2.5 mainメソッドの中身

  • 上の骨格の「何かしらの処理」の部分に処理を描く。
  • 処理は上から下へ進み、1行の中では左から右へ進む
  • セミコロン「;」で1行が終わる
  • ドット「.」は参照呼出し
public static void main(String[] args) {
  System.out.println("Hello World");
}

上のコードは、Systemクラスから変数「out」を呼び出し、メソッド「println()」を呼び出している

練習:SecondProgram

写してください。以下のコードを書いて動かしてください。

public class SecondCls {
  public static void main(String[] args) {
    System.out.println("*** Second Program ***");
    System.out.println("日記ソフト");
    System.out.println("終了します。");
  }
}

実行方法は以下の通り

  1. SecondCls.javaファイルを作成する
  2. 「ウィンドウズボタン+R」を押下してコマンドプロンプトを開く
    コマンドプロンプト
  3. javacコマンドでクラスファイルを作成する
  4. javac SecondCls.java
  5. javaコマンドで作成したクラスファイルを事項する
  6. java SecondCls

1.3 変数宣言の文

1.3.1 変数宣言の文とは?

ズバリ下のように書きます。

  1. 変数の宣言
  2. // 「宣言」:データ型 変数名;
  3. int hensuMei;
  4. 変数の初期化
  5. // 「初期化」データ型 変数名 = 代入するデータ
  6. int dataGata = 0;

1と2の違いは、宣言と同時に値を代入するかしないかです。

==変数の宣言と初期化==

public static void main(String[] args) {
  // 変数の宣言
  int num;
  // 変数の代入
  num = 0;
  // 変数の初期化
  int age = 12;
  // 命令実行の文=メソッドの呼び出し
  System.out.println("対象年齢は" + num + "~" + age + "です。");
}
  • 「変数に値を代入するとき」は「=」を使用する。
  • 「命令の文」は「メソッド呼び出し」を行う

1.3.2 変数の名前(識別子)

==英語では==
変数=Valiable

名前つけのルール

  1. 予約語は使用しない
1 2 3 4 5
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
  1. 宣言(初期化)済みの変数名は使用できない
  2. 大文字・小文字は区別される
  3. 変数名・メソッド名はキャメルケースを使用する
  4. // 変数名のキャメルケース(頭を小文字にする)
  5. int myAge;
  6. // メソッド名のキャメルケース(頭を小文字にする)
  7. public void methodName();
  8. クラス名はアッパーキャメルケース
  9. /** クラス名は頭を大文字にする */
  10. public class ClassName {
  11. }
  12. 演算子で使用している文字、予約語は変数名(クラス名)として使用できない

==計算処理==

public static void main(String[] args) {
  // 足し算
  int tashizan = 1 + 1;
  // 引き算
  int hikizan = 1-1;
  // 掛け算
  int kakezan = 1 * 1;
  // 割り算
  int warizan = 1 / 1;
}

1.3.3 データ型

※あくまでも使用例として紹介しています。
==プリミティブ型データの変数型==

  • byte ファイル・ネットワーク通信時に使用
  • int 整数データを格納するのに使用
  • long 大きな整数値を格納するのに使用
  • float 画像処理、3Dモデル描画時に使用
  • double 少数データを格納するのに使用
  • char 1文字分のデータ、シングルクォーテーション「`」で囲む

==参照型データの変数型==

  • String 文字列
  • そのほかJavaAPIや自作のクラス名
  • List<String> list; // List型の変数「list」

1.3.5 定数の利用

変数には値を何度でも代入できるので、定数を使用して値を変更できないようにする。

final データ型 変数名 = 代入するデータ

ルール:定数は大文字の変数名にする

final int OVER_TEN = 0; // 値が10以上を示すフラグ
final int UNDER_TEN = 1; // 値が10以下を示すフラグ


定数の使用例:フラグに使う

public static void main(String[] args) {

}

1.5 練習問題+α

コマンドプロンプト上に下のような図を表示するプログラムを作成してください。
※ 「=」の数が、上下ともに20あります。

<出力する図>

      *
    *   *
  *   *   *
      *
      *
  *   *   *
    *   *
      *

式と演算子

演算子

番号 演算子 意味
1 .(ドット) メソッド、フィールドの呼び出し
2 new クラスのインスタンスを作成するときに使用する
3 == 左右の数値が等しいか判定する(TRUE / FALSEを返す)
4 != 左右の数値が等しくないか判定する(TRUE / FALSEを返す)
5 & ビット演算 AND =「~かつ~」のときTRUE、それ以外はFALSE」
6 | ビット演算 OR =「~または~」のときTRUE、両方ともFALSEの場合はFALSE
7 ? XX : YY 三項演算子 =「論理演算 ? TRUEの時の値 : FALSEの時の値」:

例 String res = 1 == 1 ? "TRUEの場合": "FALSEの場合";

2.2 オペランド

2.2.1 リテラル

実際の値のこと

2.2.2 エスケープシーケンス

バックスラッシュ「\」もしくは、「¥」円記号(半角)をつけた文字のことでメタ文字を「文字」として使いたいときに使用する。

<例>

// 「"」は文字列を加工形で表示するためにエスケープシーケンスを使用する
// ※「"」を文字列として使用したいときは「エスケープ」する
String moji = "Javaのはじめの\"J\"は1文字目";

2.3 評価のしくみ

下のような式があったとします。
「1 + 5 -3」この式をプログラムで書くと次のコードになります。

public static void main(String[] args) {
  // 上の計算式
  int answer = 1 + 5 - 3;
}

このようなときに、処理の順序、「1 + 5」と「5 - 1」の評価はどのように行われるか?

左から順に評価していきます

つまり、以下の順序です。

  1. 1 + 5の計算結果を出す
  2. 上の結果に」「-1」する

==しかし掛け算は先に処理を行う
つまり以下のような優先順位で評価します。

  1. 「掛け算・割り算」→「足し算・引き算」の順序
  2. 左から順に評価

まとめると

  1. 「掛け算・割り算」→「足し算・引き算」の順序で評価
  2. 「=」以外の演算子は、左から順に評価
  3. 「=」は右から評価
問題+α

以下のコードの場合、どのような順序で評価されるでしょうか?

System.out.println("Hello World!");

実行順序として正しいものを、の中から選びなさい

  1. Systemクラスの公開フィールド変数out(PrintStreamクラス)を取得
  2. フィールド変数out(PrintStreamクラス)のメソッドprintln()を評価(呼び出している)

  1. メソッドprintln()を取得
  2. フィールド変数out(PrintStreamクラス)のSystemを評価(呼び出している)

2.4 演算子

2.4.1 算術演算子

演算子 機能 優先順位
+ 足し算
- 引き算
* 掛け算
/ 割り算

2.5 型の変換

2.5.3 強制的な型変換(キャスト)

「int型」を「double型」に変換するというような形のキャスト
<具体例>

int num = 10;
// 強制的な型変換
double dd = (doubble) num;

// 下のやり方はエラーになる
// int num1 = (int) "10";

// 型をメソッドを使用して変換している
String tmp = String.valueOf(num);

// Stringが票差化された(左に文字列が先にある)あとであれば
// intやdoubleも文字列として評価される(自動キャスト)
System.out.println("aaaa" + 10.1);

異なる型同士の算術演算

返却値(左側の変数型)は、大きいほうの型のデータ型が優先される

2.6 命令実行の文

2.6.5 乱数を生み出して代入する命令

// 3を上限値として乱数を生成する
int r = new java.util.Random().nexInt(3);

上にあるような「java.XXX.XXX」のようなパッケージはJDKの中にあるライブラリに定義されています。
そして、それらAPI群の使い方に関してはJavaDocに書かれています。

2.7 まとめ

命令の実行はメソッド呼び出しのこと

Android OpenCV 〜サンプルアプリを動かす〜

イントロダクション

アンドロイドでのOpenCVアプリを作成しようと考えています。
そんなわけで、下のサイトを参照してプログラムを動かしてみました。

以下の記述は参考サイトを実行して見た内容です。

AndroidでOpenCV

参考サイト: Android Pub

Step 1: Download OpenCV Android Library

ライブラリのダウンロード

  1. OpenCV + Androidのチュートリアルページを開きます。

  2. そして、OpenCV-android-sdkをダウンロードします。ZIPファイルをAndroid開発用のフォルダに展開します。

Step 2: Setup project

プロジェクトの作成

  1. Android Studioを開き、Emptyプロジェクトを作成する
    activity1

  2. プロジェクトの名前などを設定する

Step 3: Import OpenCV Module

OpenCVの取り込み

  1. 作成したプロジェクトを開いた状態で、File -> New -> Import Moduleを選択する

  2. プロジェクトの作成でダウンロード、展開した、ZIPファイルから「sdk/java」を指定する

  1. モジュールをインポートしたらビルドが始まるがエラーになる

Step 4: Fixing Gradle Sync Errors

build.gradleファイルを修正する


使用する実機がバージョン4.XだったのでminSdkVersion、targetSdkVersionを4に修正します。

Step 5: Add the OpenCV Dependency

OpenCVの依存性追加

  1. OpenCVライブラリの追加、ProjectStructure->Dependencies

Step 6: Add Native Libraries

ネイティブライブラリをコピーする

  1. OpenCVライブラリからAndroidプロジェクトのmainフォルダにペースト
  2. ペーストしたフォルダの名前を「jniLibs」に修正

Step 7: Add Required Permissions

AndroidManifest.xmlの修正

作成するプロジェクトのappフォルダにあるAndroidManifest.xmlに以下のコードを追記する

<uses-permission android:name="android.permission.CAMERA"/>

<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>

最終的に下のようなファイルになる

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="jp.zenryokuservice.androidopencv">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

    <uses-permission android:name="android.permission.CAMERA"/>

    <uses-feature android:name="android.hardware.camera" android:required="false"/>
    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
</manifest>

adbコマンド準備

  1. AndroidSDKのインストール場所を確認する
    • File -> androidOtherSettings -> DefaultProjectStructure...
      DefaultProjectStructure!
  2. ターミナルを立ち上げて、パスを通す
    • viコマンドで「.bash_profile」を開く
    • sdk/platform-toolsを追加する

サンプルソースを読む

起動している、コードは参考サイトにあるコード(MainActivity.java)です。
アンドロイドアプリの実装では、準備処理と起動時の処理でメソッドが分かれているので、主要な部分を見ます。

    public boolean onTouch(View v, MotionEvent event) {
        int cols = mRgba.cols();
        int rows = mRgba.rows();

        int xOffset = (mOpenCvCameraView.getWidth() - cols) / 2;
        int yOffset = (mOpenCvCameraView.getHeight() - rows) / 2;

        int x = (int)event.getX() - xOffset;
        int y = (int)event.getY() - yOffset;

        Log.i(TAG, "Touch image coordinates: (" + x + ", " + y + ")");

        if ((x < 0) || (y < 0) || (x > cols) || (y > rows)) return false;

        Rect touchedRect = new Rect();

        touchedRect.x = (x>4) ? x-4 : 0;
        touchedRect.y = (y>4) ? y-4 : 0;

        touchedRect.width = (x+4 < cols) ? x + 4 - touchedRect.x : cols - touchedRect.x;
        touchedRect.height = (y+4 < rows) ? y + 4 - touchedRect.y : rows - touchedRect.y;

        Mat touchedRegionRgba = mRgba.submat(touchedRect);

        Mat touchedRegionHsv = new Mat();
        Imgproc.cvtColor(touchedRegionRgba, touchedRegionHsv, Imgproc.COLOR_RGB2HSV_FULL);

        // Calculate average color of touched region
        mBlobColorHsv = Core.sumElems(touchedRegionHsv);
        int pointCount = touchedRect.width*touchedRect.height;
        for (int i = 0; i < mBlobColorHsv.val.length; i++)
            mBlobColorHsv.val[i] /= pointCount;

        mBlobColorRgba = converScalarHsv2Rgba(mBlobColorHsv);

        Log.i(TAG, "Touched rgba color: (" + mBlobColorRgba.val[0] + ", " + mBlobColorRgba.val[1] +
                ", " + mBlobColorRgba.val[2] + ", " + mBlobColorRgba.val[3] + ")");

        mDetector.setHsvColor(mBlobColorHsv);

        Imgproc.resize(mDetector.getSpectrum(), mSpectrum, SPECTRUM_SIZE, 0, 0, Imgproc.INTER_LINEAR);

        mIsColorSelected = true;

        touchedRegionRgba.release();
        touchedRegionHsv.release();

        return false; // don't need subsequent touch events
    }

このコードで注目したいのは、「赤い線をつけている部分」です。

結論、下の部分で画面に表示している情報を更新しているように思います。
<MainActivity.java>

// Calculate average color of touched region
mBlobColorHsv = Core.sumElems(touchedRegionHsv);
int pointCount = touchedRect.width * touchedRect.height;
for (int i = 0; i < mBlobColorHsv.val.length; i++)
    mBlobColorHsv.val[i] /= pointCount;

mBlobColorRgba = converScalarHsv2Rgba(mBlobColorHsv);

Log.i(TAG, "Touched rgba color: (" + mBlobColorRgba.val[0] + ", " + mBlobColorRgba.val[1] +
        ", " + mBlobColorRgba.val[2] + ", " + mBlobColorRgba.val[3] + ")");

mDetector.setHsvColor(mBlobColorHsv);

Imgproc.resize(mDetector.getSpectrum(), mSpectrum, SPECTRUM_SIZE, 0, 0, Imgproc.INTER_LINEAR);

動かして見たところ、上記のメソッドで画面をタッチしたときの色を取得しているようです。

そして、その色の輪郭部分を描画している。。。ように見えます。
その部分が以下のコードです。
<MainActivity.java>

if (mIsColorSelected) {
    mDetector.process(mRgba);
    List<MatOfPoint> contours = mDetector.getContours();
    Log.e(TAG, "Contours count: " + contours.size());
    Imgproc.drawContours(mRgba, contours, -1, CONTOUR_COLOR);

    Mat colorLabel = mRgba.submat(4, 68, 4, 68);
    colorLabel.setTo(mBlobColorRgba);

    Mat spectrumLabel = mRgba.submat(4, 4 + mSpectrum.rows(), 70, 70 + mSpectrum.cols());
    mSpectrum.copyTo(spectrumLabel);
}

mDetectorはサンプルコードにあるクラスで輪郭部分の描画を行なっているように見えます。

ちょっと自信がないので、「〜のように見えます」と記載しています。

輪郭部分を塗りつぶす

サンプルの実行では下の通りです。

あとは、コードを弄り確認することにします。

でわでわ。。。

Android OpenCV 〜環境構築エラー: The minSdk version should not be declared〜

AndroidでOpenCVを使うときのエラー

下のようなメッセージが出力されてビルドができない状態でした。

ERROR: The minSdk version should not be declared in the android manifest file. You can move the version from the manifest to the defaultConfig in the build.gradle file.
Remove minSdkVersion and sync project
Affected Modules: openCVLibrary2411

解決方法として参考にしたサイトは以下です。

結論

エラーメッセージの通りに修正してやれば直しました。

実施したこと

  1. インポートしたopencvライブラリのプロジェクトのbuild.gradleファイルにある以下のコードをコメントアウト
        defaultConfig {
    //        minSdkVersion 4 // 8
        targetSdkVersion 26 // 8
    }
  2. 「The minSdk version should not be declared in the android manifest file」が出力されたので、OpenCVライブラリのプロジェクトにあるAndroidManifest.xmlを修正
    <修正前>

    <uses-sdk android:minSdkVersion="26" />

<修正後>

<!--- <uses-sdk android:minSdkVersion="26" /> --->

これで、ビルドエラーの解消ができました。

でわでわ。。。

Java Basic API ~Java API Stringクラスを理解するwith JUnit~

イントロダクション

Javaでプログラミングを初めて慣れたころにJavaAPIに触れることが多くなると思います。

よくある「プログラミング練習問題」などで、文字列操作を行うことがあると思います。

この様な時に使用するのがStringクラス手に定義してあるメソッド群だと思います。しかし、説明書きしているJavaDocが難しく理解するのが難しいことが多いと思います。

この解決方法として、動かしてみるというのが手っ取り早い方法の一つだと思いますので、手っ取り早い方法を記載いたします。

JavaSEで提供しているクラスを理解

簡単にプログラムを動かす方法として、IDE(Eclipseを使用します)で動かしてみるのが手っ取り早い方法ですが、如何せんメインメソッドを使用していると毎回コードを書き直さなくてはいけないので面倒です。

なので、以下の方法を提案したく思います。

JUnitを使う

JUnitはテストツールとして使用することが多いもの(フレームワーク)です。これを使用すれば下のように簡単に、いくらでもコードを動かせます。

下のは、String#equalsメソッドをテストしたものですが、「@Test」をつけたメソッドはすべて実行されるので、どんどん作成して実行すればよいのです。
<例>

public class StringTest {

    /** String#equalsのテスト */
    @Test
    public void test01() {
        String st = "aaa";
        String s1 = "aaa";
        String s2 = "bbb";
        String s3 = "ccc";

        if (st.equals(s1)) {
            System.out.println("st == s1");
        } else {
            System.out.println("st != s1");
        }

        if (st.equals(s2)) {
            System.out.println("st != s2");
        } else {
            System.out.println("st == s2");
        }

        if (s3.equals(s1)) {
            System.out.println("s3 == s1");
        } else {
            System.out.println("s3 != s1");
        }
    }
}

実行結果

テストを増やす

StringクラスのJavaDocを見るとよく使うメソッドがあるので、それを紹介するついでに上のテストケースで実行します。
実際の作業を動画にしました。参考にどうぞ。

そして、実行するときにJUnitの設定をする必要があります。

Eclipseを使用しているならば、下のような手順ですぐに使用できます。

JUnitの設定

  1. Eclipeのプロジェクトを右クリック
  2. プロパティを選択
  3. ライブラリの追加をクリック
  4. JUnitを選択し次へ
  5. 次の画面では、完了をクリック

下のように、ライブラリが追加されているはずです。

String#substring

JavaDocでStringクラスを見るとStringクラスの中に定義されているメソッド群があります。説明がちょっと難しく理解に苦しむことがありますが、これを動かしてみれば、ドキュメントの内容がわからなくても問題ありません。逆に、ドキュメントの内容が理解できたりします。

具体的には、上の動画でも実行していますが、下のように実行します。

  1. JavaDocで試したいメソッドを見つける
  2. 対象のメソッドのテストケースを作成する
  3. テストを実行して挙動を確認する

作成したコード(テストケース)は下のような形です。

public class StringTest {

    /** String#equalsのテスト */
    @Test
    public void test01() {
        String st = "aaa";
        String s1 = "aaa";
        String s2 = "bbb";
        String s3 = "ccc";

        if (st.equals(s1)) {
            System.out.println("st == s1");
        } else {
            System.out.println("st != s1");
        }

        if (st.equals(s2)) {
            System.out.println("st != s2");
        } else {
            System.out.println("st == s2");
        }

        if (s3.equals(s1)) {
            System.out.println("s3 == s1");
        } else {
            System.out.println("s3 != s1");
        }
    }

    /**
     * JavaDocをみて、入力(引数)と出力(返却値)を確認後、実装して動かしてみる。
     * {@link String#substring(int)}のテストケース
     */
    @Test
    public void testSubstring() {
        String target = "abcdefg";
        // 2番目の文字を取得する
        String res = target.substring(1, 2);
        System.out.println("2番目の文字: ");
        // 取得結果が正しいか確認
        assertEquals("b", res);
        // 一番初めの文字を取得
        String res1 = target.substring(0, 1);
        assertEquals("a", res1);
        // 一番最後の文字
        String res2 = target.substring(target.length() -1, target.length());
        assertEquals("g", res2);
        // 初めから4文字分を切り出す
        String res3 = target.substring(0, 4);
        assertEquals("abcd", res3);
    }
}

equalsは調べなくてもわかると思いますが、substringはどうでしょうか?
ドキュメントには、下のような説明があります。

この文字列の部分文字列である文字列を返します。部分文字列は、指定されたbeginIndexから始まり、インデックスendIndex - 1にある文字までです。したがって、部分文字列の長さはendIndex-beginIndexになります。

とりあえずは、第一引数に開始、第二引数に終了のインデックス(数値)を設定します。

String res3 = target.substring(0, 4);

実行した結果がどのように取得できるか?これを確かめます。

assertEquals("abcd", res3);

実行後に、いまいちわからない場合は、値を変えてみます。上記の「0, 4」は初めから4文字を取得する場合ですが、2文字目から4文字目までを取得する場合はどうでしょうか?下のように「2, 4」と設定すれば想定通りに動くでしょうか?

String res3 = target.substring(0, 4);

それはテストしてみれば一発です。

assertEquals("取得するであろう値", 結果を格納した変数);

この様な形で、実装すればJavaAPIの理解を深めることができます。

色々なクラスを理解し、技術の幅を広げるのに役に立つと思います。

でわでわ。。。

関連ページ一覧

Eclipse セットアップ(Mac版)

  1. Java Install Eclipse〜開発ツールのインストール〜
  2. TensorFlow C++環境〜EclipseにCDTをインストール〜
  3. Setup OpenGL with Java〜JOGLを使う準備 for Eclipse〜
  4. Eclipse Meven 開発手順〜プロジェクトの作成〜
  5. Java OpenCV 環境セットアップ(on Mac)
  6. Eclipse SceneBuilderを追加する
  7. JavaFX SceneBuilder 〜EclipseとSceneBuilder連携~

Java Basic一覧

  1. Java Basic Level 1 〜Hello Java〜
  2. Java Basic Level2 〜Arithmetic Calculate〜
  3. Java Basic Level3 〜About String class〜
  4. Java Basic Level 4〜Boolean〜
  5. Java Basic Level 5〜If Statement〜
  6. Java Basic Summary from Level1 to 5
  7. Java Basic Level 6 〜Traning of If statement〜
  8. Java Basic Level8 〜How to use for statement〜
  9. Java Basic Level 8.5 〜Array〜
  10. Java Basic Level 9〜Training of for statement〜
  11. Java Basic Level 10 〜While statement 〜
  12. Java Basic Swing〜オブジェクト指向〜
  13. Java Basic Swing Level 2〜オブジェクト指向2〜
  14. サンプル実装〜コンソールゲーム〜
  15. Java Basic インターフェース・抽象クラスの作り方
  16. Java Basic クラスとは〜Step2_1〜
  17. Java Basic JUnit 〜テストスイートの作り方〜

Git関連

  1. Java Git clone in Eclipse 〜サンプルの取得〜
  2. Eclipse Gitリポジトリの取得 〜GitからソースをPullしよう〜
  3. IntelliJ IDEA Git〜Gitリポジトリからクローン〜

JavaFX関連ページ

  1. Eclipse SceneBuilderを追加する
  2. JavaFX SceneBuilder 〜EclipseとSceneBuilder連携~
  3. JavaFX SceneBuilder〜ボタンにメソッドを割り当てるワンポイント〜
  4. Java プロコンゲーム 〜見た目の作成(SceneBuilderの使用)〜

ステップアップ関連ページ一覧

  1. Java 初めてでも大丈夫〜ステップアッププログラミングのススメ〜
  2. ステップアッププログラミング〜Java FxでHelloWorld解説〜
  3. Java StepUpPrograming〜JavaFX で四則計算〜
  4. Java StepUpPrograming〜JavaFXで画面切り替えを作る1〜