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 例外の処理方法 〜try catchの使い方とFile入出力〜

イントロダクション

前回は、ポリモーフィズムの実装を行いました。

これは、クラスの継承関係を作り、クラスの型をうまく変換して多様な使い方を行うというものでした。

例えば、下のような使い方をしました。

勇者率いるパーティを表現

public static void main(String[] args) {
        Character[] party = new Character[2];
        party[0] = new Hero("太郎");
        party[1] = new Wizard("二郎");

        System.out.println("こんにちは、良いパーティですね。");
        for (int i = 0; i < party.length; i++) {
            // ここの処理を変更する必要がある
            System.out.println(party[i].getName() + "さん");
        }
}

この実装は、下の図のように、クラスの継承関係作り、Hero, Wizardのクラスを1つのデータ型( クラス型)として使用しています。

Javaプログラムは「型」を重視するので、データ型は厳密です。これがはっきりしていないと、デバックするときに変数の中身のデータ型を確認するためにコードを追いかけなくてはいけません。。。

しかし、このような形でクラスの継承関係を作ると、いろんな組み合わせが可能になります。

このような実装のことを「ポリモーフィズム」と言いました。

<抽象クラスを使った例>
Calendarクラスはインスタンスを取得するときに「カレンダ・フィールドは現在の日付と時間に初期化」されるため。
「getInstance()」でインスタンスを取得する。

<インタフェースを使用したポリモーフィズムの例>

例外処理

何かと倦厭されがちな「例外処理」ですが、上のポリモーフィズムの実装は単純なので例外処理がなくても問題ありませんが、これに対して、複雑な組み合わせを行った時、例外処理がないととても不便なのです。

==エラーの種類==

  1. 文法エラー
  2. 実行時エラー
  3. 論理エラー(仮にこう呼ぶ):処理の結果が想定通りでない。

そして、上のようなエラーがあったときにそれぞれの例外を投げます。これは、プログラムの文法で「Throw」という文言を使用するためです。日本語では「投げる」です。

例えば、例外の処理は以下の系統に分けることができます。

  • Error: 通常のアプリケーションであればキャッチすべきではない重大な問題
  • Exception: 通常のアプリケーションでキャッチされる可能性のある状態、クラスExceptionと、そのサブクラスのうちでRuntimeExceptionのサブクラスでないものがすべて、チェック例外になります。
  • RuntimeException: Java仮想マシンの通常の処理でスローすることができる各種の例外のスーパー・クラスです。

エラーがどこで起きたか分からない

稀に、例外が出てもエラーメッセージを見ない人がいますが、ちゃんと見ましょう。「どこでエラーが出ているのか?」はこの例外処理の結果を見ればわかるはずです。

そのように作れば良いのです。

File入出力

例外処理の代表的なものは「ファイル入出力」です。このファイル操作の処理を実装するときに必ず「IOException」が出てきます。ただし、ラップしているような処理は見えてきませんが。。。ちなみに「ラップする」というのは次のように処理をメソッドやクラスで包んでしまうことです。

<ラップしない場合>

/** ラップされるメソッド */
public void rap(String fileName) throws Exception {
    File file = new File(fileName);
    BufferedWriter writer = new BufferedWriter(new FileWriter(file));
    writer.write("aaa");
    writer.close();
}
/** 実行するメソッド */
public void execute() {
    try {
        rap("./test.txt");
    } catch (Exception e) {
        e.printStackTrace();
        System.exit(-1);
    }
}

<ラップする場合:rapped()がrap()をラップしている>

/** ラップされるメソッド */
public void rap(String fileName) throws Exception {
    File file = new File(fileName);
    BufferedWriter writer = new BufferedWriter(new FileWriter(file));
    writer.write("aaa");
    writer.close();
}
/** ラップするメソッド */
public void rapped(String fileName) {
    try {
        rap(fileName);
    } catch (Exception e) {
        e.printStackTrace();
        System.exit(-1);
    }
}

/** 実行するメソッド */
public void execute() {
    rapped();
}

rap()メソッドをラップすることで「try~catch」で囲まなくてもよくなりました。欠点としてはエラーハンドリングができなくなったことです。

File入出力(File IO)

そんなわけで、File入出力の実装をして見ましょう。

File出力(Writerで書き込み)

File入力(Readerで読込)

プロパティファイルを読む

<プロパティファイルを読み込む(全部)>※File入力の処理です。

ここの処理では、Readerを使用せず、Propertiesクラスの「load()」メソッドでファイルを読み込んでくれるのでこれを使用します。

プロパティファイルの読み込み

コード

private void loadProperties(String fileName) {
    Properties prop = new Properties();
    try {
        Path path = Paths.get("resources", fileName);

        if (isDebug) System.out.println("Path: " + path.getParent().toString() + "\\" + fileName);

        BufferedReader buf = Files.newBufferedReader(path);
        prop.load(buf);
    } catch (IOException ie) {
        System.out.println(fileName + "の読み込み時にエラーがありました。");
        ie.printStackTrace();
        System.exit(-1);
    }
    if (isDebug) System.out.println("propLength: " + prop.size());

    prop.keySet().stream().forEach(key-> {
        // key = 実行クラスの番号
        String className = prop.getProperty(key.toString());
        try {
            Class<CommandIF> klass = (Class<CommandIF>) Class.forName(className);
            clsMap.put(key.toString(), klass);
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    });

    if (clsMap.size() == 0) {
        System.out.println("プロパティファイルにクラスが登録されていません。");
        System.exit(-1);
    }
}

この処理で、プロパティファイルに書いてある、キーから完全クラス名を取得し、クラス・オブジェクトを取得、Mapインターフェースに登録しています。

細かく見ていきますので、ご安心ください

ファイルの読み込み

ファイルの読み込み処理の部分です。以下に抜粋します。

    Properties prop = new Properties();
    try {
        Path path = Paths.get("resources", fileName);

        if (isDebug) System.out.println("Path: " + path.getParent().toString() + "\\" + fileName);

        BufferedReader buf = Files.newBufferedReader(path);
        prop.load(buf);
    } catch (IOException ie) {
        System.out.println(fileName + "の読み込み時にエラーがありました。");
        ie.printStackTrace();
        System.exit(-1);
    }

この部分はfileNameに文字列で「ファイル名」が入っている想定です。

想定というのは、そのようにメソッドを使ってもらう前提ということです。

そして、上から順に、

Properties prop = new Properties();

ここで、プロパティクラスをインスタンス化しています。

Path path = Paths.get("resources", fileName);

この行では、resourceフォルダ内にある「fileName」のパスを取得しています。*ファイルがないときはnullが返ります。

下の処理はデバック用の処理です。取得したパスを文字列で表示しています。

if (isDebug) System.out.println("Path: " + path.getParent().toString() + "\\" + fileName);

そして、ファイルを読み込むためのクラスを取得(インスタンス化)します。

BufferedReader buf = Files.newBufferedReader(path);

最後に、Propetiesクラスで、取得したファイルリーダー(クラス)からプロパティファイルをロードします。

お気付きの方がいるかもしれませんが、ここで読み込もうとしているのは、プロパティファイルです。

ここまでが、処理の説明になります。

例外処理について

例外処理に関しては、try { ... } catch (例外クラス) { ... }で囲まれた、処理を書きます。

具体的には、このように書きます。

    try {
        Path path = Paths.get("resources", fileName);

        if (isDebug) System.out.println("Path: " + path.getParent().toString() + "\\" + fileName);

        BufferedReader buf = Files.newBufferedReader(path);
        prop.load(buf);
    } catch (IOException ie) {
        System.out.println(fileName + "の読み込み時にエラーがありました。");
        ie.printStackTrace();
        // プログラムの強制終了
        System.exit(-1);
    }

このように、ファイルを読み込もうとしたときに、例外が発生する可能性があるので、下のコードはThrows文が書かれています。
<使用している部分>

BufferedReader buf = Files.newBufferedReader(path);

<呼び出しているメソッドの定義>

BufferedReader java.nio.file.Files.newBufferedReader(Path path) throws IOException

なので、throwをキャッチする処理を書かなくてはなりません。

このように、例外が発生する可能性があるのであれば、「throws」文を使い例外が発生する可能性があることを呼び出した側のメソッドに通知する必要があります。

逆にメソッドの内部で揉み消してしまうならば、下のようにtry-catchで処理をしてしまえば良いのです。

    try {
        // 何かしらの処理
    } catch (IOException ie) {
        System.out.println("エラーがありました。");
        ie.printStackTrace();
        // プログラムの強制終了
        System.exit(-1);
    }

実際に作ってみる

まずは、サンプルコードを見てください。実行確認済みです。

public static void main(String[] args) {
    Path path = Paths.get("resources", "mains.properties");
    try {
        BufferedReader read = Files.newBufferedReader(path);
        String line = null;
        while((line = read.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException ie) {
        ie.printStackTrace();
        System.exit(-1);
    }
}

メインメソッドで、ファイル読み込みの処理を行ったものです。

<処理内容>

  1. resourceフォルダ(ビルドパスが通っている)にある「mains.properties」のパスを取得します。
  2. ファイル読み込みクラス、BufferedReaderを作成(インスタンス化)します。
  3. ファイルの内容を1行ずつ、読み込み、読み込み行がないならばnullが返ってくるので処理を終了します。
     ファイルの内容を標準出力に出力している

このような形で、例外処理を行いますが、これを別なkたちで使用することもあります。

チェック時の例外を投げる

<入力チェックの例外>
【前提】
・CheckerUtils#fixStr()は以下のように定義している

public static boolean fixStr(String str) throws Exception {
    if (str == null) {
        throw new Exception("strはnullにできません");
    }
    System.out.println(str);
}

<呼び出し元>

public static void main(String[] arg) {
    try {
        ChecherUtis.fixStr("aaaa");
    } catch (Exception e) {
        e.printStackTrace();
        Systme.exit(-1);
    }
}

このようにすると、例外に「strはnullにできません」と表示することができます。

さらに、Exceptionクラスを拡張して、下のように、自前の例外を作成することも可能です。

public class HeroExceptiion extends Exception {
    public HeroExceptiion(String message) {
        super(message);
    }
}

結局のところは、例外クラスの名前が変わるだけなのですが、この例外が出るところは決まってくるので。デバック時も問題になりません。

結構便利です。

今回はこんなところで。。。

でわでわ。。。

<<< 前回

継承に関するページ一覧

  1. Java オブジェクト指向基礎 ~オブジェクト指向コンセプト~
  2. UMLの書き方(読み方)〜概要とクラス図〜
  3. Java クラスの継承を理解する
  4. クラスの継承〜アクセス修飾子〜
  5. クラスの継承関係を作る1
  6. クラスの継承関係を作る2

環境構築関連ページ一覧

設計関連ページ一覧

  1. 設計を始める〜1.アプリイメージ〜
  2. 設計を始める〜2.機能イメージ〜
  3. 設計を始める〜3.機能概要〜
  4. Java はじめて16 〜クラス設計から実装〜

PHP関連ページ

  1. WordPress プラグイン作成〜DBを使用する〜
  2. PHP PDO 〜MySQLにアクセスする〜
  3. PHP Ajax 〜DBに登録したデータを受信する〜
  4. Google Maps API PHP連携 〜マップ情報をDBに登録する〜
  5. PHP Image File 〜iPhoneやAndroidでの画像送受信の問題〜
  6. AngularJS Routing 〜PHPをWeb APIにする〜
  7. WordPress PHPカスタム〜根本的に見た目を変える〜
  8. WordPress PHPカスタム〜根本的に見た目を変える2〜
  9. Eclipse PHPプラグイン 〜ElipseでWordPress環境を構築〜
  10. WordPress テスト実装 〜heade-test.phpを表示〜
  11. AngularJS + PHP 〜WordPressと連携する〜
  12. AngularJS + PHP 〜AngularJSの実装〜
  13. AngularJS + PHP 〜AngularJSの実装2〜
  14. WordPress 処理解析 ~index.phpを眺める~
  15. WordPress Plugin NewStatPress ~アクセス解析プラグインAPIを使う~
  16. WordPress 処理解析 ~ログイン処理を調べる~
  17. WordPressカスタム〜アンケートボタンを追加する(設計)〜
  18. WordPressカスタム〜プラグインの作成〜
  19. WordPressカスタム〜ダッシュボードのプラグイン画面作成〜
  20. WordPressカスタム〜ダッシュボードのプラグイン画面作成2〜
  21. WordPressカスタム〜ダッシュボードのプラグイン画面作成3〜
  22. WordPress プラグイン作成〜アンケート作成プラグインを作る〜

JS関連ページ

  1. JS GoogleMaps API 〜オリジナル・データマップを作ろう〜
  2. 吹き出しにYoubetubeを埋め込む
  3. Ajax + XmlHttpRequest〜画像送信からDB登録して表示〜
  4. JS XmlHttpRequest 〜JSでの同期/非同期通信〜
  5. JS Google Maps API 〜GeoLocation 現在位置の取得〜
  6. AngularJS + PHP 〜AngularJSの実装〜
  7. AngularJS + PHP 〜AngularJSの実装2〜
  8. WordPress プラグイン作成 〜$wpdbでのSELECT〜
  9. WordPressプラグイン作成 〜HTML挿入まで完了〜
  10. WordPress プラグイン作成 〜アンケート挿入〜
  11. MAMP 起動設定 〜WordPressのテスト環境を作る〜
  12. MAMP WordPress 〜インポート時のエラー対処〜
  13. WordPress PHPカスタム〜根本的に見た目を変える2〜

数理モデル関連ページ

  1. 数学への挑戦 第二弾〜数理モデルxプログラミング〜
  2. 数学への挑戦 第二弾〜実装編:数理モデルxプログラミング〜
  3. 数学への挑戦 第二弾〜集合を使う:数理モデルxプログラミング〜
  4. 数学への挑戦 第二弾〜確率変数:数理モデルxプログラミング〜
  5. 数学への挑戦 第二弾〜期待値と分散:数理モデルxプログラミング〜
  6. 数学への挑戦 第二弾〜卒業までに彼氏ができる確率:数理モデルxプログラミング〜
  7. 数学への挑戦 第二弾〜確率変数の足し算:数理モデルxプログラミング〜
  8. 数学への挑戦 第二弾〜まとめ1:数理モデルxプログラミング〜

Java Basic 実践学習編 〜変数の使用とデータ型、条件分岐、コードブロック〜

イントロダクション

前回は「Java Basic 実践学習編 〜ハローワールドから変数の宣言・初期化〜」を行いました。

今回は、表題の通りです。

変数の使用

前回も行いましたが、下のように、変数を宣言、初期化して使用します。

変数の宣言と初期化

<Code.09>

public class HelloWorld {
    public static void main(String[] args) {
        // 変数の宣言
        int seisu;
        // 変数の初期化
        double shosu = 0.0;
        // 変数の初期化
        String moji = "文字列";
    }
}
九九の二の段

<Code.10>

public static void main(String[] args) {
    int a = 2;
    int x = 1;
    System.out.println("2 x 1 = " + a * x);
    x++;
    System.out.println("2 x 2 = " + a * x);
    x++;
    System.out.println("2 x 3 = " + a * x);
    x++;
    System.out.println("2 x 4 = " + a * x);
    x++;
    System.out.println("2 x 5 = " + a * x);
    x++;
    System.out.println("2 x 6 = " + a * x);
    x++;
    System.out.println("2 x 7 = " + a * x);
    x++;
    System.out.println("2 x 8 = " + a * x);
    x++;
    System.out.println("2 x 9 = " + a * x);
}

上のコードは、九九の二の段を表示するプログラムです。ここでは変数xの値をインクリメントすることで、二の段の計算結果を表示しています。

変数の宣言と初期化を確認したところで次のコードに行きます。

コードブロック

一旦立ち止まって振り返ります。今まで動かしていた「メインメソッド」は下のように書きます。
この時に「{」から「}」までの間がメインメソッドの範囲、コードブロックになります。

<Code.11>

public static void main(String[] args) {
    // 何かしらの処理
}

これは決まっている部分ですので、そのまま覚えても問題ありません。と言うか自分は覚えました。

ポイント

「{}」は「中かっこ」、「波かっこ」など色々な言い方がありますが、「{}」の括弧で囲まれた部分が「ブロック」になります。
具体的には<Code.11>の「{」から「}」までの間が「(コード)ブロック」にあたります。

これは、スコープともいい「{」から「}」までの間だけ変数が機能します。
具体的には、下のように書くと変数「num」はエラーになると言うところです。

変数の有効範囲

<Code.12>

public static void main(String[] args) { // ここからメインメソッドのブロック
    int a = 0;
    if (a == 1) { // ここからIFのブロック
        int num = 0;
        num++;
    } else { // ここからelseのブロック
        num = 10; // ここでエラー
    }
}

「{」から「}」までの間が、変数のスコープ、機能する範囲なのでif() { ... }の中で宣言(初期化)された変数「num」はelse { ... }の範囲では機能しないのです。

詳細は以下のようになります。

  1. 1行目はメインメソッドの定義、メソッドの宣言
  2. 2行目でint型(整数型)の変数「a」の初期化
  3. if文で「aの値が1のときIFブロックに処理が進む」
  4. 同様に「if文の条件以外のばあいelseのブロックに進む」

この様に、メインメソッドのブロックの中に、ifのぶろっくとelseのブロックがあります。

そして、これを次のように書き換えるとエラーは出ません。

<Code.13>

public static void main(String[] args) {
    int a = 0;
    int num = 0;
    if (a == 1) {
        num++;
    } else {
        num = 10;
    }
}

変数「num」がメインメソッドのスコープ内で宣言されているので、その中にあるif() { ... }の中でもelse { ... }でも両方で機能することができます。

なので、次のようなコードでは、メソッドの中で宣言していてもエラーになります。別のメソッドだから、スコープの範囲が違うためです。

<Code.14>

public static void main(String[] args) {
    int a = 0;
    int num = 0;
    if (a == 1) {
        num++;
    } else {
        num = 10;
    }
}

/** メンバメソッド */
public void test1() {
    num; // ここでエラー
    System.out.println("test1");
    System.out.println("2 / 2 = " + 2 / 2);
}

ポイント

変数のスコープと言うのがありそれは「{」から「}」までの間がその範囲になります。
なので変数の宣言が、「{」から「}」までの間の外にあればそれはそれはエラーになります。

クラスとメソッドについて

今までプログラムを何個か作成してきましたが、Javaのプログラムを動かすための単位は「クラス」になります。
このクラスは下のように書き、フィールドとメソッドを持っています。

<Code.15>

public class HelloWorld {
    /** フィールド */
    private int field;

    /** メソッド */
    public void method(String hikisu) {
        int a = 0;
        int num = 0;
        if (a == 1) {
            num++;
        } else {
            num = 10;
        }
    }
}

このルールで、作成したクラスに「メインメソッド」を追加しているのです。今までに作成したものはメインメソッドのみでしたが。。。クラスとしては成り立つのです。ちょっと極端ですが、空クラスも、作成すればあります。

public class Kara {
}

Javaの実装ルールに違反していないのでOKなのです。まぁ作成する意味もないですが。。。

条件分岐

if文

次は、<Code.13>で出てきたif文に関して学習します。
俗にいう条件分岐です。これは、プログラムを実行するときに「~の場合の処理」と条件を付けて処理を分けたいときに使用します。具体的に以下のようなコードです。

<Code.16>

public static void main(String[] args) {
    int num = 10;
    if (num == 10) {
        System.out.println("No10");
    } else {
        System.out.println("Not No10");
    }
}

int型(整数型)の変数numが10の時「No10」とコンソールに表示します。それ以外の時は「Not No10」と表示します。
この場合は、プログラムを書き換えて変数numの値を変更してやる必要があります。

なので、プログラム引数を使用してプログラムを書き換えなくてもよいように修正します。

プログラム引数

プログラム引数は、Javaプログラムを実行するときに渡せる引数のことで、引数はString型の値になります。
ただし、文字列を複数渡すことができるのでString[](String型の配列)になっています。

具体的には下のように使用します。

コードとしては、動画のものと違いますが、下のように使います。

public static void main(String[] args) {
    // プログラム引数を取得する
    int num = Integer.parseInt(args[0]);
    if (num == 10) {
        System.out.println("No10");
    } else {
        System.out.println("Not No10");
    }
}

しかし、このコードでは、プログラム引数が渡されてないい場合はエラーになります。

なので次のように書き換えます。
<Code.17>

public static void main(String[] args) {
    // プログラム引数を取得する
    int num;
    if (args[0] != null && args[0].matches("[0-9]{1}")) {
        num = Integer.parseInt(args[0]);
    } else {
        num = 10;
    }

    if (num == 10) {
        System.out.println("No10");
    } else {
        System.out.println("Not No10");
    }
}

このように、想定外の入力があったときを考慮してプログラムを作成するとエラーが出ない、安全なプログラムができます。リアルでもプログラムでも安全第一です

処理の内容に関して
初めの

if (args[0] != null && args[0].matches("[0-9]{1}")) {

を分解して説明します。
if文に関しては後に説明しますが、

args[0].matches("[0-9]{1}") {

の部分に関して
この部分はString型のメソッドを使用しています。実はString型はJavaAPIで定義されているクラスなのです。
String[]はString型の配列ですので、配列の中身はString型の変数です、

String[0]

String[] hako = {"もじ", "123", "aaa"};

と初期化したときの「"もじ"」に当たります。
つまり

String[0] => "もじ", String[1] => "123", String[2] => "aaa"

となります。

なので、Stringクラスのメソッド「matches」を使用することができます。

このメソッドの処理は引数に「正規表現」を渡し返り値に正規表現にマッチするかどうか?を返す処理になります。

具体的には下のようになります。
<Code.18>

public static void main(String[] args) {
    String aa = "12345";
    boolean isNumber = aa.matches("[0-9]{1,}");
    System.out.println("入力値: " + aa + "は、正規表現「[0-9]{1,}」にマッチするか?: " + isNumber);

    boolean isAtoZ = aa.matches("[A-Z]{1,}");
    System.out.println("入力値: " + aa + "は、正規表現「[0-9]{1,}」にマッチするか?: " + isAtoZ);
}

実行結果は以下の通りです。

条件分岐本題

if文になれてきたところで、プログラムを理解していきましょう。

<Code.13>を見てください。初めのif文で変数aaの値が10の時...と処理が書いてあります。

public static void main(String[] args) {
    int num = 10;
    if (num == 10) {
        System.out.println("No10");
    } else {
        System.out.println("Not No10");
    }
}

ここでのnum == 10の部分が論理式になります。論理式とは返却値に真偽値(trueもしくはfalse)を返します。
コードで書くと下のようになります。

boolean is10 = num == 10;

何度も記載しますが、booleanは真偽値のデータ型です。true, falseどちらかの値しか持ちません。
なので、変数「num」が10の場合は、true, そうでない場合はflaseが変数「is10」に代入されます。

ちょっと座学臭い感じですが、「=」演算子は式の値を代入します。
初めの方に実装しましたが、変数の初期化を行った時には「=」で宣言と同時に値を代入します。

int num = 10;

同様に、初期化でなくても値は代入する事ができます。

num = 9;

下のように、プログラムを書いたときは変数「num」の値が変わって聞きます。そして、プログラムは必ず上から下に流れます。
<Code.19>

public static void main(String[] args) {
    int num = 10;
    if (num == 10) {
        num = 20;
    } else {
        num = 3;
    }
    if (num == 20) {
        System.out.println("Hello");
    } else {
        System.out.println("Bye");
    }
}

このコードは、「Hello」が表示されます。以下のように処理が進みます。

  1. int型の変数numを10で初期化
  2. もしnumが10であれば、numに20を代入
    3.それ以外ならnumに3を代入
  3. もしnumが20であれば、「Hello」を表示
  4. それ以外なら「Bye」を標示

条件分岐のバリエーション

if-elseを理解できたと思います。これに追加してelse-ifがあります。具体的には下のように書きます。
<Code.20>

public static void main(String[] args) {
    int num = 10;
    if (num == 10) {
        num = 20;
    } else if (num == 20){
        num = 3;
    } else {
        num = 2;
    }
    if (num == 20) {
        System.out.println("Hello");
    } else if (num == 3) {
        System.out.println("Else if");
    } else {
        System.out.println("Bye");
    }
}

今までの条件に「そのほかに、もしnumが20の時」という文言が加わりました。
作り方はif文の時と同じです。

文章をつなげると「もじnumが10ならば~その他にもし、numが20ならば~、それ以外なら~」というような文章、プログラムができました。

switch文

switch文はif文と同じです。ただ書き方が違います。
if文は以下のように書きます。

if (論理式A) {
    // 論理式Aがtrueときの処理
} else if (論理式B) {
    // 論理式Bがtrueときの処理
} else {
    // 何かしらの処理
}

switch文は以下の通りです。

switch (変数) {
case XX:
    // 変数がXの時のケース
    break;
case YY:
    // 変数がYの時のケース
    break;
default:
    // 変数が上記以外のとき
}

<Code.20>をswitch文に書き換えると下のようになります。

public static void main(String[] args) {
    int num = 10;
    switch (num) {
    case 10:
        System.out.println("No8");
        break;
    case 20:
        System.out.println("No9");
        break;
    default:
        System.out.println("それ以外");
    }
}
ポイント

このプログラムの

break;

に注目して下さい。この分がないとどうなるでしょうか?
<Code.21>

switch (num) {
case 8:
    System.out.println("No8");
case 9:
    System.out.println("No9");
default:
    System.out.println("それ以外");
}
if (num == 0) {
    break;
}

出力結果はいかのようになりました。入力値は「8」です。

8
No8
No9
それ以外

入力値が「9」の場合は

9
No9
それ以外

同様に上記以外の入力、「5」を入力しました。

5
それ以外

つまるところは、breakがないとそれ以降の処理がすべて動いてしまうということです。

ループ文

while文

やって来ました。ループ文です。ここまで来た方おめでとうおございます。
プログラミングで遊ぶ材料がそろいました。

まずは下のループ文を見てください。

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);

    while(true) {
        int num = scan.nextInt();

        switch (num) {
        case 8:
            System.out.println("No8");
            break;
        case 9:
            System.out.println("No9");
            break;
        default:
            System.out.println("それ以外");
        }
    }
}
while(true) { ... }

これは無限ループのプログラムの型です。
「{}」の間(スコープ)を無限ループします。

このままだとプログラムが終了しません。

では、どのようにプログラムを終了するか?

特定の入力があった場合にプログラムを終了するようにプログラムを作ります。

今回利用しているJavaAPIは、java.util.Scannerです。
そして、使用しているメソッドはnextInt()です。

終了するための処理は下のコードです。

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);

    while(true) {
        int num = scan.nextInt();

        switch (num) {
        case 8:
            System.out.println("No8");
            break;
        case 9:
            System.out.println("No9");
            break;
        default:
            System.out.println("それ以外");
        }
        if (num == 0) {
            break;
        }
    }
}

上のコードを説明すると。。。

  1. Scanner scan = new Scanner(System.in);で標準入力の受付クラスをインスタンス化
    標準入力を受け付けられるようにします。
  2. while(true) {で無限ループを開始します。
  3. int num = scan.nextInt();で標準入力を待ち受けます。
  4. あとはswitch文で受け取った値の判定をしてそれぞれの処理を行います。
  5. if (num == 0) {入力値を代入した変数「num」が0の場合「{}」内の処理を行います。
  6. break;無限ループを抜けます。

for文

この無限ループは、ゲームを作成するときの基本的なプログラムになります。
そして、今回は回数制限のある「おみくじゲーム」を作成します。

占い回数を入力して、今日の運勢を%で算出します。

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);

    System.out.println("今日の運勢を占います。占う回数を入力してください。");
    int num = 0;
    while(true) {
        num = scan.nextInt();
        if (num > 3) {
            System.out.println("3以下の値を入力してください");
            continue;
        }
        break;
    }
    System.out.println(num + "回占います。");

    int sisu = 0;
    for (int i = 0; i < num; i++) {
        int unsei = new Random().nextInt(3);
        if (unsei == 0) {
            System.out.println((i + 1) + "回目: 大吉");
            sisu += 4;
        } else if (unsei == 1) {
            System.out.println((i + 1) + "回目: 中吉");
            sisu += 3;
        } else if (unsei == 2) {
            System.out.println((i + 1) + "回目: 吉");
            sisu += 2;
        } else {
            System.out.println((i + 1) + "回目: 凶");
            sisu += 1;
        }
    }
    System.out.println("sisu: " + sisu);
    int un = new BigDecimal(sisu).divide(new BigDecimal(num * 4), 2, RoundingMode.DOWN).multiply(new BigDecimal(100)).intValue();
    System.out.println("un: " + un);
    System.out.println("今日の運勢は、" + un + "%好調です。");
}

これを改造するもよし、アイディアを出して別のものにするもよし、
遊んでみてください。

ポイント

今回使用したループ文はfor文といって下のように書きます。

for (カウンタの初期化; ループする論理式; ループした後の処理) {
    // 何かしらの処理
}

これは、どのような意味かというとfor int i = 0; i < 10; i++) { .. }<code>とコードを書いたときの場合は、int(整数)型の変数を0で初期化(</code>int i = 0<code>)して、この変数が10よりも小さい(i < 10)間、ループするたびにあとの処理(</code>i++)を行います。

ループ文の練習です、下のような問題があります。

問題1「4回ループするfor文を作ってください」

<for文の場合>

for (int i = 0; i < 5; i++) {
    System.out.pprintln("Hello" + i);
}

処理の順序は下のようになります。

  1. int型(整数型)の変数iを0で初期化
  2. i = 0なので論理式「i < 5」の評価後の値は「0 < 5」でtrue
  3. 論理式の値がtrueなので「{}」の中の処理を行う
  4. 「Hello0」を表示した後に
    i++

    の処理を行う

  5. iが1になったので、論理式
    i < 5

    の評価の値は「1 < 5」でtrue

  6. 「Hello1」を表示した後に
    i++

    の処理を行う

  7. iが2になったので、論理式
    i < 5

    の評価の値は「2 < 5」でtrue

  8. 「Hello2」を表示した後に
    i++

    の処理を行う

  9. iが3になったので、論理式
    i < 5

    の評価の値は「3 < 5」でtrue

  10. 「Hello3」を表示した後に
    i++

    の処理を行う

  11. iが4になったので、論理式
    i < 5

    の評価の値は「4 < 5」でtrue

  12. 「Hello4」を表示した後に
    i++

    の処理を行う

  13. iが5になったので、論理式
    i < 5

    の評価の値は「5 < 5」でfalse

  14. 論理式の値がfalseになったのでループを終了する

<while文の場合>

int i = 0;
while(i < 5) {
    System.out.println("Hello" + i);
    i++;
}
  1. int型(整数型)の変数iを0で初期化
  2. i = 0なので論理式「i < 5」の評価後の値は「0 < 5」でtrue
  3. 論理式の値がtrueなので「{}」の中の処理を行う
  4. 「Hello0」を表示した後に
    i++

    の処理を行う

  5. iが1になったので、論理式
    i < 5

    の評価の値は「1 < 5」でtrue

  6. 「Hello1」を表示した後に
    i++

    の処理を行う

  7. iが2になったので、論理式
    i < 5

    の評価の値は「2 < 5」でtrue

  8. 「Hello2」を表示した後に
    i++

    の処理を行う

  9. iが3になったので、論理式
    i < 5

    の評価の値は「3 < 5」でtrue

  10. 「Hello3」を表示した後に
    i++

    の処理を行う

  11. iが4になったので、論理式
    i < 5

    の評価の値は「4 < 5」でtrue

  12. 「Hello4」を表示した後に
    i++

    の処理を行う

  13. iが5になったので、論理式
    i < 5

    の評価の値は「5 < 5」でfalse

  14. 論理式の値がfalseになったのでループを終了する

こんな風に作成します。

今までに学習してきたことは大まかに下のようなことです。

  • リテラルの理解
  • 変数・データ型の理解
  • 条件分岐の理解
  • ループ文、繰り返し処理の理解

これらの処理、文法がプログラミングの基本になります。この基本は「初めの一歩」にして「奥義」たりえます。
基本を極めればどんなプログラムでも対応する事ができます。

そして、楽しく学習するのが一番学習効果が高いので「楽しく」プログラミングできるように想像力を働かせましょう。

具体的には「~出来たら面白そうだ」などと考えてみましょう。もしかしたらものすごい発見があるかもしれません。

でわでわ。。。

<<<前回

Java Basic 実践学習編1 〜ハローワールドから変数の宣言・初期化〜

Javaの実践学習

今までに、色々と学習してきましたが、効率と理解度を考慮に入れるとズバリ下のような学習方法が一番だと思いました。

  1. コードを書く
  2. コードを動かす
  3. コードを書き換えて動かしてみる
  4. コードを理解する

この順序でいろんな書き方、プログラムの組み方を理解していくのが最もわかり易く、実践で使えると思いました。

この手順を使用してJavaの基本をやり直したいと思います。

初めてのJava

以前書いた記事はこちらです。

Lv1.ハローワールド

初めてのプログラムとして有名なものですが、これはJava言語に限ったことではありません。C言語、Python, C#, java script etc ...でも同じことです。
プログラムを起動して、「Hello World」と表示するだけのプログラムです。

このプログラムは、大きなアプリケーションに新たに取り組む、もしくはフレームワークを使用するなどの時に「プログラムが動くよね?」という確認のために使用することが多いです。

そして、自分はJava屋なので、Java言語で実装を行います。

下のコードは、「Hello クラス」を作成し、そこにメインメソッドを作成しました。とりあえずこれを書き写して動かしてみましょう

<Code.01>

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

Eclipse(開発ツール(IDE))での実行した時の動画は以下になります。

シンプルに、コンソール(標準出力)への文字列出力になります。

ポイント1

プログラムが動くことを確認するというところです。

Lv2.適当な文字の出力

上のコードを書き換えて、出力内容を変更します。

<Code.02>

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("I am Takunoji. It's verry hard.");
    }
}

出力した文言の言っていることは、意味がわかりませんが、とりあえずは、出力内容が変わります。

コードの実行確認は、読者の皆さんが行ってください。
※コピペしないほうが、理解も早いです。

ポイント2

"(ダブルクォーテーション)で囲った部分が文字列としてJVM(Javaを起動する機械、java.exeのこと)に、認識されます。
まとめると下のようなイメージになります。

System.out.println(「文字列」);

この「文字列」の部分を引数と呼びます。<Code.02>のコードを説明すると
printlnメソッドの引数に文字列「I am Takunoji. It's verry hard.」を渡している」と説明できます。

よくあるミス

下のコードはエラーになります。

<Code.03>

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("I am Takunoji. It's verry hard.);
    }
}

すぐに気がつく人は気がつくのですが、気がつかない人はなかなか気がつきません。
自分がそうです。苦労しました、今でも、汚いコードとかにある、このような「小さなミス」を見つけるのに一苦労します。

コードは綺麗に書きましょう

一言で言うと自分があとで苦労します。。。

余談:綺麗なコードとは

単純に、以下の部分がポイントです。

  1. インデントが揃っている
  2. 余計な変数宣言がない
  3. 同じ名前の変数を別の用途に使いまわさない
  4. 処理が整理されていて、どの処理がどこにあるのかわかるようになっている

大まかに上のようなコードです。詳細に関しては、今後理解して行けば良いと思います。とりあえず書いて動かしてみましょう。

Lv3.計算をしてみる

単純な足し算と引き算をコンソールに出力します。

<Code.04>

public class HelloWorld {
    public static void main(String[] args) {
        // 足し算
        System.out.println("1 + 1 = " + (1 + 1));
        // ひき算
        System.out.println("1 - 1 = " + (1 - 1));
    }
}

上のコードは、文字列「1 + 1 = 」に「1 + 1」の計算結果を文字列として連結して、出力しています。
次の行では、同様に、文字列「1 - 1 = 」に「1 - 1」の計算結果を文字列として連結して、出力しています。

ポイント3

ポイント2でも説明しましたが、System.out.println("1 + 1 = " + (1 + 1));<code>の</code>"1 + 1 = " + (1 + 1)の部分が引数になります。
この引数は"1 + 1 = "<code>が文字列を示し、</code>(1 + 1)が計算処理でその結果は2になります。
最後に、"1 + 1 = " + (1 + 1)にある真ん中の「+」が文字列の連結処理を行っているところです。

文字列の隣に来る「+」は文字連結を示します。

では、次のコードを見て見ましょう、掛け算と割り算です。

<Code.05>

public class HelloWorld {
    public static void main(String[] args) {
        // かけ算
        System.out.println("2 * 2 = " + 2 * 2);
        // わり算
        System.out.println("2 / 2 = " + 2 / 2);
    }
}

ポイント4

このコードは、掛け算と割り算を行なっています。しかし、<Code.04>と比べてみるとかっこが足りません。
具体的に"1 + 1 = " + (1 + 1)<code>と</code>"2 * 2 = " + 2 * 2の部分です。

この部分は暗黙的なルールがあり、中学生くらいに習ったと思いますが、「足し算と掛け算」があったら「掛け算」の方を先に計算すると言うルールがあったと思います。

プログラムでも同じなんです。

つまるところは以下のような理由で、上のような違いがあります。

<足し算と引き算の場合>

public static void main(String[] args) {
    // 足し算
    System.out.println("1 + 1 = " + (1 + 1));
    // ひき算
    System.out.println("1 - 1 = " + (1 - 1));
}

足し算と引き算の場合は、()かっこが必要です。それは「文字を連結する」と言う処理と、「計算をする」と言う処理にしようする演算子(「+」のこと)が同じなため

"1 + 1 = " + 1 + 1

のように書くと文字連結か、計算するかJavaコンパイラが判別できないためエラーになります。

<掛け算と割り算の場合>

public static void main(String[] args) {
    // かけ算
    System.out.println("2 * 2 = " + 2 * 2);
    // わり算
    System.out.println("2 / 2 = " + 2 / 2);
}

見た目にも、「+」と「*」で演算子が違うので「文字列の連結」と「計算」の区別がつきます。なのでかっこがなくてもビルドエラーになりません。

ついでにもう1つサンプルコード
<Code.06>

public class HelloWorld {
    public static void main(String[] args) {
        // かけ算と割り算
        System.out.println("2 * 2 = " + 2 * 2 / 2);
    }
}

この場合はどうのような処理結果が出るでしょうか?それは実行して見てからのお楽しみ。

変数を使う

プログラミングを行なっていると「変数」と言う言葉が出てきます。
プログラミングは、中学校くらいに習った(習う)数学と似たところがあります。

演算子 意味 サンプルコード
+ 足し算、文字列の連結 1 + 1, "文字" + "1"
- 引き算 1 - 1
* かけ算 1 * 1
/ わり算 1 / 1
% 剰余算 1 % 1
剰余算について

<Code.07>

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
        System.out.println("3 % 2 = " + 3 % 2);
    }
}

上のように割った後の余りを算出します。「3 / 2 = 1 あまり1」と言うふうになります。なので「3 % 2」の計算結果は「1」になります。

実際に使用するときは「変数Xが偶数か奇数か?」と調べるときに、下のような形で使用します。

<Code.08>

public class HelloWorld {
    public static void main(String[] args) {
        int X = 32;
        boolean isKisu =  X % 2 == 1;
    }
}

このときに変数Xを2で割った時の余りが1になる数は「奇数」です。逆に「0」になるものは偶数です。

このような「法則のようなもの?」を見つけてそれをプログラムに落とし込むと言うところもプログラミングの面白いところです。

変数を学ぶ

プリミティブ型の変数としては以下のようなものがあります。

[プリミティブ型]と呼ばれるデータ型の種類

データ型          読み      用途
byte            バイト        8ビットの整数(-127から127) を示すが実際はファイル入出力時にこのデータ型で扱うことが多い
int               イント        整数として使用する(四則計算など)、整数の計算で使用する事が多い
long              ロング      intよりも大きい数値を使用する時に使用する、日付計算などで使用する事が多い。
double          ダブル        小数点をつける数値として使用する
float            フロート    あまり使わない
char           キャラ          一文字を示す、またintでも扱うことができる 'a'(シングルクォーテーション使用)
boolean        ブーリアン 真(true)か偽(false)を示す、intではtrue=1, false=0

これは全てではないですが、大まかに変数の一覧になっています。

そして、よく使用するのが、以下の4つです。

  1. int型: 整数用の変数
  2. double型: 少数用の変数
  3. boolean型: 真偽値
  4. String型:文字列として使用する

今までにも使用しているコードですが、改めて眺めて見ましょう

<Code.09>

public class HelloWorld {
    public static void main(String[] args) {
        // 変数の宣言
        int seisu;
        // 変数の初期化
        double shosu = 0.0;
        // 変数の初期化
        String moji = "文字列";
    }
}

変数の宣言は値を代入しません。

int seisu;

、そして、初期化は値を代入します

int double shosu = 0.0;

上記ひと通りの内容を説明した動画が、以下になります。

四則計算の実装

次は、四則計算をプログラムで行います。上記の計算でも行いましたが、今回は変数を使用して実行します。

九九(2の段)を算出、表示する

サンプルコードは以下になります。

ポイント5

<Code.10>

public static void main(String[] args) {
    int a = 2;
    int x = 1;
    System.out.println("2 x 1 = " + a * x);
    x++;
    System.out.println("2 x 2 = " + a * x);
    x++;
    System.out.println("2 x 3 = " + a * x);
    x++;
    System.out.println("2 x 4 = " + a * x);
    x++;
    System.out.println("2 x 5 = " + a * x);
    x++;
    System.out.println("2 x 6 = " + a * x);
    x++;
    System.out.println("2 x 7 = " + a * x);
    x++;
    System.out.println("2 x 8 = " + a * x);
    x++;
    System.out.println("2 x 9 = " + a * x);
}

表示結果は以下になります。

ポイント

変数「a」と「x」を初期化して、掛け算した結果を表示しています。そして表示処理

System.out.println("XXXX");

)の間にある

x++;

の処理は「インクリメント」と言って変数の値に「プラス1」します。
なので、これは2の段を表示できているのです。

今回は、ここまでです。次は、変数を使用して、簡単なプログラムを作成します。

Java Basic API ~Java 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の理解を深めることができます。

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

ちなみに、YoutubeにアップしたJUnit関連の動画はこちらのURLで一覧になっています。再生リストというやつです。

でわでわ。。。

関連ページ一覧

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〜