Java Basic ミニゲーム作成 〜Step3_2〜

イントロダクション

前回は、説明が不十分な感じでした。
とりあえずで"bye"と入力すると終了するコンソールアプリを作成しました。
今回は、タイトル表示までやりました。
ただし、クラス単体では動きません。。。

使用するクラス

必要なクラスは以下になります。

RpgMain
ViewStatus
TitleView

RPGMainクラス

RPGMainでゲームの処理をstaticで作成しています。つまりは、メインメソッドから直接呼び出せる形で実装しています。
※RpgMain#view()メソッドは使っておりません。今後の実装を考えて作っておりますので今後修正する可能性が大きいです。

<実行動画>

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

処理内容:メインメソッド

  1. 初期化 #init
    • RpgMainクラスを生成(new)して
    • メンバメソッドinitialize()で初期画面の標準入力を受け付ける
    • ファイルの読み込み&出力 ※ラムダ式を使用してみました
    • 初めの画面管理オブジェクト生成
/**
 * このゲームでは初期化は必ず1回なのでstaticをつける</br>
 * static -> 静的メソッド=> クラス内にあるがJVMから直で参照される
 * ※JVM => Java Virtual Machine
 */
private static void init() {
    // mainメソッドと同様にクラスをnewする必要あり
    game = new RpgMain();
}
  1. ゲームループ #gameLoop
    • 無限ループ開始
    • コマンド実行処理(Mainクラス) ※画面管理オブジェクトのexecuteを実行
    • 更新後の画面を表示
/**
 * この処理もinit()と同様に必ず1回なのでstaticをつける</br>
 */
private static void gameLoop() throws IOException{
    /*
     *  <ゲームループ> 
     *  1.入力
     *  2.データ更新、
     *  3.レンダリング(今回はコマンドなので文字出力)
     *  4.「bye」コマンドでゲームを終了する
     */
    while(true) {
        // 1. 入力を受け取る
        String command = game.listenInput();
        // command変数がnullになる可能性があるため定数.equals()の形にする
        if(TERMINATE_GAME.equals(command)) {
            break;
        }
        // 2-1.処理を実行する(タイトル、その他初期表示する
        status = game.execute(command);
    }
}
  1. 終了処理 #terminated
    • リソース(クラス)のメモリ解放
/**
 * ゲームのリソースを解放する
 */
public static void terminated() {
    // クラスの解放を行う
    game = null;
    System.out.println("This game terminated!, See you next time!!");
}

「static」をつけているのは、Mainメソッドから
直接呼ぶ様にしたかったからです。→メインメソッドとクラスのメンバメソッドを分けると見やすいと思ったため。

ViewStatusクラス

このクラスは、抽象クラスで、今後作成していく表示する画面を実行するためのクラスです。大まかに今回の実装のかなめになるクラスです。
ViewCommandはインターフェースですが、インナークラスとして実装しています。
※正しくは、インターフェース・クラス

このクラスの使い方としては、各画面クラス(TitleViewクラスなど)で以下のメソッドをオーバーライドしてやれば、コマンドに対応した処理を実行する
というような実装を行いました。

/** 画面の表示処理 */
public abstract void views();
/** 使用するコマンド */
public abstract Optional<Map<String, ViewCommand>> createCommands();
/** ViewStatusをセットする */
public abstract void setViewStatus(ViewStatus status);
/**
 * 画面のステータスクラスを示す。<BR>
 * コマンドの実行は内部インターフェースViewCommand<BR>
 * の実装クラスが行う<BR>
 * 【使い方】
 * 1. このクラスを継承して全ての抽象メソッドを実装します。
 * 2. コンストラクタでcreateViewStr()を呼び出して画面(文字列)を
 *    デザインしたファイルを指定してください読み込んで表示します。
 * 
 * @author takunoji
 */
public abstract class ViewStatus {
    /** 自クラスを保持する */
    protected ViewStatus status;
    /** コマンド管理 */
    protected Map<String, ViewCommand> commands;
    /** 表示する画面(文字列) */
    protected List<String> viewStrList; 

    /**
     * インナークラスのインターフェース
     * @author takunoji
     */
    public interface ViewCommand {
        /** コマンドの実行
         * Nullが返却されるときは画面の遷移なし 
         */
        public abstract ViewStatus execute();
    }

    /**
     * コンストラクタ<BR>
     * 使用するコマンドをMapに設定する
     */
    public ViewStatus() {
        Optional<Map<String, ViewCommand>> optCommands = createCommands();
        // 取得した結果がNullの場合はからのMapを返す
        commands =  optCommands.isPresent() ? optCommands.get() : new HashMap<String, ViewCommand>();
    }

    /**
     * コマンド実行処理<BR>
     * RpgMainクラスで標準入力を受けてコマンドマップに<BR>
     * 登録されているViewCommandのexecuteを実行する<BR>
     * Mapに登録されていない時は何も実行しない
     * @param input
     * @return
     */
    public ViewStatus execute(String input) {
        Optional<ViewCommand> command = Optional.ofNullable(commands.get(input));
        // commandがからの場合は何もしない
        command.ifPresent(cmd -> setViewStatus(cmd.execute()));
        return this;
    }

    /**
     * ファイルを読み込み画面を描画する(文字列)
     * @param filePath
     */
    protected void createViewStr(String filePath) {
        Path path = Paths.get(filePath);
        List<String> lines = null;
        try {
            lines = Files.readAllLines(path);
        } catch (IOException e) {
            e.printStackTrace();
        }
        lines.stream().forEach(System.out::println);
        // viewの文字列を保存します
        this.setViewStr(lines);
    }

    /** 作成、ファイルから読み込んだView文字を保存する */
    public void setViewStr(List<String> viewStrList) {
        this.viewStrList = viewStrList;
    }
    /** 作成、ファイルから読み込んだView文字を取得する */
    public List<String> getViewStr() {
        return this.viewStrList;
    }

    /** 画面の表示処理 */
    public abstract void views();
    /** 使用するコマンド */
    public abstract Optional<Map<String, ViewCommand>> createCommands();
    /** ViewStatusをセットする */
    public abstract void setViewStatus(ViewStatus status);
}

TitleViewクラスについて

そして、初めの画面管理オブジェクトのTitleViewは「ViewStatus」という抽象クラスを実装しています。
抽象クラスについてはのちに説明いたしますが、インターフェースとクラスの中間にいるクラスです。

具体的に、抽象メソッドと実装するメソッド両方を持っております。
インターフェースと違いimplemensではなく「extends」(継承)する必要があります。
さらにちょっと厄介なインナークラスにインターフェースを作成しています。

ViewStatus以外で、使用することのないインターフェースなのでそうしたのですが、普通は外部に作成します。
クラスが増えない様に、インナークラスにしたのですがやっぱり微妙でした、なんかのタイミングで修正しようと思います。

インポートするときはxxxxViewStatus.ViewCommandの様にやります。

まとめ

以下のクラスを使用しました。それぞれの役目を割り当てています。

  • RpgMain: ゲームを動かす。メインメソッドを起動するためのクラス。
  • ViewStatus: 抽象クラス、このクラスを継承したクラスはすべて、画面状態を示すクラスとして使用する。
  • TitleView: タイトルを表示するステータス(状態)を表現するクラス。

ここまでで、とりあえずは実装をどんどん拡張する準備が整った形です。
具体的には、「ViewStaus」クラスを継承して新しいクラスを作成するということです。

現状では、TitleViewクラスのみですが、これを増やしていけば一つのアプリが作れるかもしれません。

とりあえず、今回はここまでにします。でわでわ。。。

次回は、ミニゲーム作成-〜コンソールゲーム〜/

です。

関連ページ

前回

http://zenryokuservice.com/wp/2018/05/20/java-basic-ミニゲーム作成-〜コンソールゲーム〜/

インターフェースについて

http://zenryokuservice.com/wp/2018/06/01/java-basic-インターフェース・抽象クラスの作り方/

ページ一覧

http://zenryokuservice.com/wp/2018/09/29/mapping-of-java-bassic~java-basicの記事一覧~/

Java Basic ミニゲーム作成 〜Step3_1〜

イントロダクション

はじめにコンソール画面を使用してミニゲームを作成しようと思っています。
標準入力(コンソール画面に入力する)を使用して行いますので、参考までに標準入力のサンプルを載せておきます。

標準入力の動き

最終的に作成したもの

本文

  • ミニゲームの作成を行います。
    処理の概要としては、以下の通りです。( version0.1)
=====補足==========
<基本設計レベル>
[詳細設計レベル]
==================

<初期処理>
画面状態管理Obj
リソースの読み込み
[テキストで表示する絵を読み込み変数に保存]→テキストファイル

[新規で追加するファイルも読み込める様に工夫する]

<選択→決定処理>
ゲームタイトル画面の「スタート」「コンテニュー」の選択をする

以下の様に表示する

START:S
CONTINUE: C
<イントロダクションの表示処理> イントロダクションのテキストファイルを読み込み ストーリーの序章を表示して、ゲームを開始できる様な文章を表示する

この仕様で実装します。

  1. 画面状態管理Objの作成

    • シンプルにMap型のフィールド変数を作成します。
  2. リソースの読み込み、単純にテキストファイルの読み込みです。

※今後はプロパティファイルなど読み込む予定です。(XMLもやるかも?)リメイクの方(Github)で使用しています。

※未実装です

  1. これもテキストファイルを読み込みゲームの序章を表示します。

今回は、ここまでを実装します。

土台にするのは以前の実装です。
クラス名はブログの都合上変えてあります。
そして「画面状態」は今回初登場の「Map」インターフェースを使用して管理します。

<<元にするソースについて>>

ゲームの基本的な処理フロー

初期化→ゲームループ→終了

上記のメソッドを実装してあります。

まとめると

  1. ゲームの起動準備「init();」
  2. 入力→画面の更新をループする「gameLoop()」
  3. ゲームの終了「terminated()」

上記の3つの処理の中で、ゲームを進行させていくと言うことです。が実装してみないとイメージがわかないと思います。※イメージが湧く人は頭のいい人です。筆者は試行錯誤済みです。

そして、「3つの処理」というのは「」の中に書いてある各メソッドのことを指します。

  • init()
  • gameLoop()
  • terminated()

それぞれの処理は以下のようになります。
<init: 初期処理>

/**
* このゲームでは初期化は必ず1回なのでstaticをつける</br>
* static -> 静的メソッド=> クラス内にあるがJVMから直で参照される
* ※JVM => Java Virtual Machine
*/
private static void init() {
    // mainメソッドと同様にクラスをnewする必要あり
    game = new RpgMain();
}

ここで実行しているのはコンストラクタになります。

/**
* ぶっちゃけてここで初期化(init)処理をやっても良い</br>
* 最終的にプログラムの設計者の判断に委ねられる</br>
*/
public RpgMain() {
    // メンバメソッドなのでコンストラクタで呼び出す
    initialize();
}

そして、inittialize()メソッドを実行しています。フィールド変数にTitleViewクラスを代入(セット)しています、

/**
* 入力、出力のためのオブジェクトを生成</br>
* RpgMainクラスが存在しないならば使用できない様にするので</br>
* このメソッドはメンバメソッドにしてある</br>
*/
public void initialize() {
    // 入力受付クラス
    read = new BufferedReader(new InputStreamReader(System.in));
    // *** titleの表示 *** //
    // ViewStats生成
    status = new TitleView();
}

<gameLoop: 初期処理>

/**
 * この処理もinit()と同様に必ず1回なのでstaticをつける</br>
 */
private static void gameLoop() throws IOException{

    /*
    *  <ゲームループ> 
    *  1.入力
    *  2.データ更新、
    *  3.レンダリング(今回はコマンドなので文字出力)
    *  4.「bye」コマンドでゲームを終了する
    */
    while(true) {
    // 1. 入力を受け取る
    String command = game.listenInput();
    // command変数がnullになる可能性があるため定数.equals()の形にする
        if(TERMINATE_GAME.equals(command)) {
            break;
        }
        // 2-1.処理を実行する(タイトル、その他初期表示する
        status = game.execute(command);
    }
}

ここでは、「String command = game.listenInput();」で標準入力を受け取っています。
そして受けた文字列から実行するコマンドを実行して処理後にTitleViewクラスを受け取っています。

<terminated: 終了処理>

/**
* ゲームのリソースを解放する
*/
public static void terminated() {
    // クラスの解放を行う
    game = null;
    System.out.println("This game terminated!, See you next time!!");
}

サンプルコードは一番上の「ミニゲーム」の部分にリンクしています。

コンソールゲームで初めのタイトルが表示される様なものです。初めはこれからストーリーをつけて。。。と考えていたのですが、ストーリーができず。。。保留状態です。。。※作成しました。作成したものは上部にYOutube動画があります。

実装したコード

この記事の上部にあるリンク先にはGithubで見ることができます。関連クラスも同様にアップロードしてあります。

/**
 * コマンドラインRPGのメインクラス</br>
 * <ul>
 * 機能リスト
 * <li>1.必要なリソースを読み込む #init</li>
 * <li>2.ゲーム起動(コマンド入力) #gameLoop</li>
 * <li>3.リソースの解放</li>
 * <li>ゲーム終了(このメインメソッドの終了)</li>
 * </ul>
 * @author takunoji
 */
public class RpgMain {
    /** フィールド変数で自信を管理 */
    private static RpgMain game;
    /** 定数: AP終了コマンド */
    public static final String TERMINATE_GAME = "bye";
    /** 入力を受付るオブジェクト */
    private BufferedReader read;
    /** 画面状態管理オブジェクト */
    private static ViewStatus status;

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

    /**
     * このゲームでは初期化は必ず1回なのでstaticをつける</br>
     * static -> 静的メソッド=> クラス内にあるがJVMから直で参照される
     * ※JVM => Java Virtual Machine
     */
    private static void init() {
        // mainメソッドと同様にクラスをnewする必要あり
        game = new RpgMain();
    }

    /**
     * この処理もinit()と同様に必ず1回なのでstaticをつける</br>
     */
    private static void gameLoop() throws IOException{

        /*
         *  <ゲームループ> 
         *  1.入力
         *  2.データ更新、
         *  3.レンダリング(今回はコマンドなので文字出力)
         *  4.「bye」コマンドでゲームを終了する
         */
        while(true) {
            // 1. 入力を受け取る
            String command = game.listenInput();
            // command変数がnullになる可能性があるため定数.equals()の形にする
            if(TERMINATE_GAME.equals(command)) {
                break;
            }
            // 2-1.処理を実行する(タイトル、その他初期表示する
            status = game.execute(command);
        }
    }

    /**
     * ゲームのリソースを解放する
     */
    public static void terminated() {
        // クラスの解放を行う
        game = null;
        System.out.println("This game terminated!, See you next time!!");
    }

    //////////////////////////////////////
    // コンストラクタ、メンバメソッドの定義
    //////////////////////////////////////
    /**
     * ぶっちゃけてここで初期化(init)処理をやっても良い</br>
     * 最終的にプログラムの設計者の判断に委ねられる</br>
     */
    public RpgMain() {
        // メンバメソッドなのでコンストラクタで呼び出す
        initialize();
    }

    /**
     * 入力、出力のためのオブジェクトを生成</br>
     * RpgMainクラスが存在しないならば使用できない様にするので</br>
     * このメソッドはメンバメソッドにしてある</br>
     */
    public void initialize() {
        // 入力受付クラス
        read = new BufferedReader(new InputStreamReader(System.in));
        // *** titleの表示 *** //
        // ViewStats生成
        status = new TitleView();
    }

    /**
     * 入力受付を開始、入力結果を取得する</br>
     * @return 入力文字列(コマンド)
     * @throws IOException
     */
    private String listenInput() throws IOException {
        return read.readLine();
    }

    /**
     * コマンドの実行を行う<BR>
     * 1.
     * @param input
     * @return
     */
    private ViewStatus execute(String input) {
        status = status.execute(input);
        return status;
    }

    private void view() {
        if(status != null) {
            status.views();
        }
    }
}

関連ページ一覧

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 4Boolean
  5. Java Basic Level 5If 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 9Training 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 〜テストスイートの作り方〜

 

Java Basic インターフェース 〜Step2_3 〜

イントロダクション

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

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

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

余談

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

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

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

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

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

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

これがまずは、基本的な考え方になります。

インターフェースクラスを作成すると、このインターフェースクラスを一つのグループとして使用することができます。
ListインターフェースクラスのJavaDocを見てみると「既知の実装クラス」の部分にあるクラスが実装(implements)しているクラスです。

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

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

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

なお、各実装は以下のように定義します。
<TestIF>

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

<TestCls1>

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

<TestCls2>

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

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

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

実行結果

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Java Basic API Listの使い方 〜Step2_2〜

Listの使い方

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

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

このリストはJavaでのプログラムでも存在していて完全クラス名はjava.util.Listです、そして、詳細な説明があるJavaDocはこちらのリンク先にあります。
クラスと言いましたが、これは「インターフェース・クラス」実体のないクラスです。これは実体のあるクラスを格納できる変数だと思ってもらえれば、ある程度はわかりやすいと思います。

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

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

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

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

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

Listの扱い方

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

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


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

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

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

【配列の扱いあれこれ】

配列を使用して様々なデータを検証、編集など 色々な処理を行いますが何かと不便なこともあります。 String[] args = new String[5]; の様に初期化した場合→test01();

サンプルソースのダウンロードができます。

この場合は、配列の数が決まるので困る時があります。 例:標準入力を受けるとき byte[] b = new byte[5]; System.in.read(b);

上記の場合は、5文字までを受け取ることができます。 少なかったり多かったりすると上手くないのです。。。 なので前回はBufferedReaderを使用してそこを解消しました。

そこで、初めの配列(byte[] b)をString[], int[]などに変更した場合 かつ標準入力出ない場合はどうしたら良いでしょうか?

【Listクラスを使用する】

ここで、Listが出てきます。完全修飾名(完全クラス名)は 「java.util.List」クラスです。正しくはインターフェースクラスになります。 このインターフェースは以下のクラスに実装されています。 他にもあるけれど、使用頻度の高いものを記載します。

java.util.ArrayListクラス(完全修飾名) ・java.util.LinckedListクラス(完全修飾名) ・java.util.Vectorクラス(完全修飾名)

これらのクラスにはclass名の後に「implements java.util.List」 が記載されています。

これが「実装する」という意味です。 // インターフェースの定義 public interface List { ....}の様に記載します。 実際のjava.util.Listインターフェースの内容は Eclipseを使用しているならListの文字の上で「F3」を押下すると ソースを見ることができます。 実際のインターフェース定義は以下になります。

public interface List<E> extends Collection<E> {
    // Query Operations

インターフェース定義でも「extends」とありますが
とりあえず置いておきます。

ではインターフェースって何?となると思います。
インターフェースはクラスに実装(implements)することにより
インターフェースで複数のクラスを一つの変数で扱えます。

例として、ListはArrayListとLickedListをListの変数で使用できます。
List<String> list = new ArrayList<String>();
// OK牧場(笑)
List<String> list1 = new LinkedList<String>();
の様に別のクラスでも同じ変数で使用することができます。
【追伸】
List<変数の型>の「変数の型」の部分は、ジェネリクスと言います。
コードが長くなってくるとこのリストの中身はなんだった?
とわからなくなってしまいます。それを解消したのがこの
「ジェネリクス」です。
その他Map, Set, Vectorなどで使用します。

でわでわ。。。

Java Basic try catch文 〜Step1_3_3〜

イントロダクション

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

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

Exceptionの種類によりコントロールすことができます。
ちなみにしたの場合は、どんなエラーでもキャッチします。

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


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

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

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

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

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

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

try catch文

入出力や様々なところでエラーハンドルを
行うために使用します。

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

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

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

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

サンプルコードはこちら

実装例

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

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

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

// try部分に例が発生するメソッド処理を記載するtry {

   System.in.read(b);

} catch(IOException e) {

   // 例外が起きた時にはキャッチ文ところで処理

   e.printStackTrace();

}

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

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

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

// 5バイト(5文字)分
byte[] b = new byte[5];

try {

   // 入出力の例外を投げる

   System.in.read(b);

  // 文字列を受け取る

  String result = new String(b);

  // 文字列に'a'が見つからない場合

 if (result.indexOf("a") == -1) {

     // 例外を投げる

    throw new Exception("入力違反です");
  }

} catch(IOException ie) {

   // 初めに標準入力の例外を受け取る様にする

   ie.printStackTrace();

} catch(Exception e) {

   // 自分で投げる例外をキャッチ
 
   e.printStackTrace();

}

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

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

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

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

public static void main(String[] args) {

   testPrint();

}


/**

 * メインメソッドから直接(クラスをnew しないで)呼び出す時

 * はメソッドの修飾子に「static」をつける

 */

public static void testPrint() {

   try {

      throw new Exception("必ず例外を投げます");

   } catch(Exception e) {

     e.printStackTrace();

   }
}

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

関連ページ

  1. 標準入力(コンソールからの入力)<System.inクラスについて>
  2. サンプル実装〜コンソールゲーム〜
  3. Java Basic インターフェース・抽象クラスの作り方
  4. Java Basic クラスとは〜Step2_1〜

 



関連ページ

Java Basic While文 〜 Step1_3_2〜

while文は、単純なループを行うときに便利です。for文と違ってシンプルな記述が可能です。

とりあえずは、こんな感じで実装してみました。
余計な音が入っています。

処理内容としては、以下のようなものです。

1.標準入力を受け付ける
2.入力値を表示する。
3.「bye」と入力されたら処理を終了する。
4.それ以外は無限にループする

while文の書き方

1: while文の書き方

while(ループする条件) {
// 処理
}

2: 「ループする条件」について

例1: 3回ループする

int i = 0;
while( i < 3) {
// 処理
}

上記の「i < 3」の部分が条件になり、日本語に訳すと
「iが3より小さい間」という意味になり
「while(i < 3)」は「iが3より小さい間ループする」
という意味になる。
「条件」部分(i < 3)に関して、真偽値(True, Flase)のページで解説しています。

例2: 無限ループする

int i=0;
while(true) {
// 処理
}

例2の場合は条件の部分が「true」になっています。
条件の部分はtrueの間ループするので
→「i < 3」=> trueの場合が例1
例2の場合はずっとtrueなので「無限ループ」になります。
無限ループの場合、「break」文がないとPCが固まって
しまうので注意が必要です。

例3 do while文(4回ループ)

int i = 0;
do {
// 処理
} while(i < 4);

条件が下の部分に来ています。

サンプルコードはこちら

関連ページ

Java Basic for文 〜Step1_3_1〜

イントロダクション

ひと通り、変数の扱いなど理解したら今度は、ループや条件分岐などを理解します。

こんな感じです。余計な音が入っています。

ここら辺の文法を理解したらロジックを組むのが楽しくなると思います。

具体的には、「条件分岐」と「ループ」を使って、例えば「じゃんけんゲーム」を作ってみるとか、何かしらのアイディアを実装するとか。。。

フローチャートを書いてみるのも良いと思います。

<フローチャートの例>

兎にも角にも、「何を?」「どのように?」「どういう順番で?」実行するのか?を考えるところがロジックを組むために考えるところだと思います。
筆者は、今(2023-03-03現在)テキストRPGを作成するアプリを作ろうとしています。
詳細は、リンク先に記載しています。Githubです。アイディアの共有ができれば幸いです。

for文

いきなりですが、for文についてやります。※バグが入っております。それはどこでしょうか?

public static void main(String[] args) {
   // String型の配列を初期化
   String[] moji = {"abc", "def", "ghi"};
   // コンソール出力する変数
   String result = "";
   /* 【書き方】
    * for( 初期値; ループ条件; ループするときの処理) {
    *     // 何かしらの処理
  * }
    */
   for( int i = 0; i < 4; i++) {
      result += moji[i];
   }
   System.out.println("配列を繋げると: " + result);
}

初めにString型の配列を初期化しています。
ループして表示するために変数を用意しました。
そして、コンソール出力用の変数「result」
for文を開始いたします。

for文の文法

上記のソース部分にも記載しましたが、一応
1行大枠のみを記載すると以下のようになります。
for( .... ) { / 処理 /}

「for(」に続き
「int i = 0」の部分では使用する変数を初期化しています。
「i < 4」はループ条件、「i」が4より小さいときループします。
「i++」はfor文の中上の「/ 処理 /」の部分を一周したら行う処理です。

<書き方>

for (初期化; ループ条件; 後処理) {
   // 何かしらの処理
}

<サンプル>

for (int i = 0; i < 10; i++) }
   // 何かしらの処理
}
  1. 変数「i」を0で初期化、これでカウンターをセットする。
  2. 「i」が10より下(i < 10)の間ループする。
  3. 何かしらの処理が1回終わったら後処理(i++)を行う。

ちなみに、for文で無限ループするとこんな感じになります。

// 何も書いていないのは「処理なし」ということ
for (;true;) {
   // 何かしらの処理
}

サンプルコードと内訳


for( int i = 0 /* ① */; i < 4 /* ② */; i++ /* ④ */) {
    // ③
    System.out.println("Hello World=" + i);
}

① int 型の変数「i」を0で初期化して
②「i」が4より小さい間
③「Hello World」に「i」の値を付け足した文字を
コンソールに出力します。
1回目のループは、「i」が1なので「Hello World1」が表示され
2回目のループは、「i」が1なので「Hello World2」が表示される



となります。
④そして、コンソール出力をした後に「i++」の処理が走ります。
「i++」→「i」をインクリメントする=「i」に1を追加する
→ i = i + 1;
それから、次のループ処理を行う。。。

ざっと、コードを書いてみました。こんな流れになります。
サンプルコードはここからダウンロードしてください。

練習

やり方を眺めたら、次は実行してみるのがポイントです。プログラミングスキルとして要求されるものは「技術」と「理論」です。
技術はあれこれと考えるより手を動かす」のが大事です。プログラミングスキルという意味では、これが半分、
もう半分は理論です。「理論は、あれこれと考える」ことです。※おおざっぱな話ですが。。。

練習問題

問題を解くときに、パッケージ作成などしてやるとクラス配置が整理できます。

問題1

1から10までを合計した値をコンソール(標準出力)に表示してください。

問題2

問題1で作成したコードをベースにして、底辺が3、高さが1から10まで変化するときすべての三角形の面積を表示してください。
※以下のように表示してください。「??」には計算結果が入ります。
(3 x 1) / 2 = ??
(3 x 2) / 2 = ??
(3 x 3) / 2 = ??


問題3

問題2のコードをベースにして、三角形の数が10, 9, 8, 7 ...となるとき、すべての三角形の面積の合計を表示して下さい。
※以下のように表示してください。「??」には計算結果が入ります。
(3 x 1) / 2 = ?? 三角形は10個で面積は???
(3 x 2) / 2 = ?? 三角形は9個で面積は???
(3 x 3) / 2 = ?? 三角形は8個で面積は???


でわでわ。。。

 

関連ページ

Java Basic booleanの意味と条件分岐 〜Step1_2_2〜

イントロダクション

はじめに復習をします。

前回使用した変数にint型, dluble型がありますが、これらはプリミティブ型変数と呼びます。
これに対して、String型のようにクラスとしてJavaで定義されているものは参照型と呼びます。

具体的に、参照型はメソッドが呼べるがプリミティブ型がはメソッドが呼べないというところです。

そして、もう1つ参照型変数はインスタンスを参照します。このインスタンスがキーポイントになりますが、今はString型の変数を初期化したら、その変数にはString型のインスタンスが入っているんだなと理解してください。

この「インスタンス」のことを「オブジェクト」と呼んでいることが多いですが「プログラミング業界で『オブジェクト』と言えばほとんどすべてのもの」が『オブジェクト』になるので注意が必要です。

具体的には下のようなコードになります。

int num = 0;
//int num1 = null; -> ビルドエラー
String moji = "abc";
String moji2 = null;

moji.length(); // 文字列の長さを取得する
// num1.length(); // エラーになる
  1. プリミティブ型の変数にはnullを代入できません。プリミティブ型は何もない=「参照なし」の状態にはできないのです。
  2. 参照型にはnullが代入できます。参照型は何もない=「参照なし」の状態があり得ます。

String型のような参照型の変数は、常にクラスを参照しようとします。なのでどこも参照したくない場合はnullを代入します。俗にいうと「メモリを解放する」という処理になります。

そして、プリミティブ型の変数、intdoubleを使用してきましたが。これらの変数はメモリ領域を直接確保します。
なので、確保した領域に「何もない」=nullを代入することができません、つまり、はじめから変数を宣言(初期化)=メモリ領域の確保、は必要ないからです。

具体的には、下のようなプログラムを見ていただくとわかると思います。

int num; // int型の変数を宣言=4バイト文のメモリ領域の確保
int num1 = 1; // 上と同様に4バイト文のメモリ領域を確保

String moji = null; // 変数を宣言しているが、メモリ領域は確保していない
String moji2 = "a"; // 変数を宣言して値を設定しているので1バイト分のメモリ領域を確保

上記のようになります。

サンプルコード

プログラム引数を整数型の変数にセットして四則計算を行い表示するプログラムです。
※ テストしていないので、こんな感じというのを見てほしいです。

public class Sample {
    public static void main(String[] args) {
        if (args.length != 2) {
            System.out.println("プログラム引数は2つセットしてください。");
            System.exit(-1);
        }
        // プログラム引数は1桁の数字
        if (args[0].matchies("0-9") && args[1].matchies("0-9")) {
            int left = Integer.parseInt(args[0]); // プログラム引数の1つ目
            int right = Integer.parseInt(args[1]); // プログラム引数の2つ目
            // 四則計算の処理
            System.out.println("left + right = " + (left + right));
            System.out.println("left - right = " + (left - right));
            System.out.println("left * right = " + (left * right));
            System.out.println("left / right = " + (left / right));
        } else {
            System.out.println("プログラム引数は1桁の数字をセットしてください。");
        }
    }
}

プログラム引数を使用してプログラムを実行しています。具体的な処理内容は以下の通りです。

  1. 引数が2つでない場合はメッセージを表示してプログラムを強制終了(異常終了)
  2. プログラム引数が2つとも一桁の数字であれば、四則計算を行い表示
  3. それ以外はメッセージを表示

<コマンドで実行する場合>
下のようにコマンドをたたく

java Sample 1 2

boolean型

プリミティブ型の変数booleanの扱い方について記載します。

真偽値で、条件分岐を行うのに便利

// sample
int a = 1;
int b = 2;
boolean isSame = a == b;
System.out.pintln(isSame);

上のコードは、int型の変数、「a」「b」を初期化してそれぞれの値が等しいかどうか検証しています。

boolean isSame = a == b;

この行が判定している処理になります。

そして、この判定結果がboolean型の変数isSameに代入されています。

早い話が

aとbが等しい時は「true」、そうでない場合は「false」が変数isSameに代入されます。

これを確かめるのには、上のコードを実行してみればわかります。

試しに、「a」「b」の値を変更して実行して見てください。
どのような結果になるか予想してから実行して見てください、

ちょっとしたクイズゲームみたいでしょう?

ちょっとしたクイズゲーム

上のコードを書き換えて、下のように修正しました。これを写経して動かして見てください。
ちなみに、「サンプル実装パターンX」とあるコメント行から下の部分が変更する部分です。

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    String num1 = scan.next();
    String num2 = scan.next();
    // サンプル実装パターン1
    int a = Integer.parseInt(num1);
    int b = Integer.parseInt(num2);

    boolean isSame = a == b;
    System.out.println(isSame);
}

別パターン

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    String num1 = scan.next();
    String num2 = scan.next();
    // サンプル実装パターン2
    int a = Integer.parseInt(num1);
    int b = Integer.parseInt(num2);
    boolean isSame = a == b;
    if (isSame) {
       System.out.println(a + “ and “ + b + “ is same”);
    } else {
       System.out.println(a + “ and “ + b + “ is not same”);
    }
}

ちなみに、筆者が作成したものを動画にしてみました。

プログラム引数について

Javaプログラムを起動するときに渡す値のこと、コマンドで渡す、IDEでプログラムを実行するときに渡す。

public static void main(String[] args) {
   System.out.println(“プログラム引数は” + args[0] + “です”);
}

上のコードはプログラム引数を渡さないと落ちます!

Eclipseで実行するときは以下のような画面で
「引数」「Arguments」のタブより
「プログラム引数」と「VM引数」とあるので
プログラム引数の部分に入力する

VM引数

システムプロパティなどに使う、Java Vertual Machine(JVM)に渡す引数
「-D引数」という形で渡す※全てではない

<プログラム引数を渡す。>※ Eclipse余計な音が入っています。

<プログラム引数を渡す。>※IntelliJ IDEA

IF文の書き方

【条件分岐の書き方】

if ( 条件式 ) {
   処理
} else if( 条件その2) {
    処理2
} else {
    上記の条件以外のケースの処理
} 

<IFの実装サンプル>

上の「条件式」の部分には論理式が入ります。論理式はboolean型の値を返却する式のことです。
具体的には下のようになります。

boolean(真偽値)

<Booleanの実装サンプル>

// 下の変数には全てtrueが入ります
boolean isSame = 1 == 1;
boolean notSame = 1 != 2;

boolean isSameString = "1".equals("1");
boolean notSameString = !"1".equals("1");

boolean yes = true;
boolean no = false;

// 論理演算
boolean result = yes & no; // falseになる AND演算
result = yes | no;         // trueになる OR演算
result = yes ^ no;         // trueになる XOR演算
result = ~yes;             // falseになる NOT演算
日本語 演算(演算子) 真偽値1 真偽値2 結果
論理積 AND(&) TRUE TRUE TRUE
論理積 AND(&) TRUE FALSE FALSE
論理積 AND(&) FALSE FALSE FALSE
論理和 OR(|) TRUE TRUE TRUE
論理和 OR(|) TRUE FALSE TRUE
論理和 OR(|) FALSE TRUE TRUE
論理和 OR(|) FALSE FALSE FALSE
排他的論理和 XOR(^) TRUE TRUE FALSE
排他的論理和 XOR(^) TRUE FALSE TRUE
排他的論理和 XOR(^) FALSE TRUE TRUE
排他的論理和 XOR(^) FALSE FALSE FALSE
否定(ビット反転) NOT(~) TRUE - FALSE
否定(ビット反転) NOT(~) FALSE - TRUE
        boolean and = true & false;
        boolean or = true | false;
        boolean xor = true ^ false;
        // NOT演算
        boolean not = !false;

【標準入力】 ※低レベルな(古い)書き方です。

public static void main(String[] args) {
   byte[] input = new byte[5]; // 5文字までの入力分
   System.in.read(input);
   System.out.println(input); // コンソール出力
}

【標準入力】 ※最近の書き方です。

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

<標準入力を使うサンプル>

【プログラム引数の使い方】
※サンプルは上の方にあります。

public static void main(String[] args) {
   // プログラム引数はスペースで区切ると複数個入力できる
   System.out.println("プログラム引数: " + args[0]);
}

【標準出力・入力のメソッドについて】
「System.out.println("文字列");」とコードを記載すると思いますが
Systemクラスのoutフィールドに定義されている「printlnメソッド」を
いつも使用しています。

JavaDocAPIを見るとそのように書いてあります。
Javaに関してはこのJavaDocを読んで理解できるようになれば
Javaの基本はマスターしたと言って過言はありません。

とりあえずは、こんな感じです。

switch文

今度はswitch文についてです。
BlueJでSwitch文>

IF文と同じように条件分岐を行いますが、コードの書き方が違います。

switch (値) {
case 値がXXの時:
    // 何かしらの処理
    break;
case "文字":
    // 何かしらの処理
    break;
case "文字2":
    // 何かしらの処理
    break;
default:
    // 想定外の値の時の処理
}

実際に使用する時は「値がXXの時」の部分を指定した値の時の処理を書きます。
言葉で示すよりもコードで示す方が良いと思いますので、以下に示します。

String moji = "aa";
switch (moji) {
    case "aa":
        System.out.println("1. 何かしらの処理");
        break;
    case "abc":
        System.out.println("2. 何かしらの処理");
        break;
    default:
        System.out.println("3. 何かしらの処理");
}

上記の場合、String型の変数「moji」に「aa」という値が入っていますので。「1. 何かしらの処理」が標準出力に表示されます。(出力されます)

そして、case文の中にある「break」がない時は、全て表示されます。具体的には以下の通りです。

String moji = "aa";
    switch (moji) {
    case "aa":
        System.out.println("1. 何かしらの処理");
    case "abc":
        System.out.println("2. 何かしらの処理");
    default:
        System.out.println("3. 何かしらの処理");
}

この場合は、下のように出力されます。

  1. 何かしらの処理
  2. 何かしらの処理
  3. 何かしらの処理

そして、次の場合はどうでしょうか?

String moji = "aa";
switch (moji) {
    case "aa":
        System.out.println("1. 何かしらの処理");
    case "abc":
        System.out.println("2. 何かしらの処理");
        break;
    default:
        System.out.println("3. 何かしらの処理");
}
  1. 何かしらの処理
  2. 何かしらの処理

と表示されます。これはcase "aa"のcase文に「break」がなく次の"abc"の部分に「break」があるからです。

つまり「break」は「{}」の中から外に出ますよという意味です。

if文の時でも同様ですが、意味がないので使用しません。

次にやるループ処理では大いに意味があるので使います。

変数「i」が3の時ループを抜ける処理
for (int i = 0; i < 10; i++) {
    if (i == 3) {
        break;
    }
}

<<<前回 次回>>>

関連ページ

Java データ型 変数の扱い方〜Step1-2-1〜

イントロダクション

前回は、演算子ということで「四則演算」を行いました。

次のステップとして、以下のようなことを行います。

前回は演算子にはどんなものがあるか?どんなふうに使うのか?といったことに触れましたので、今回は、それらをまとめて実践的な視点で
メソッドを作成することも考えた形で学習したいと思います。

  1. 変数の扱い
  2. byte型変数
  3. 基本になるデータ型
  4. 変数の宣言方法
  5. リテラルに関して
  6. メソッドを切る(作る)

変数の扱い

Javaなどのプログラムではデータの形として、次のものがあります。

  • 数値(int, double, short, long, float ...)
  • 文字(char, String(クラス))
  • クラス(java.lang., java.util.) ※javaのパッケージで記載しました。

上に列挙したデータの形は「かっこ()」内に記載した型名のように、「XXX型」というような名前がついています。
これらを分けて考える必要があります。そのため「データ型」という概念を使って区別します。

具体的には、int型であればそれは「整数の値ですよ。」doubleであれば、浮動小数点数、文字れあればchar、文字列であればString。。。
これらは、使いながら覚えていけばよいと思います。頭で暗記しても使えなければ意味がないので、使いながら理解していくのが最も効率的だと思います。なので、使いながら学習していきましょう。

下のコードは、各データ型の初期化を行っているものです。これらのデータを初期化したうえで、何かしらの処理を行うのが多いです。

// int型
int seisu = 10;
// double型
double shosu = 1.3;
// char型
char ch = 'a';
// String型
String moji = "文字列";

System.out.println("int型: " + seisu);
System.out.println("double型: " + shosu);
System.out.println("char型: " + ch);
System.out.println("String型: " + moji);

上から順にコードの説明を以下に示します。

  1. int型の変数「seisu」を10で初期化
  2. double型の変数「shosu」を1.3で初期化
  3. char型の変数「ch」を'a'で初期化 -> 「char」は1文字のみを示すデータ型です。
  4. String型の変数「moji」を10で初期化
  5. 文字列「int型:」に変数「seisu」の値を連結して表示
  6. 文字列「double型:」に変数「shosu」の値を連結して表示
  7. 文字列「char型:」に変数「ch」の値を連結して表示
  8. 文字列「String型:」に変数「moji」の値を連結して表示

データ型の表示サンプルコードはこちら
※下に基本的な変数の種類を記載しています。

<変数の扱いのサンプル>

byte型変数

パソコンは、データ~画像の表示まですべてを2進数で行っております。この2進数を示すデータ型が「byte」です。
この2進数は、10進数、8進数、16進数と変換することが(わりかし)容易です。そして、文字を表示するのにアスキーコードユニコードなど扱うのに便利です。

byte型変数:ビット(bit)とは→1010(つまり二進数)

  • 1バイト(1byte) = 8bit(8桁の2進数) => 10101010
    javaでは、byte b = 0b10101010のように書くことができる。しかしコンソールに表示すると「int型」として表示される。。。
  • 4bitは2進数の「1010」のように4つの「0か1」が並んだもの
    例: 2進数(4bit)の「1010」は10進数(普通の数字)では「10」になる

「0」→0, 「1」→1「10」→2, 「11」→3, 「100」→4,「101」→5,「110」→6, 「111」→7, 「1000」→8,「1001」→9, 「1010」→10

具体的には、パソコンの内部的なところでは、全てが二進数で扱われます。なので、プログラムでは
人間にわかるように、二進数ではなく、今書いている「文字列」や「数値」などのように「データ型」を設けて
「"1"」と「1」を区別します。

2進数「111001」は整数型では 57を示し、 char型では '9' を示す

このように、2進数は同じ値でも、データ型によって表示される値(文字を含む)が変わります

それは、パソコンが2進数で全てを表現しているからです。

基本になるデータ型

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

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

これらに対して、クラス型(参照型)というのがあります。代表的なモノはString型です。もちろん自作したクラスも参照型になります。

変数を使ったサンプルコード

以下に、サンプルコードを示します。
コメント部分にコードの意味を書いています。

サンプルコード1

変数の宣言と、初期化の違いを記載しています。同様に、四則計算も行っています。

public static void main(String[] args) {
    // 変数「i」の宣言
    int i;
    // 変数の初期化
    int j = 0;

    // 足し算
    int answer = 1 + 1;
    // 引き算
    int answer1 = 1 + 1;
    // かけ算
    int answer2 = 1 * 1;
    // わり算
    int answer3 = 1 / 1;

    System.out.println("足し算の結果:" + answer);
    System.out.println("引き算の結果:" + answer1);
    System.out.println("かけ算の結果:" + answer2);
    System.out.println("わり算の結果:" + answer3);

    i = 20;
    j = 11;
    System.out.println("問題の答え:" + (i + j));
}

変数の宣言方法

変数のデータ型(下のサンプルは整数型(int型))

// 変数「i」の宣言
int i;
// 変数の初期化
int j = 0;

変数のデータ型(下のサンプルは文字型(char型))

// 変数「i」の宣言
char c;
// 変数の初期化
char ch = 'A';
char ch = 65;

char型は1文字をセットする変数型です。数値で扱うこともできます。
ASCIIコード表に対応しています。

スコープ(変数の生存範囲)

変数の宣言する位置によって変数のスコープが決まってきます。例えば、下のようなケースがあります。

  • フィールド変数はクラス全体がスコープの範囲になります。
  • メソッドの中で宣言するローカル変数はメソッドの中。。。
  • if文の中で宣言するローカル変数はif文の中あ。。。

ここでの注意は、変数名は同じスコープ(「{」から「}」の間)の中になければ重複しても問題ありません。ということです。

次のサンプルコードではint型変数の「c」に注目してみてください。

<エラーにならないパターン>
具体的には、下のコードはエラーになりません。ifの中で初期化している「int c」のスコープはelseの中に届かないためエラーにならない。

public static void main(String[] args) {
    if ('a' == 'a') {
        int c = 0;
        System.out.println("'a' == 'a': TRUE");
    } else {
        int c = 0;
        System.out.println("'a' == 'a': FALSE");
    }
}

<エラーになるパターン>
if文の外にて初期化しているので、ifとelseのスコープを含む範囲にあるためエラーになります。

public static void main(String[] args) {
    int c = 0;
    if ('a' == 'a') {
        int c = 0;
        System.out.println("'a' == 'a': TRUE");
    } else {
        int c = 0;
        System.out.println("'a' == 'a': FALSE");
    }
}

変数のデータ型(下のサンプルは文字型(byte型))

// 変数「i」の宣言
byte i;
// 変数の初期化
byte j = 0;

※文字列型は、クラス=参照型になります。

まずは「int」「double」「String」のデータ型を覚えましょう。

リテラルに関して

変数の型に関しては、理解できたと思いますが、変数を宣言したときの右側部分

リテラルは文字列、整数型などの変数に値を設定する前。
つまりは、「=」の右側のことです。
「String a = "文字リテラル";」とか「int i = 10」などのような初期化をした時に出てくる右側部分です。つまりは、 「"文字リテラル"」と「10」がそれにあたります。

String moji = "文字リテラル";
int seisu = 10;

上のコードの場合は、文字リテラルが「"文字リテラル"」で整数リテラルが「10」になります。

細かい説明などはこちらの動画にしてありますので、よかったらどうぞ。

[参照型]→ クラスのこと

データ型          読み      用途
String         ストリング   文字列 "abcdefg"(ダブルクォーテーション使用)
Array      配列     変数に「[]」が付いている以下に例を示す

<配列の使用例>
// int型の配列宣言

int hairetu[] = {1,2,3,4,5};

配列から値を取り出した場合は、配列にはなりません。具体的には下のように、int型の配列から値を取り出すと、int型になります。

int hairetu[] = {1,2,3,4,5};
int i = hairetu[0];

// 配列の中身をコンソールに表示
System.out.println("配列の一番初めの値" + hairetu[0]);
//これも初めのうちは「丸暗記」でOKです。(処理内容を理解しなくても良い)

/*
* 配列の中身を足し算します
*/
int answer = hairetu[0] + hairetu[1]; // 1 + 2
System.out.println("配列の初めの2つを足し算=" + answer);
// 同様に5番目と3番目の引き算(5 - 3)
int answer1 = hairetu[4] - hairetu[2];
System.out.println("5 - 3" + answer1);

// サンプル
long time = System.currenttimemillis();</pre>

<問題>

<問題1>
上記の配列「hairetu」の中身を全て合計するプログラムを作成して
答えが正しいか起動結果を確認してください。
「ヒント」
・配列の1番目は「hairetu[0]」のように指定します。
・クラスの中にメインメソッドを作成して実行してみてください。

とりあえずは、こんな感じです。

<問題2>
プログラム引数に2つの数字を渡して、それらを足し算して式と結果を表示するプログラムを作成してください。

コマンド実行したときの例

java Mondai 1 2

実行結果

1 + 2 = 3

問題の作り方

問題の解凍方法のサンプルです。パッケージとクラスの作成方法を動画にしました。

メソッドを切る

余力があればこちらもどうぞ、と言うレベルです。

※ 余計な音が入っています。

今まで作成したプログラムは「なんとなく残しておきたいな。。。」と感じた方、早速残しましょう。

作成したプログラムは、「メソッド」と言う形で別な場所に移すことができます。当然呼び出さなければ、意味がありませんが、メインメソッドを動かしても影響のないようにする」と言うことであれば、メソッドに定義して残すのも1つです。

具体的に、メソッドに作成した処理を移動して、そのメソッドを動かさなければコードが残っているだけになります。
悪く言うと、残骸になります。

具体的に。。。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
        int X = 43;
        System.out.println("X % 2 = " + X % 2);
        // クラスのインスタンス化
        HelloWorld main = new HelloWorld();
        // メンバメソッドを呼び出す。
        main.test1();
        // スタティックメソッドを呼び出す。
        HelloWorld.test2();
    }

    /** メンバメソッド */
    public void test1() {
        System.out.println("test1");
        System.out.println("2 / 2 = " + 2 / 2);
    }
    /** スタティックメソッド */
    public static void test2() {
        System.out.println("test2");
    }

    /** スタティックメソッド */
    public static void newClass() {
        // クラスのインスタンス化
        HelloWorld main = new HelloWorld();
        // メソッドを呼び出す。
        main.test1();
        // スタティックメソッドを呼び出す。
        HelloWorld.test2();
    }
    /** スタティックメソッド:四角を表示する */
    public static void printRect() {
        System.out.println("****** ");
        System.out.println("*    *");
        System.out.println("*    *");
        System.out.println("*    *");
        System.out.println("*    *");
        System.out.println("******");
    }
}
  1. staticがついているメソッドはメインメソッドから直接呼び出すことができます。
  2. メンバメソッド」は呼び出すことができません。呼び出すにはクラスをnewしてやる必要があります。

メンバメソッドもstaticメソッドもクラス内で呼び出すのであれば、クラス名を省略することができますが、staticメソッド内においては、メンバメソッドはクラスをnewする必要があります。

<メンバメソッドを呼び出す例>

HelloWorld main = new HelloWorld();
main.test1();
HelloWorld.test2();

<staticメソッドを呼び出す例>

public class HelloWorld {
    public static void main(String[] args) {
        // staticメソッド呼び出しクラス名を省略(クラス内にあるメソッドなので省略可能)
        printRect();
        // メンバメソッド呼び出し、クラスはnewする必要がある
        HelloWorld main = new HelloWorld();
        main.test1();
        // staticメソッド呼び出し
        HelloWorld.test2();
    }
    /** メンバメソッド */
    public void test1() {
        System.out.println("test1");
        System.out.println("2 / 2 = " + 2 / 2);
    }
    /** staticメソッド */
    public static void test2() {
        System.out.println("test2");
    }

    /** staticメソッド */
    public static void printRect() {
        System.out.println("****** ");
        System.out.println("*    *");
        System.out.println("*    *");
        System.out.println("*    *");
        System.out.println("*    *");
        System.out.println("******");
    }
}

※余計な音が入っておます。

前回 <<< >>> 次回

関連ページ

Java 四則演算 演算子 〜Step1-2: arithmetic calculation〜

イントロダクション

Javaによる、足し算〜割り算のやり方をまとめました。はじめのコードの記述方法はJava Hello World はじめのプログラム 〜 Step1-1〜を参照してください。

ちなみに前回はこんな感じのことをやりました。メインメソッドの作成とハローワールドの実行です。

四則演算

はじめのプログラム、「ハローワールド」を実装したら次は、四則計算を行うプログラムを書きましょう。
はじめのプログラムで「文字列を表示する」事を行ったので、次は「計算結果を出力しましょう」ということです。
ちなみに、「パソコンは基本的に計算機なので、四則計算は基本になる」ということです。

文字表示の次は

四則演算を実装できるようになりましょう。ポイントとしては、変数の型と計算するための*演算子「+, -, , /」を理解する*ことです。
これらの演算子は、それぞれ「足し算(+), 引き算(-), 掛け算(
), 割り算(/)を行うためのものです。
また、これらの演算結果を表示するSystem.out.println( ... );の処理の引数(「()」)に表示したいものを渡します。
コードで書くと下のようになります。

System.out.println("文字列を渡す");
System.out.println(1 + 1); // 計算結果を渡す

// 文字列に統合されるので「文字列を渡す1」と表示される
System.out.println("文字列を渡す" +1);

<文字列と数値の違い>

Javaプログラムの書き方動画

IntelliJ IDEAを使用して、パッケージとクラスの作成、メインメソッドの作成を行った動画です。Windowsナレーターで解説しています。

実行する前に、IDE(開発ツール)をインストールしましょう。

変数の使い方

今回は、変数の扱い方を学習します。

プログラムを書くときには、データを一時的に保存する変数が必要になります。変数は下のサンプルコードように「データ型」「変数名」Ex: String mojiの順番で書くルールになっています。そして「=」は変数にセットするという意味です。String moji = "セットされる文字"

そして、大まかに変数の種類として以下のような分類があります。

  1. プリミティブ型変数:データそのもの、数値や文字など
  2. 参照型変数:クラス(Javaでは全てクラスで表現されます)型の変数。

ここで「Javaでは全てクラスで表現されます」と記載しましたが、「プリミティブ型はクラスではないでしょ?」と思った方。
スルドイ!

その通りです。しかし、プリミティブ型もクラスとして表現されています。俗にいうラッパークラスとして使用されています。

しかし、プリミティブ型はクラスではありませんので、ちょっと語弊があります。

プリミティブ型の例

じゃ、プリミティブ型ってなによ?と疑問に思うと思います。筆者も疑問に思いました。
ややこしい言い方にですが、「低レベルな変数」という言い方になります。

ラッパークラスの場合は、クラスの定義通り「フィールド」と「メソッド」を持っています。

プリミティブ型の場合は、持っていません。「0と1で表現される値」と表現する方が妥当だと思います。
整数値、プラスマイナスを含めて難なく表現できます。しかし、小数点は「浮動小数点数」などと、妙な言い方をします。
これは、2進数での小数点表記がややこしいためです。そのためにJavaでは「BigDecimal」クラスが用意されています。

つまり、プリミティブ型はクラスとは違い、「値しか持っていない」ということです。だからchar a = 'a'char a = 65;は同じ'A'という意味(値)になります。

プリミティブ型の値に関して

他にも、「0bx10101010」は、2進数表記で整数型(10進数)だと「170」になります。当然2進数は8進数、16進数などに変換することができるので
それぞれに変換することができます。そしてパソコンは計算機なので、そういう計算が得意です。

リテラルという言葉の意味には「"XXX"」「123」などの表記も含まれます

進数 表記(リテラル) 10進数 内訳
2進数 |0bx1010 10 0 + 2 + 0 + 8
8進数 010 8 0 + 8
16進数 0x9, 0xf, 0x1f 9, 15, 31 9, 15, 15 + 16

ちなみに、上の2進数は8桁あります。これはデータの量で言うと「8ビット」つまり「1バイト」分のデータ量になります。
上記の「0b」は2進数表記の意味があります。そして以下のような形で書けばそれぞれの意味になります。これをリテラルと呼びます。

リテラル

変数名 表記(リテラル) 意味
byte 0bx10101010 2進数を表現する8ビット分のデータ
int 1, -12 ±の整数
double 1.2, 0.4 浮動小数点数
char 'a', 'i' 1文字を表す、整数値でもセット可能
String "moji" 文字列
// 整数値を使用するときの変数型
int num = 0;
// 小数点を含む数値を使用するときの変数型
double shosu = 0.0;
// 真偽値
boolean isNumber = false;
// 文字1文字を格納できるシングルクォーテーションで囲む
char ch = 'a';

他にもありますが、少しずつ覚えていきましょう。
使わないと忘れますので。。。

ちなみに、char型の変数は文字列として使用したいときは以下のように配列にします。

char[] moji = new char[]{`a`, `b`,  `c`};

参照型の例

自分で作成したクラスや、JavaAPIで用意されているクラスが参照型(クラス型)変数に格納できます。

// 文字列を表現するクラス
String moji = "hoge";
// int型のラッパークラス、下のコードは同じ意味になります。
Integer num = 1;
Integer num1 = new Integer(1);
// 同様にbooleanのラッパークラス(参照型になります)
Boolean isNumber = false;
Boolean isNumber1 = new Boolean

そしてクラスの型を「データ型」と呼ぶ時もあります。
どちらも同じ意味です。
ListArrayListのJavaDocです。

// データ型 変数名(宣言)
int number;
// 初期化(文字列もクラス型です)
String moji = "文字列です";
// クラス型の変数(java.util.List, java.util.ArrayList)
List<String> list = new ArrayList<String>();</String>

データ型 変数名;

// int型の変数「num」を宣言。
int num;

データ型 変数名 = 値(数値、文字列、クラスなどデータ型による)

// int型の変数「num」を「1」で初期化。
int num = 1;

ここまで、ずらずらと説明してきましたが、ちょいと動かしてみます。Eclipseを使用してデバック実行したものを動画にしました。

四則演算の解説

四則演算の方法

1.「+」足し算

//「num」に2が入る
int num = 1 + 1;

2.「-」引き算

//「hiki」に1が入る
int hiki = 2 - 1;

3.「*」掛け算

// 「kake」に1が入る
int kake = 1 * 1;

4.「/」割り算

// 「wari」に2が入る
int wari = 4 / 2;

その他の演算(計算に使用)

5.「++」インクリメント

// 変数「num」に2が入る
int i = 1;

int num = i++;

6.「--」デクリメント

// 変数「hiki」に0が入る
int i = 1;

int hiki = i--;

「%」剰余: 割った時のあまり

// 変数「amari」に1が入る
int amari = 5 % 2

→5 / 2 = 2 余り 1
<サンプルコード>: ダウンロードできます。

// 変数宣言の例→早い話が初期化は値を入れるが宣言は値を入れない

int num1;

// 変数に値0をセット、以前の値は削除される

num1 = 0;
/*
 *
 * 変数の初期化

 * 変数の宣言時に、値を代入する

 * 変数 = 値(代入)

 */
public static void main(String[] args) {
 int num1 = 1;

 <span class="s2">int</span> <span class="s3">num2</span> = 10;

 // 1.足し算

 <span class="s3">num1</span> = <span class="s3">num1</span> + <span class="s3">num2</span> + 2;
 
// 2.引き算
 
num1 = num1 - num2;

 // 3.掛け算

 num1 = num1 * 3;
 
// 4.割り算

 num1 = num1 / 2;
 
// 計算結果を表示
 
System.out.println("計算結果" + num1);
}
/** メインメソッド*/

public static void main(String[] args) {

   int hidari = 0;

   int migi = 1;

   int answer = (hidari++) + migi;
   // 計算結果が少数になる可能性があるので「double型を使用する)
   
double ans1 = answer / 2;

   int amari = 3 / 2;

}

問題

問題を解いてみましょう。クイズとかなぞなぞを解く感じで実行してみましょう。

<問題1>
mondai1メソッドを作成し、コンソールに以下を出力してください。
「出力内容」


「2 + 2 は 4です」


<問題2>
mondai2メソッドを作成して、コンソールに以下を出力してください。


「10 % 3 は 1です」


<問題3>
mondai3メソッドを作成して、コンソールにいかをしゅつりょくしてください。ただし、変数firstとsecondを表示結果と同様に初期化処理を行ってください。


変数「first」を12(数値)で初期化
変数「second」を"abc"(数値)で初期化
「firstとsecondを連結すると12abc」になります。


ヒント

初めに動かすために作るものは

  1. クラス
  2. メインメソッド

コンソール出力するのに使うメソッドはなんでしたか?計算結果を出力するコードがこの記事内にあります。

よくわからない時は、とりあえず動かしてみましょう。

とりあえず自分が似たようなことをやってみました。使用している開発ツールはEclipseです。

数値の扱いを学習したのでちょっと数学的(算数的)な問題を作ってみました。

<問題4>
正三角形の面積を求めるプログラムを作成してください。
なお、プログラム引数の第一引数が正三角形の一片の長さになります。

※ヒント
プログラム引数の使い方は以下のような手順です。
ちなみに、プログラム引数の使い方は下のような手順です。※Eclipseでのやり方
Eclipseでプログラム引数を渡すときは下のように行います。

  1. 実行するJavaファイルを右クリック
  2. 実行⇒実行の構成
    Program args
  3. 起動するクラスを選択、もしくは、検索
  4. 引数タブの「プログラム引数」に引数(文字列)を渡す
    ※プログラム引数を複数渡すときは間にスペースを入れる

リテラルに関して

変数の型に関しては、理解できたと思いますが、変数を宣言したときの右側部分

リテラルは文字列、整数型などの変数に値を設定する前。
つまりは、「=」の右側のことです。
「String a = "文字リテラル";」とか「int i = 10」などのような初期化をした時に出てくる右側部分です。つまりは、 「"文字リテラル"」と「10」がそれにあたります。

String moji = "文字リテラル";
int seisu = 10;

上のコードの場合は、文字リテラルが「"文字リテラル"」で整数リテラルが「10」になります。

細かい説明などはこちらの動画にしてありますので、よかったらどうぞ。

関連ページ

関連ページ一覧

[Eclipse セットアップ](http://zenryokuservice.com/wp/2020/09/01/%e9%96%8b%e7%99%ba%e7%92%b0%e5%a2%83%e6%a7%8b%e7%af%89%ef%bd%9ewindows%e7%89%88eclipse%e3%81%ae%e8%a8%ad%e5%ae%9a%ef%bd%9e/)

  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 Discord

  1. IntelliJ IDEA Discord Botを作る〜Gradle環境のセットアップ〜
  2. Java Discord セットアップ〜Hello Discord〜
  3. Java Discord ピンポン〜Discordプログラム〜
  4. Java Discord Listener実装〜コマンドを好きなだけ追加しよう〜