変数

プリミティブ変数
型 ビット数
byte 8
short 16
int 32
long 64
float 32
double 64

プリミティブ変数のデフォルト値は 0 (0.0) です。


10進数
int cnt = 7;
int cnt = 7,2 （カンマを使っているのでコンパイルエラー）


8進数
先頭に 0 をつける
int seven = 07; （10進数の7）
int eight = 010; （10進数の8）
int nine = 011; （10進数の9）


16進数
先頭に 0x をつける
10進数の 1～15 までは0 1 2 3 4 5 6 7 8 9 a b c d e fで表す。
アルファベットは大文字小文字の区別なし。


サフィックス
double d = 1.2d;
float f = 1.2f;
long l = 100000l;

boolean 型と char 型

boolean 型

true か false を格納
デフォルト値は false

if 文の条件になる
(例）
if (1 < 10) {};


char 型

1つの文字、Unicode、16ビット符号なし整数（65535以下の正の整数）が使用できる。
（例）
char name = '円';
char name = '\u004F';

デフォルト値は \u0000

String 型

String 型はダブルクウォーテーションで囲む。
String 型は他のクラスと違いダブルクウォーテーションで囲む方法でインスタンスを生成できる。
その後同じ名前をダブルクウォーテーションで囲んで違う変数名で宣言した場合、すでにプールに納められている同じ文字を格納する String 型インスタンスが使われます。これは他のクラスにはない特殊な例です。

＜サンプル＞
String name1 = "Albert";
String name2 = new String("Albert");
String name3 = "Albert";

System.out.println(name1 == name2);
System.out.println(name1 == name3);
System.out.println(name1 == name3);

＜出力結果＞
false
true
false

キャスト

拡張変換
byte → short → int → long → float → double のような変換はキャスト不要

int intValue = 27;
double doubleValue = intValue

縮小変換
double doubleValue = 27.0;
int intValue = (int)doubleValue;

１次元配列

配列の宣言
要素数を必ず宣言して初期化する。
各要素は0で初期化される。
int[] myArray = new int[3];

宣言と代入
int[] myArray = {1, 2, 3};

配列はオブジェクトとして扱われる
Integer[] myArray = new Integer[3];
配列はオブジェクトとして扱われているが、Interger クラスのコンストラクタは呼び出されず、各要素は null で初期化される。

＜サンプル＞
Integer[] myArray = new Integer[3];
System.out.println(myArray[2]);

＜出力結果＞
null

２次元配列

２次元配列は１次元配列の各要素にさらに１次元配列が収められています。

２次元配列の初期化
int[][] myArray = new int[3][];
２次元配列の最初の要素数を指定して初期化します。
各要素は null で初期化されます。

値の代入
int[][] myArray = new int[2][2];
myArray[0][0] = 1;
...
myArray[1][1] = 4;

int[][] myArray = new int[2][];
myArray[0] = {1, 2};
myArray[1] = {3, 4};

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

オブジェクト参照変数

オブジェクト参照変数
＜サンプル＞
public class Sample {
   public static void main(String[] args) {
      Sub objSub = new Sub();
      Super objSup = objSub;
   }
}
class Super { }
class Sub extends Super { }

objSub, objSup はオブジェクト参照変数です。メモリー上にあるインスタンスを参照する変数（オブジェクト）です。

インスタンス変数

クラスのメソッドの外側で宣言した変数はインスタンス変数としてオブジェクト参照変数からアクセスできます。
インスタンス変数は自動で初期化されます。
＜サンプル＞
public class Sample {
   public static void main(String[] args) {
      Sub objSub = new Sub();
      Super objSup = objSub;
      System.out.println(objSub.x);
      System.out.println(objSup.x);
   }
}
class Super {int x;}
class Sub extends Super {int x;}

クラス変数

インスタンス変数と同じ位置（メソッドの外側）で static 修飾子で宣言されている静的変数はクラス変数といいます。
クラス変数へのアクセス
クラス変数は自動で初期化されます。

＜サンプル＞
public class Sample {
public static void main(String[] args) {
System.out.println(Suub.x);
System.out.println(Super.x);
}
}
class Super {static int x;}
class Sub extends Super {static int x;}

ローカル変数

自動で初期化されないので初期値を代入する必要があります。
初期化しないまま使用するとコンパイルエラーになります。

int x = 0;
System.out.println(x);

配列の初期化の場合は要素数を決める必要があります。値の代入がなくてもコンパイルエラーにはなりません。

Integer[] myArray = new Integer[3];
System.out.println(myArray[2]);

Java 予約語

変数名、メソッド名などに Java 予約語は使用できません。

Java 予約語一覧
abstract
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
extends
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
try
void
volatile
while
assert

アクセス修飾子

public : このメンバーにはどこからでもアクセスできる。
protected : このメンバーにはパッケージ外のサブクラスからでもアクセスできる。
修飾子なし（デフォルト） : このメンバーには同一パッケージ内からアクセスできる。
private : 同一クラス内からのみアクセスできる。

ローカル変数にアクセス修飾子は使用できない。

クラスの構造

＜サンプル＞
package sample;
import java.util.*;

public class MyClass {
    int x;
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.func1();
    }
    void func1() {
        System.out.println(func2());
    }
    int func2() {
        return 100;
    }
}

パッケージの宣言
クラスはパッケージで管理することが推奨されています。

インポート宣言
Java のクラスライブラリで java.lang パッケージ以外のライブラリはインポートする必要があります。
java.util.*; とすると java.util パッケージのすべてのインターフェース、クラスのインポートを宣言します。
java.util.Date; とすると java.util.Date クラスのインポートを宣言します。

main メソッド
Java プログラムは main メソッドからスレッドがスタートします。
main メソッドは
public static void main(String[] args)
というシグネチャですが args の部分は任意です。

main メソッドなどの静的メソッド（static メソッド）から自クラスの動的メソッドを呼び出す場合、自クラスのインスタンス（参照変数）から呼び出す必要があります。
（例）
MyClass obj = new MyClass();
obj.func1();

自クラスの動的メソッドから動的メソッドを呼び出す場合は、メソッド名を記述するだけです。
（例）
void func1() {
    func2();
}

final クラスと abstract クラス

final で修飾されたクラス
・継承（拡張）することができないのでサブクラスを作成できない。
・したがってどのメソッドもオーバーライドできない。

String クラスなどは final クラスです。

abstract クラス（抽象クラス）

abstract で修飾されたクラス
・インスタンス化できない。
・継承されることを目的とする
・abstract メソッド（抽象メソッド）を含むクラスは必ず abstract クラス（抽象クラス）である必要がある。
・抽象クラスに非抽象メソッドを含めることはできる。

＜サンプル＞
public class Sample {
    public static void main(String[] args) {
        Super obj = new Sub();
        obj.func();
    }
}
abstract class Super {
    abstract void func();
}
class Sub extends Super {
    @Override
    void func() {}
}

インターフェース

インターフェースの目的は抽象クラスと似ていますがすべてのメソッドが abstract です。
インターフェースのメソッドは中身を実装しません。したがってインターフェースの役割は、それを実装するクラスの方向性を定め柔軟な設計を可能にすると言うことができます。

インターフェースの変数
public static final でなければならい。省略は可能でコンパイラが補足する。
インターフェースの変数は「定数」として利用できる。

インターフェースのメソッド
public abstract でなければならない。省略は可能でコンパイラが補足する。

インターフェースの定義
interface で定義します。

インターフェースの実装
implements で定義します。
複数のインターフェースを実装できます。


インターフェースは他のインターフェースを継承できます。
インターフェースAを継承するインターフェースαを実装しているサブクラスはインターフェースαのメソッドだけでなくインターフェースAのメソッドも実装しなければならない。


＜サンプル＞

interface Human {
    void speak();
}
class Japanese implements Human{
    public void speak() {
        System.out.println("こんにちは");
    }
}
class English implements Human {
    public void speak() {
        System.out.println("Hello");
    }
}
public class Sample {
    public static void main(String[] args) {
        Human person1 = new Japanese();
        Human person2 = new English();
        person1.speak();
        person2.speak();
    }
}

＜出力結果＞
こんにちは
Hello


Human クラスを実装（implements)するサブクラスは必ず speak メソッドを実装しなければなりせん。
Human インターフェースを実装することで Japanese クラス、English クラスは同じ特性を持つことになります。

person1.speak();
person2.speak();
ではそれぞれ Japanese クラスと English クラスでオーバーライドされた speak メソッドが呼び出されています。
これは「多様性」といいます。

演算子

代入演算子

x = y     (x に y を代入)
x += y　     (x = x + y)
x -= y     (x = x - y)
x *= y     (x = x * y)
x /= y     (x = x / y)
x %= y     (x = x % y)

インクリメント・デクリメント

x++     (x = x + 1)     x を利用してからインクリメント
x--     (x = x - 1)     x を利用してからデクリメント
++x     (x = x + 1)     x をインクリメントしてから利用
--x     (x = x - 1)     x をデクリメントしてから利用


論理演算子

x & y     x と y が true の場合 true を返す
x y     x か y のとちらかが true の場合 true を返す
x ^ y     排他的論理輪
!x     x でない場合 true を返す
x && y     x と y が true の場合 true を返す
            左辺が false の場合右辺を評価しない
x y     x と yの どちらかが true の場合 true を返す
            左辺が true の場合右辺を評価しない

文字列連結演算子

String s1 = "Hello " + "world"; (Hello world)
String s2 = "Hello " + 100; (Hello 100)
どちらか片方が String の場合 + 演算子は文字列連結演算子となる。


ビットシフト演算子

x >> n     x を２の n 乗で割る（右に n ビットシフト）
x << n     x に２の n 乗を掛ける（左に n ビットシフト）　
x >>> n     右に n ビットシフトして最初の符号を 0 にする

＜サンプル＞
public class Sample {
    public static void main(String[] args) {
        int a = 0;
        int b = 0;
        for (int i = 0; i < 5; i++) {
            if ((++a < 2) && (++b < 2)) {
                a++;
            }
        }
        System.out.println("a = " + a + " b = " + b);
    }
}
＜出力結果＞
a = 6 b = 3

if 文

if else

if (x == y) {
System.out.println("Hello");
} else {
System.out.println("こんにちは");
}

if 文条件判断結果は boolean 型でなければならない。

if (x = y) { } なら条件判断は行わず代入が行われる。（代入演算子）

if - else if - else

else if を使うと条件分岐を増やすことができる。

if (x == y) {
...
} else if (x == z) {
...
} else {
...
}

if 文のボディを表す { } の中に実行文が１行しかない場合は { } は省略できます。
しかし、可読性が落ちることは確かです。

if (x == y) {
a = b;
}
System.out.println("Hello");

上記と同じ
if (x == y)
a = b;
System.out.println("Hello");

switch 文

int number = 7;
switch (number) {
case 2:
    System.out.println("小吉");
    break;
case 5:
    System.out.println("中吉");
    break;
case 7:
    System.out.println("大吉");
    break;
default:
    System.out.println("吉");
}

条件判断には int 型か int 型に拡張変換できる型(byte, short, char)のみ使用できます。

break キーワードがないとすべてのケースの実行文が実行されます。

default 文の位置は最後でなくてもいいです。

while ループ

int a = 0;
while (a < 10) {
.....
}

a が 10 未満の間繰り返し処理を行う。

int a = 0;
do {
.....
} while (a < 10);

最初に実行文を１回実行してからループする。
int a = 10 からスタートしたとしても実行文は１回実行される。

for ループ

for (int i = 0; i < 10; i++) {
    ...
}

i が 10 未満の間だけ繰り返し処理を行う。
for (宣言; 条件; 処理) {
    処理
}

for の（）の中の処理はボディの処理が終わってから実行される

ネスト
ループの中のループ

for (int i = 0; i < 5; i++) {
    for (int j = 0; j < i; j++) {
        .....
    }
}