最初に知っておくべきJavaの基本文法

## はじめに
この記事は以下のような方が読まれることを想定しています。

* 今度実務でJavaを使うことになったが、Javaなんて学生時代にやって以来忘れてしまった。
* C言語など他言語のプログラミング経験はあるが、Javaは初めてだ。
* オブジェクト指向よりも基本的な文法を復習したい。

## mainメソッドを書いて動かしてみよう
サイトや本を読むだけでは理解は進みません。
自分でコードを書いて、プログラムを動かすことがとても大事です。

### 1. mainメソッドのポイント
- mainメソッドは、何か１つのクラス(例：Sample1)に必ず属さないといけない。
- アクセス修飾子publicは、「どこからでも呼び出せる」という意味。
    - Javaのメイン関数は public と決まっている。
- staticは、クラスのインスタンス化せずにmainメソッドを呼び出すために付けます。
- 戻り値はvoid、つまりmainメソッドは何も返さないという意味。
- mainの括弧の中に書いた「String[] args」
    - String[]はStringの配列という意味
    - Stringは文字列を格納するための型。参照型に分類されるもの。
    - argsは引数名。コマンドライン引数で渡された値をプログラム内で使うことができる。
- クラスやメソッドは {} で括る。
- System.out.print()で標準出力する。
- 実行文は ; で終わる。
- // はコメント行。プログラム実行時には無視される。

### プログラム例
```java:Sample1.java
public class Sample1 {
    public static void main(String[] args){
        // ここで標準出力する
        System.out.print("hello world");
    }
}
```
### 2. プログラムを実行
- ファイル名（Sample1.java）、クラス名（Sample1）を同じにする。
- プログラム実行は「java Sample1 **.class**」ではないことに注意。
- プログラム実行後、mainメソッドが最初に実行される。

#### 実行例
```
> javac Sample1.java  # コンパイル
> java Sample1        # プログラム実行

hello world　　　　  　# 実行結果
```


## リテラル
### ポイント
- リテラルとは、文字や数値といった値そのもののこと。

### プログラム例
```java:Sample2.java
public class Sample2 {
    public static void main(String[] args){
        // 1. 文字リテラル
    	System.out.println('A');
    	
    	char c1 = 'B';
    	System.out.println(c1);     // 変数

    	//System.out.println('AB');  // コンパイルエラー
    	
    	System.out.println('\u0041');// 文字コード指定
    	
    	// 2. 文字列リテラル
    	System.out.println("Hello");
    	
    	String str = "123";
    	System.out.println(str);
    	
    	// 補足: エスケープシーケンス
    	System.out.println("Hello\nWorld!!");
    	
    	// 3. 整数リテラル(10進数)
    	int i = 123;
    	System.out.println(i);
    	System.out.println(i+100);
    	
    	// 4. 浮動小数点数リテラル
    	double d = 3.14;
    	System.out.println(d);
    	System.out.println(d+1.54);
    	d = 2.712e-4;
    	System.out.println(d);
    	
    	// 5. 論理値リテラル
    	boolean b = true;
    	System.out.println(b);
    	b = (10 == 5);
    	System.out.println(b);
    	
    }
}
```

## 演算子
### ポイント
- 算術演算子（+, -, *, / など）
- 代入演算子
- 比較演算子
- 論理演算子
- ビット演算子
- 演算子の優先順位

### プログラム例
```java:Sample3.java
import java.util.Arrays;  // 配列の中身を表示するため

public class Sample3 {
    public static void main(String[] args){
    	System.out.println("======= 1. 算術演算子 =======");
    	// 1.1 インクリメント
    	int a = 10;
    	int b = a++;            // 代入後にインクリメント
    	System.out.println(b);  // int b = a;
    	                        // a = a + 1;
    	                        // と同じ
    	
    	int x = 10;
    	int y = ++x;            // 代入前にインクリメント
    	System.out.println(y);  // x = x + 1;
    	                        // int y = x;
    	                        // と同じ
    	
    	// 1.2 文字列の連結
    	String str1 = "Hello " + "World";
    	System.out.println(str1);
    	
    	System.out.println("======= 2. 代入演算子 =======");
    	// 2.1 代入（プリミティブ型）
		int x2 = 10;
		int y2 = x2;
		y2 += 1;
		System.out.println(x2);  // 結果：10
		System.out.println(y2);  // 結果：11
    	
    	// 2.2 代入（参照型）
		int[] x3 = { 10, 20, 30 };
		int[] y3 = x3;
		y3[0] += 1;
		System.out.println(Arrays.toString(x3)); // 結果：[11, 20, 30]、x[0]の値も変わることに注意!!
		System.out.println(Arrays.toString(y3)); // 結果：[11, 20, 30]
    	
    	System.out.println("======= 3. 比較演算子 =======");
    	// 3.1 数値の比較(基本型, 参照型)
		int[] x4 = { 1, 2, 3 };
		int[] y4 = { 1, 2, 3 };
    	System.out.println(x4[0] == y4[0]);			// 基本型の比較 （結果：true）    	
    	System.out.println(x4 == y4); 				// 参照型の比較1（結果：false）   
    	System.out.println(Arrays.equals(x4, y4)); 	// 参照型の比較2（結果：true）   
    	
    	// 3.2 文字列の比較
    	String str2 = "abc";
    	String str3 = "ab";
    	str3 += "c";
    	System.out.println(str2==str3); 		// 結果：false
    	System.out.println(str2.equals(str3));	// 結果：true
    	
    	System.out.println("======= 4. 論理演算子 =======");
    	System.out.println("======= 5. ビット演算子 =======");
    }
}
```
## 変数宣言
### ポイント
- 変数宣言と初期化を別々にやる記述と、同時にやる記述がある。

### 別々にやる記述の例
```java:Sample5.java
public class Sample5 {
    public static void main(String[] args){
    	// 1. 変数宣言
    	// [書式] データ型名 変数名;
    	int idata;
    	String str;
    	
    	// 2. 値の代入
    	// [書式] 変数名 = 値;
    	idata = 100;
    	str = "abcdef";
    	
    	// 代入は「==」ではないことに注意！
    	// idata == 100;はコンパイルエラーになる
    	
    }
}
```

### 同時にやる記述の例
```java:Sample6.java
public class Sample6 {
    public static void main(String[] args){
    	// 1. 変数宣言と値の代入
    	// [書式] データ型名 変数名 = 値;
    	int idata = 100;
    	String str = "abcdef";
    }
}
```


## プリミティブ型（基本データ型）
### ポイント
- プリミティブ型とは、Javaの基本となる変数の型。
- 後述の「参照型」と区別される。
- プリミティブ型の8種類
    - 整数
        - byte型
            - 8ビット（1バイト）のデータ
            - -128～127の整数
        - short型
            - 16ビットのデータ
            - -32768から32767までの整数
        - int型
            - 32ビットのデータ
            - -2147483648から2147483647までの整数値
        - long型
            - 64ビットのデータ
            - -9223372036854775808から9223372036854775807までの整数値
    - 浮動小数点数
        - float型
            - 32ビットの単精度浮動小数点数
            - 有効桁数は6桁
        - double型
            - 64ビットの倍精度浮動小数点数
            - 有効桁数は15桁
    - 論理型
        - boolean型
            - 真偽値(trueかfalse)
    - 文字
        - char型
            - 16ビットのUNICODE文字1文字
            - 実際は、16ビットの符号なし整数(文字コード)を格納する

### プログラム例
```java:Sample4.java
public class Sample4 {
    public static void main(String[] args){
    	System.out.println("======= 1. byte型 =======");
    	byte b1 = 127;
    	System.out.println(b1);		
    	b1 += 1;
    	System.out.println(b1);		// -128になってしまう（オーバーフロー）
    	
    	System.out.println("======= 2. short型 =======");
    	short s1 = -32768;
    	System.out.println(s1);		
    	s1 -= 1;
    	System.out.println(s1);		// 32767になってしまう（オーバーフロー）
    	
    	System.out.println("======= 3. int型 =======");
    	int i1 = s1;
    	i1 += 1;
    	System.out.println(i1);		// 32768(正しい)
    	
    	System.out.println("======= 4. long型 =======");
    	//long l1 = 9223372036854775807; 	// コンパイルエラー
    	long l1 = 9223372036854775807L;		// 正しい
    	System.out.println(l1);
    	
    	System.out.println("======= 5. float型 =======");
    	//float f1 = 3.14; 	// コンパイルエラー
    	float f1 = 3.14F; 	// 正しい
    	System.out.println(f1);
    	
    	System.out.println("======= 6. double型 =======");
    	double d1 = 3.14; 
    	d1 = d1 + 5.2e3;
    	System.out.println(d1);

    	System.out.println("======= 7. boolean型 =======");
    	boolean bl1 = true;
    	System.out.println(bl1);
    	bl1 = (d1 < 3);				// d1は3より大きいので、演算結果はfalse
    	System.out.println(bl1);
    	
    	System.out.println("======= 8. char型 =======");
    	char c1 = 'a';
    	char c2 = 'あ';
    	//char c3 = "ab";		// コンパイルエラー: 文字列は格納できない
    	System.out.println(c1);
    	System.out.println(c2);
    }
}
```

## 参照型
### ポイント
- Javaは、プリミティブ型以外の変数の型は「参照型」と分類される。
- 参照型の代表例は「String」

### プログラム例
```java:Sample7.java
public class Sample7 {
    public static void main(String[] args){
    	String str = "Hello";	// 文字列は "(ダブルクォーテーション)で括る
    	
    	str += "World!!";
    	
    	System.out.println(str);// "HelloWorld!!"と表示
    	
    }
}
```
## プリミティブ型と参照型の違いは？
### ポイント
- どちらも「変数の型」を表すもの。
- 違いは「変数に入れる値」。
    - プリミティブ型は、変数には「値」そのものを入れている。
        - 整数ならば100, 200, 0など
        - 文字ならば’a’, 'あ'など
        - 論理型ならtrue, false
    - 参照型は、変数には「メモリのアドレス値（値が入っているメモリの場所）」を入れている。
        - 文字列型Stringならば、文字列"abcdef"があるアドレス値（1000番地など）

### プログラム例
```java:Sample8.java
public class Sample8 {
    public static void main(String[] args){
    	// プリミティブ型
		int x = 10;
		int y = x;
    	
    	// 参照型
		String s1 = "abc";
		String s2 = s1;
    }
}
```
### プリミティブ型の変数に入っているものは「値」そのもの
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/409243/2e2c849a-5768-5fc5-ef19-ab7489f652ca.png)

### 参照型の変数に入っているものは「メモリのアドレス値」
1000番地には文字列"abc"が入っている。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/409243/ee7dc198-82f4-0af5-fbe8-1f017eece13d.png)

## 配列
### プログラム例１
```java:Sample9.java
public class Sample9 {
    public static void main(String[] args){
    	// 1. 配列の変数宣言
    	// [書式] データ型名[] 配列名;
    	int[] ai;
    	String[] as;
    	
    	// 2. 配列の領域確保
    	// [書式] 配列名 = new 型名[要素数];
    	ai = new int[5];
    	as = new String[10];
    	
    	// 3. 配列の初期化
    	// [書式] 配列名[要素番号] = 初期値;
    	// 注意：要素番号は「0」から始まる
    	ai[0] = 1;
    	ai[1] = 2;
    	as[0] = "abc";
    	as[1] = "defg";
    }
}
```

### プログラム例２
```java:Sample10.java
public class Sample10 {
    public static void main(String[] args){
    	// 方法１：配列の変数宣言と領域確保を１つにまとめる
    	// [書式] データ型名[] 配列名 = new 型名[要素数];
    	int[] ai1 = new int[5];
    	String[] as1 = new String[10];
    	
    	// 方法２：配列の変数宣言, 領域確保, 初期化を１つにまとめる
    	// [書式] データ型名[] 配列名 = {初期値1, 初期値2, ・・・};
    	int[] ai2 = {1, 2, 3};
    	String[] as2 = {"abc", "de", "fghij"};
    }
}
```
## プログラミングの三大要素って知っていますか？

* 順次処理（逐次処理）
* 条件分岐
* 繰り返し処理（反復処理）

Javaに限らず、全プログラミング言語で共通する重要な概念です。

### 1. 順次処理（逐次処理）
プログラムの上（先頭）から下（末尾）に処理が順番に実行されること。

#### プログラム例１
```java:Sample12.java
public class Sample12 {
    public static void main(String[] args){
    	// 実行結果は、何度やっても「1, 2, 3, 4, 5」の順番で表示される
    	System.out.println("1"); 
    	System.out.println("2"); 
    	System.out.println("3"); 
    	System.out.println("4"); 
    	System.out.println("5"); 
    }
}
```
#### プログラム例２
```java:Sample13.java
public class Sample13 {
    public static void main(String[] args){
    	// メソッドを呼び出しても同じ。
    	// 実行結果は、何度やっても「1, 2, 3, 4, 5」の順番で表示される。
    	System.out.println("1"); 
    	sub();
    	System.out.println("5"); 
    }
	
	public static void sub(){
    	System.out.println("2"); 
    	System.out.println("3"); 
    	System.out.println("4"); 
	}
}
```
### 2. 条件分岐
いわゆるif文やswitch文のこと。
ある条件に当てはまるときと当てはまらないときで、別々の処理をさせたいときなど、プログラムの流れを変えるときに使う。

#### プログラム例
```java:Sample14.java
// 実行結果
// iは偶数です。
// jは奇数です。
// kは偶数、かつ10以下。
// ニ
public class Sample14 {
    public static void main(String[] args){
    	int i = 10;
    	int j = 9;
    	int k = 8;
    	int l = 2;
    	
    	// 1.1 if文
    	if(i % 2 == 0){
    		System.out.println("iは偶数です。"); 
    	}
    	
    	// 1.2 if-else文
    	if(j % 2 == 0){
    		System.out.println("jは偶数です。"); 
    	}else{
    		System.out.println("jは奇数です。"); 
    	}
    	
    	// 1.3 if-elseif文
    	if(k % 2 == 0 && k > 10){
    		System.out.println("kは偶数、かつ10より大きい。"); 
    	}else if(k % 2 == 0 && k <= 10){
    		System.out.println("kは偶数、かつ10以下。"); 
    	}else{
    		System.out.println("kは奇数です。"); 
    	}
    	
    	// 2 switch文
    	switch (l){
    	case 0:
    		System.out.println("ゼロ"); 
    		break;
    	case 1:
    		System.out.println("イチ"); 
    		break;
    	case 2:
    		System.out.println("ニ"); 
    		break;
    	default:
    		System.out.println("その他"); 
    		break;
    	}
    }
}
```

### 3. 繰り返し処理（反復処理）
いわゆるfor文やwhile文のこと。
ある処理を繰り返すときに使う。

#### プログラム例
```java:Sample15.java
// 実行結果
//  [100, 100, 100, 100, 100, 100, 100, 100, 100, 100]
//  [200, 200, 200, 200, 200, 200, 200, 200, 200, 200]
//  [300, 300, 300, 300, 300, 300, 300, 300, 300, 300]
import java.util.Arrays;

public class Sample15 {
    public static void main(String[] args){
    	int[] ai = new int[10];
    	
    	// 1. for文：配列の全要素に 100 を設定
    	for(int i = 0; i < ai.length; i++){
    		ai[i] = 100;
    	}
    	System.out.println(Arrays.toString(ai)); 
    	
    	// 2. while文：配列の全要素に 200 を設定
    	int j = 0;
    	while(j < ai.length){
    		ai[j] = 200;
    		j += 1;
    	}
    	System.out.println(Arrays.toString(ai)); 
    	
    	// 番外編 もちろん. 繰り返し処理を使わない方法もあるが、効率が悪い
    	ai[0] = 300;
    	ai[1] = 300;
    	ai[2] = 300;
    	ai[3] = 300;
    	ai[4] = 300;
    	ai[5] = 300;
    	ai[6] = 300;
    	ai[7] = 300;
    	ai[8] = 300;
    	ai[9] = 300;
    	System.out.println(Arrays.toString(ai)); 
    }
}
```

## メソッドを作る
### ポイント
- メソッド（関数）とは、処理をまとめたもの。
- 複数箇所で同じ処理をする場合など、その処理を１つのメソッドで定義する。
- メソッドは「クラスメソッド」と「インスタンスメソッド」の2つがある。まずはクラスメソッドから取り上げる。
    - アクセス修飾子：public, privateなど
    - static：必須
    - 戻り値：メソッドの呼び出し元に返す値の型（何も返さないときはvoid）
    - 仮引数：メソッドに渡す値（何も渡さないときは省略）

### クラスメソッドの宣言
```
アクセス修飾子 static 戻り値 メソッド名(仮引数) {
  メソッドの処理;
　　　：
}
```

### プログラム例
```java:Sample11.java
import java.util.Arrays;  // 配列の中身を表示するために必要
public class Sample11 {
    public static void main(String[] args){
    	int[] ai = new int[5];
    	
    	// メソッドを呼び出すときは値（実引数）を渡す
    	// 下の場合、実引数は「ai」と「0」です。
    	setArray(ai, 0);
    	System.out.println(Arrays.toString(ai)); // 結果：[0, 0, 0, 0, 0]

    	setArray(ai, 100);
    	System.out.println(Arrays.toString(ai)); // 結果：[100, 100, 100, 100, 100]
    }
	
	// 指定した値を配列に設定するためのメソッド
	//    引数(仮引数)     int[] array  値を設定する配列
	//                    int   val    値
	//    戻り値(復帰値)   なし
	public static void setArray(int[] array, int val){
		for(int i = 0; i < array.length; i++){
			array[i] = val;
		}
	}
}
```
















## リファレンス

* Javaの実行に欠かせないmainメソッド、その仕組みからしっかり解説
https://engineer-club.jp/java-main