# basic

# 理解しておくべきことば
- JDK(Java Development Kit) : 開発環境
- JRE(Java Runtime Environment) : Javaの実行環境。JDKに含まれている
- JVM(Java Virtual Machine) : Javaを動作させるための仮想マシン
# コンパイル
    $ javac HelloWorld.java
# 実行

実行する際に`.class`をつける必要はない

    $ java HelloWorld
## コメント
- 一行
    // comment
- 複数行
    /*
    comment
    comment
    */
# 変数
    型 変数名という形式で書く
    String msg = "Hello world";
# 定数
    finalキーワードを使う
    String final MSG = "Hello world";
# 基本データ型
    boolean
    char : 1文字
    byte / short / int / long : 整数値、通常はint
    float / double : 小数、通常はdouble
- String : 文字列。`" "`で囲む
# 配列

次のように書く

    int[] a = new int[4]; // new演算子で型指定、要素数を書く
    int[] a = new int[]{1, 2, 3, 4}; // 宣言と同時に初期化
    int[] a = {1, 2, 3, 4}; // 省略
## 多次元配列
    int[][] a = {
    {10, 20},
    {30, 40},
    {50, 60}
    };
    System.out.println(a[0][0]); // 10
    public class HelloWorld {
        public static void main (String[] args) {
            int sales[] = {150, 200, 140, 400};

            for (int i = 0; i < sales.length; i++) {
                System.out.println(sales[i]);
            }
        }
    }
# キャスト
- データ型の違うものを演算するときはキャスト：型の明示的な変換を行う
    double d = 102.333;
    int i = (int)d;
# 演算子
## インクリメント、デクリメント
    ++a,--aの前置とa++、a--の後置がある
    int x, a = 1;
    x = ++a; // aに1を足した後、代入され流のでxは2
    int y, b = 1;
    y = b++; // yにbを代入した後、bに1をたすのでyは1
# switch
    breakを忘れないように
- defaultでデフォルト値を設定
- case文は複数の条件を列挙できる(ex. case 3, case 4)
    public class HelloWorld {
        public static void main (String[] args) {
            int n = 2;

            switch (n) {
                case 1:
                    System.out.println("One!");
                    break;
                case 2:
                    System.out.println("Two!");
                    break;
                case 3:
                case 4:
                    System.out.println("Three! or Four!");
                    break;
                default:
                    System.out.println("None of these!");
                    break;
            }
        }
    }
# for
    public class HelloWorld {
        public static void main (String[] args) {
            for (int n = 0; n < 10; n++) {
                System.out.println(n);
            }
        }
    }
- continueでループをスキップ、breakはループから抜ける
    public class HelloWorld {
        public static void main (String[] args) {
            for (int n = 0; n < 10; n++) {
                if (n == 5) {
                    continue;
                }
                System.out.println(n);
            }
        }
    } // 0, 1, 2, 3, 4, 6, 7, 8, 9
    forを使ってすっきりと書くこともできる
    public class HelloWorld {
        public static void main (String[] args) {
            int sales[] = {10, 20, 30, 40};

            for (int sale : sales) {
                System.out.println(sales[i]);
            }
        }
    }
# メソッド
    returnで値を返す際にはその型をメソッド名の前につける
    public static String sayHi(String name) {
        return "Hi " + name;
    }
## 抽象メソッド
    abstractキーワードを使うと、メソッドの内容は未定だが、子クラスで宣言されるべき、という表明になる。

抽象メソッドを含むクラスは必ず抽象クラスでなければならない
抽象メソッドは子クラスで完成される必要がある（そうでない場合、子クラスは抽象クラスである必要がある）

    public abstract class Character {
        public abstract void attack(Matango m) {
        }
    }
# クラス
- メンバー変数：クラス内で使うデータ
- コンストラクタ：初期化処理
    class User {
        // member variables
        String name;
        String email;

        // Constructor
        User(String name) {
            this.name = name;
        }

        void sayHi() {
            System.out.println("Hi I'm "+this.name);
        }
    }

    public class HelloWorld {
        public static void main (String[] args) {
            User tom = new User("Tom");
            tom.sayHi(); // Hi I'm Tom
        }
    }
## 別コンストラクタの呼び出し

コンストラクタをオーバーロードする歳は別にコンストラクタを`this();`で呼び出す

    class User {
        String name;
        String email;

        User(String name, String email) {
            this.name = name;
            email = email;
        }

        User() {
            this("Example", "test@example.com");
        }
    }
## 継承

上のUserクラスを継承する。

    class SuperUser extends User {
        SuperUser(String name) {
            super(name); // 親クラスのコンストラクタを呼ぶ
        }

        // メソッドのオーバーライド
        void sayHi() {
            System.out.println("HIIIIIII!!! " + this.name);
        }
    }

オーバーライドはアノテーション`@Override`を記述しておくと、メソッド名や引数が間違っている場合にエラーになる

    @Override
    void sayHi() {
        //...
    }
## 抽象クラス

インスタンスを生成できないクラス(module)は`abstract`を使う

    public abstract class Character {
        String name;
        int hp;
        public abstract void attack(Matango m);
    }
# パッケージとアクセス修飾子
## アクセス修飾子

クラスやそのフィールド、メソッドに対してアクセス修飾子をつけることができる
変数のアクセス領域を制限する

- public : 自由にアクセスできる
- protected : クラスとその継承クラスでアクセスできる
- private : クラス内でしかアクセスできない
# getter、setter
    class User {
        private String name;
        private int score;

        public User(String name, int score) {
            this.name = name;
            this.score = score;
        }

        public int getScore() {
            return this.score;
        }

        public void setScore(int score) {
            if (score > 0) {
                this.score = score;
            }
        }
    }

    public class MyApp {
        public static void main(String[] args) {
            User tom = new User("Tom", 65);
            tom.setScore(80);
            tom.setScore(-1);
            System.out.println(tom.getScore());
        }
    }
# クラス変数・クラスメソッド
    static修飾子を使って、インスタンス化しなくてもクラスから直接扱えるフィールドやメソッドを定義できる（クラス変数・クラスメソッド）
    class User {
        private String name;
        private static int count = 0; // クラス変数

        public User(String name) {
            this.name = name;
            User.count++;
        }

        public static void getInfo() { // クラスメソッド
            System.out.println("# of instance " + User.count);
        }
    }

    public class MyApp {
        public static void main(String[] args) {
            User.getInfo();
            User tom = new User("Tom");
            User.getInfo();
            User bob = new User("Bob");
            User.getInfo();
        }
    }
# final修飾子

フィールドやメソッド、クラスを変更できなくする
変数なら再代入、クラスは継承、メソッドのオーバーライドなどを禁止する。
アクセス修飾子(`public`、`private`、`protected`)、`static`、`final`はどの順番で書いても構わないが、左記の順番で書かれることが慣習となっている

# インターフェース

クラスの機能を拡張するためにインターフェースを使う。定数、抽象メソッド、defaultメソッド、staticメソッドを書くことができる。
インターフェースに宣言されたメソッドは自動的に`public`かつ`abstract`になる（省略できる）
フィールドは、`public static final`のもの（定数）のみ定義できる。省略しても自動的に追加される。
通常メソッドの処理内容は書けないが、Java8では`default`キーワードを用いることで処理内容を追加できる。
クラスの継承と違い、インターフェースはクラスにいくつでも適用させることができる。

    interface Printable {
        double VERSION = 1.2;
        void print();
        // defaultメソッド
        public default void getInfo() {
            System.out.println("I/F ver. " + Printable.VERSION);
        }
    }

    class User implements Printable {
        @Override
        public void print() {
            System.out.println("Now printing user profile...");
        }
    }


    public class MyApp {
        public static void main(String[] args) {
            User tom = new User();
            tom.print();
            tom.getInfo();
        }
    }
# 列挙型

定数をまとめて扱いやすくする列挙型。

    enum Result {
        SUCCESS,
        ERROR
    }

    public class MyApp {
        public static void main(String[] args) {
            Result res;

            res = Result.ERROR;

            switch (res) {
                case SUCCESS:
                    System.out.println("OK");
                    break;
                case ERROR:
                    System.out.println("NG");
                    break;
            }
        }
    }
# 例外処理

例外が起こりそうな処理を`try`で囲み、例外を`catch`する、という形で例外処理を行う

    class MyException extends Exception {
        public MyException(String s) {
            super(s);
        }
    }

    public class MyApp {
        public static void div(int a, int b) {
            try {
                if (b < 0) {
                    throw new MyException("Not minus");
                }
                System.out.println(a / b);
            } catch (ArithmeticException e) {
                System.err.println(e.getMessage());
            } catch (MyException e) {
                System.err.println(e.getMessage());
            } finally {
                System.out.println("--- end ---");
            }
        }

        public static void main(String[] args) {
            div(3, 0);  // / by zero (0 除算のエラー)
            div(5, -2); // Not minus
        }
    }
# ジェネリクス

型を実行時に指定できる汎用化したメソッドを定義できる

    class MyData<T> {
        public void getThree(T x) {
            System.out.println(x);
            System.out.println(x);
            System.out.println(x);
        }
    }

    public class MyApp {
        public static void main(String[] args) {
            MyData<Integer> i = new MyData<>();
            MyData<String> s = new MyData<>();
            i.getThree(30);
            s.getThree("hello");
        }
    }
# 組み込みメソッド
## Math
- ceil : 切り上げ
- floor : 切り捨て
- round : 四捨五入
- 他にrandom()やPIなど
## Calendar

標準ライブラリではない

    import java.util.Calendar;

    public class HelloWorld {
        public static void main (String[] args) {
            Calendar cal = Calendar.getInstance();
            System.out.println(cal.get(Calendar.DATE)); // 現在時刻
            cal.set(2011, 4, 12, 3, 22);
            System.out.println(cal.get(Calendar.DATE)); // 12
            cal.add(Calendar.DATE, 5);
            System.out.println(cal.get(Calendar.DATE)); //17
        }
    }