[備忘録 その３] Java Silver ～変数と配列 その１～

# 変数
## リテラル
リテラルとは、プログラムのなかで直接記述される値のことです。リテラルは具体的な値を表し、変数や定数に代入されたり、計算や比較に使用されたりします。
### 1\.整数リテラル
整数リテラルは、整数値を表します。デフォルトでは'int'型として扱われますが、'long'型として扱いたい場合は、末尾に'L'または'l'を付けます。
```java
int decimal = 10; // 10進数
int octal = 012;  // 8進数（10進数で10）
int hex = 0xA;    // 16進数（10進数で10）
int binary = 0b1010; // 2進数（10進数で10）

long longValue = 10L; // long型
```
### 2\.浮動小数点リテラル
浮動小数点リテラルは、小数点を含む数値を表します。デフォルトでは'double'型として扱われますが、'float'型として扱いたい場合は末尾に'F'または'f'を付けます。
```java
double doubleValue = 3.14;
float floatValue = 3.14F;
```
### 3\.文字リテラル
文字リテラルは、単一の文字を表します。単一引用符(')で囲まれた1文字が文字リテラルとなります。
```java
char charValue = 'A';
char escapeChar = '\n'; // エスケープシーケンス（改行）
```
### 4\.文字列リテラル
文字列リテラルは、一連の文字を表します。二重引用符(")で囲まれた文字列が文字列リテラルとなります。
```java
String stringValue = "Hello, World!";
```
### 5\.ブーリアンリテラル
ブーリアンリテラルは'true'または'false'の値を表します。
```java
String stringValue = "Hello, World!";
```
### 5\.NULLリテラル
'NULL'リテラルは、オブジェクトが参照を持たないことを示します。
```java
String nullString = null;
```
### 5\.配列リテラル
javaでは、配列リテラルを使って配列を初期化できます。配列リテラルは中括弧'{}'で囲まれたカンマ区切りの要素のリストです、
```java
int[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"one", "two", "three"};
```

### リテラルの例
```java
public class LiteralExample {
    public static void main(String[] args) {
        // 整数リテラル
        int decimal = 10;
        int octal = 012; // 10進数で10
        int hex = 0xA; // 10進数で10
        int binary = 0b1010; // 10進数で10
        long longValue = 10L;

        // 浮動小数点リテラル
        double doubleValue = 3.14;
        float floatValue = 3.14F;

        // 文字リテラル
        char charValue = 'A';
        char escapeChar = '\n'; // 改行

        // 文字列リテラル
        String stringValue = "Hello, World!";

        // ブーリアンリテラル
        boolean isTrue = true;
        boolean isFalse = false;

        // nullリテラル
        String nullString = null;

        // 配列リテラル
        int[] intArray = {1, 2, 3, 4, 5};
        String[] stringArray = {"one", "two", "three"};

        // リテラルの出力
        System.out.println("整数リテラル: " + decimal + ", " + octal + ", " + hex + ", " + binary + ", " + longValue);
        System.out.println("浮動小数点リテラル: " + doubleValue + ", " + floatValue);
        System.out.println("文字リテラル: " + charValue + ", " + (int)escapeChar);
        System.out.println("文字列リテラル: " + stringValue);
        System.out.println("ブーリアンリテラル: " + isTrue + ", " + isFalse);
        System.out.println("nullリテラル: " + nullString);
        System.out.print("配列リテラル: ");
        for (int i : intArray) {
            System.out.print(i + " ");
        }
        System.out.println();
        for (String str : stringArray) {
            System.out.print(str + " ");
        }
    }
}

```

## エスケープシーケンス一覧
Javaには、Unicodeエスケープシーケンス以外にも、文字列や文字リテラル内で特定の特殊文字を表現するエスケープシーケンスがいくつかあります。
### 1\.改行('\n')
改行を表します。
```java
String newLine = "Hello\nWorld!";
System.out.println(newLine);
// 出力:
// Hello
// World!

```
### 2\.復帰('\r')
キャリッジリターン(復帰)を表します。
```java
String carriageReturn = "Hello\rWorld!";
System.out.println(carriageReturn);
// 出力:
// World!

```
### 3\.タブ('\t')
水平タブを表します。
```java
String tab = "Hello\tWorld!";
System.out.println(tab);
// 出力:
// Hello   World!

```
### 4\.バックスペース('\b')
バックスペースを表します。
```java
String backspace = "Hello\bWorld!";
System.out.println(backspace);
// 出力:
// HellWorld!

```
### 5\.フォームフィード('\f')
フォームフィードを表します。これはページ区切りを示しますが、コンソールでの出力にはほどんど影響しません。
```java
String formFeed = "Hello\fWorld!";
System.out.println(formFeed);
// 出力:
// HelloWorld!

```
### 6\.シングルクォート('\'')
シングルクォート(単一引用符)を表します。
```java
String formFeed = "Hello\fWorld!";
System.out.println(formFeed);
// 出力:
// HelloWorld!

```
### 7\.ダブルクォート('\"')
ダブルクォート(二重引用符)を表します。
```java
String doubleQuote = "He said, \"Hello!\"";
System.out.println(doubleQuote);
// 出力:
// He said, "Hello!"

```
### 8\.バックスラッシュ('\\')
バックスラッシュ自体を表します。
```java
String backslash = "This is a backslash: \\";
System.out.println(backslash);
// 出力:
// This is a backslash: \
```

### エスケープシーケンスの例
以下に、これらのエスケープシーケンスを使った例を示します。
```java
public class EscapeSequenceExample {
    public static void main(String[] args) {
        // 改行
        String newLine = "Hello\nWorld!";
        System.out.println(newLine);

        // 復帰
        String carriageReturn = "Hello\rWorld!";
        System.out.println(carriageReturn);

        // タブ
        String tab = "Hello\tWorld!";
        System.out.println(tab);

        // バックスペース
        String backspace = "Hello\bWorld!";
        System.out.println(backspace);

        // フォームフィード
        String formFeed = "Hello\fWorld!";
        System.out.println(formFeed);

        // シングルクォート
        String singleQuote = "He said, \'Hello!\'";
        System.out.println(singleQuote);

        // ダブルクォート
        String doubleQuote = "He said, \"Hello!\"";
        System.out.println(doubleQuote);

        // バックスラッシュ
        String backslash = "This is a backslash: \\";
        System.out.println(backslash);
    }
}


```

## _(アンダースコア)がある数値リテラル
Java 7以降では、数値リテラルにアンダースコア('_')を含めることができます。
アンダースコアは桁区切りとして使われ、数値の可読性を向上させます。これは数値の値には影響しませんが、視覚的に数値を読みやすくするのに役立ちます。

### 1\.整数リテラル
```java
int oneMillion = 1_000_000; // 1,000,000
int creditCardNumber = 1234_5678_9012_3456; // 1234 5678 9012 3456
int socialSecurityNumber = 999_99_9999; // 999-99-9999
int hexBytes = 0xFF_EC_DE_5E; // 0xFFECDE5E
int binaryBytes = 0b11010010_01101001_10010100_10010010; // 二進数

```
### 2\.浮動小数点リテラル
```java
double pi = 3.14_15_92_65_35_89; // 3.141592653589
double avogadroNumber = 6.022_140_857_747_474e23; // 6.022140857747474E23
double balance = 1_000.00; // 1,000.00

```
### 3\.長整数リテラル
```java
long creditCardNumberLong = 1234_5678_9012_3456L; // 1234 5678 9012 3456

```
### 注意点
アンダースコアは数値の先頭または末尾、連続する場所、小数点の前後、指数部の前後にはおけません。
```java
int x1 = _1000; // 無効
int x2 = 1000_; // 無効
int x3 = 1__000; // 無効
float x4 = 3._1415F; // 無効
float x5 = 3_.1415F; // 無効
float x6 = 3.14_15_F; // 無効

```

### アンダースコアの使用例
いかに、アンダースコアを使った数値リテラルの例を示します。
```java
public class UnderscoreInNumericLiterals {
    public static void main(String[] args) {
        int oneMillion = 1_000_000;
        int creditCardNumber = 1234_5678_9012_3456;
        int socialSecurityNumber = 999_99_9999;
        int hexBytes = 0xFF_EC_DE_5E;
        int binaryBytes = 0b11010010_01101001_10010100_10010010;

        double pi = 3.14_15_92_65_35_89;
        double avogadroNumber = 6.022_140_857_747_474e23;
        double balance = 1_000.00;

        long creditCardNumberLong = 1234_5678_9012_3456L;

        System.out.println("One Million: " + oneMillion);
        System.out.println("Credit Card Number: " + creditCardNumber);
        System.out.println("Social Security Number: " + socialSecurityNumber);
        System.out.println("Hex Bytes: " + hexBytes);
        System.out.println("Binary Bytes: " + binaryBytes);
        System.out.println("PI: " + pi);
        System.out.println("Avogadro Number: " + avogadroNumber);
        System.out.println("Balance: " + balance);
        System.out.println("Credit Card Number Long: " + creditCardNumberLong);
    }
}

```

## 変数の宣言と初期化
### 変数の宣言
変数の宣言は、プログラムで使用するためのメモリ領域を確保し、その変数に対して、名前をつけることです。
変数を宣言することで、その変数にデータを格納するための場所が確保され、後でその変数を利用することができます。

### 変数の宣言の構文
```java
type variableName;
```
ここで、'type'は変数のデータ型（整数、文字列、オブジェクトなど）、'variableName'は変数の名前です。
例：整数型の変数を宣言する
```java
int age;
```
この例では、'age'という名前の整数型の変数を宣言しています。これにより整数型のデータ格納するための領域が確保されていますが、初期化されていません。

### 変数の初期化
変数を宣言した後、必要に応じて初期化を行うことができます。
初期化とは、変数に最初の値を与えることです。初期化をしないと、変数はデフォルトの初期化が割り当てられますが、それは方によって、異なります。（整数型なら0、オブジェクト型ならnullなど）

#### 初期化の例
```java
int age = 25;
```

#### 変数の複数宣言と初期化
Javaでは、複数の変数を同じ型で一度に宣言することもできます。
```java
int x, y, z;
x = 10;
y = 20;
z = 30;
```

または、初期化と宣言を同時に行うことができます。
```java
int x = 10, y = 20, z = 30;
```

#### 注意点
・変数を使用するために必ず宣言する必要があります。未宣言の変数を使用しようとすると、コンパルエラーが発生します。
・変数名は識別子ルールに従って命令する必要があります。具体的には、英字、数字、アンダースコア（_）を使用して、数字ではじまることはできません。
```java
public class Example {
    public static void main(String[] args) {
        // 変数の宣言と初期化
        int myNumber = 42;
        String message = "Hello, world!";
        
        // 変数の使用
        System.out.println(message); // "Hello, world!" を出力
        System.out.println("My favorite number is " + myNumber); // "My favorite number is 42" を出力
    }
}

```

### 識別子のルール

1\. 命令規則：識別子は、アルファベット（A-Z、a-z）、数字（0−9）、アンダースコア（_）、ドル記号（＄）を使用して命令します
ただし、数字で始まることはできません。

2\. 大文字と小文字の区別：大文字と小文字は区別されます。つまり'myVariable'と'myvariable'は異なる識別子とみなされます。

3\. 予約後の使用禁止：言語で予約されているキーワード（予約後）は識別子として使用することができません。例えば、Javaでは'int'、'class'、'public'などが予約後です。

4\. 意味のある名前：識別子はその役割や目的を明確に反映する名前をつけることが推奨されます。このようにすることで、コードが読みやすくなり、他の開発者が理解しやすくなります。

#### 予約後
<table>
  <tr>
    <td>abstract</td>
    <td>assert</td>
    <td>boolean</td>
  </tr>
  <tr>
    <td>break</td>
    <td>byte</td>
    <td>case</td>
  </tr>
  <tr>
    <td>catch</td>
    <td>char</td>
    <td>class</td>
  </tr>
  <tr>
    <td>const</td>
    <td>continue</td>
    <td>default</td>
  </tr>
  <tr>
    <td>do</td>
    <td>double</td>
    <td>else</td>
  </tr>
  <tr>
    <td>enum</td>
    <td>extends</td>
    <td>final</td>
  </tr>
  <tr>
    <td>finally</td>
    <td>float</td>
    <td>for</td>
  </tr>
  <tr>
    <td>goto</td>
    <td>if</td>
    <td>implements</td>
  </tr>
  <tr>
    <td>import</td>
    <td>instanceof</td>
    <td>int</td>
  </tr>
  <tr>
    <td>interface</td>
    <td>long</td>
    <td>native</td>
  </tr>
  <tr>
    <td>new</td>
    <td>null</td>
    <td>package</td>
  </tr>
  <tr>
    <td>private</td>
    <td>protected</td>
    <td>public</td>
  </tr>
  <tr>
    <td>return</td>
    <td>short</td>
    <td>static</td>
  </tr>
  <tr>
    <td>strictfp</td>
    <td>super</td>
    <td>switch</td>
  </tr>
  <tr>
    <td>synchronized</td>
    <td>this</td>
    <td>throw</td>
  </tr>
  <tr>
    <td>throws</td>
    <td>transient</td>
    <td>try</td>
  </tr>
  <tr>
    <td>void</td>
    <td>volatile</td>
    <td>while</td>
  </tr>
</table>


* null、true、falseはjavaによる予約後ではありませんが、それぞれの特別な値やキーワードととして扱われます。

### データ型
データ型（Data　Type）は、プログラミング言語において、データの種類や形式を定義するために基本的な概念です。データ型は、データを格納するためのメモリのサイズや形式、そしてそのデータに対して行える演算や操作を決定します。

### プリミティブ型
プリミティブ型は、基本的なデータ型であり、言語自体が適用するためのものです。サイズによって細分化されます。
1\. 整数型：整数値を表現するための型です。一般的には、サイズによって細分化されます。
* byte: 8ビット（-128 ～ 127）
* short: 16ビット（-32,768 ～ 32,767）
* int: 32ビット（-2,147,483,648 ～ 2,147,483,647）
* long: 64ビット（-9,223,372,036,854,775,808 ～ 9,223,372,036,854,775,807）

2\. 浮動小数点型：浮動小数点を表現するための型です。
* float: 32ビット（単精度浮動小数点数）
* double: 64ビット（倍精度浮動小数点数）

3\. 文字列：単一の文字を表現するための型。
* char: 16ビット（Unicode文字を表現）

4\. 真偽値型：真（true）または偽（false）を表現するための型
* boolean: 真偽値を表す型。

### 参照型
参照型は、オブジェクトや配列などを複合的なデータを表現するための型です、これらの型はメモリ上の位置（参照）を格納し、実際のデータはその位置に存在します。主な参照型には以下があります。
* クラス（Class）
* インタフェース（Interface）
* 配列（Array）

### データ型の使い分け
プログラムの開発する際には、使用するデータの性質に応じて適切なデータ型は、選択することが重要です。

### デフォルト型
#### 符号付き整数のデフォルト型
整数リテラル（例えば'42'）はデフォルトで'int'型とみなされます。大きな値は使用する場合や'long'型を使用したい場合は、リテラルの後に'L'または'l'を付けます。
```java
int defaultInt = 42;       // デフォルトでint型
long longNumber = 42L;     // long型リテラル
```

#### 浮動小数点のデフォルト型
浮動小数点リテラル（例えば、'3.14'）はデフォルトで'double'型とみなされます。'float'型を使用したい場合は、リテラルの後に、'F'または'f'を付けます。
```java
double defaultDouble = 3.14;   // デフォルトでdouble型
float floatNumber = 3.14F;     // float型リテラル
```


### 定数
定数は、プログラムの実行中に変更されない固定された値のことです。Javaで定数を定義するには、'final'キーワードを使用します。定数は読みやすさやメンテナンスの向上に役立ち、マジックナンバー（コード中に突然現れるリテラル値）を避けるためによく使われます。

#### 定数の定義方法
1\.　プリミティブ型の定数
```java
public class Constants {
    public static final int MAX_VALUE = 100;
    public static final double PI = 3.14159;
}
```
* 'final'キーワードは、変数が一度初期化されたら変更できないことを示します。
* 'static'キーワードは、この定数がクラスレベルのものであり、インスタンスごとに複製されないことを示します。

2\.　オブジェクト型の定数
```java
public class Constants {
    public static final String GREETING = "Hello, World!";
}
```
オブジェクト型の定数もプリミティブ型と同様に'final'キーワードで定義されます。

#### 定数の命令規則
Javaでは、定数の命名に一般的な規則があります。全て大文字のアルファベットを使い、単語の区切りにはアンダースコア'_'を使用します。
```java
public static final int MAX_SPEED = 120;
public static final String DEFAULT_NAME = "Unnamed";
```
#### 定数の利用例
定数は、コードの可読性を向上させ、後で値を変更する必要がある場合に便利です。
```java
public class Main {
    public static void main(String[] args) {
        System.out.println("Maximum Value: " + Constants.MAX_VALUE);
        System.out.println("Value of PI: " + Constants.PI);
    }
}
```
#### 列挙型（enum）
定数の集合を表現するもう一つの方法として、列挙型（'enum'）があります。'enum'は、一連の定数を定義するための特別なクラスです。

```java
public enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}
```

'enum'を使うと、特定の値のみを持つ型を定義できます。
```java
public class Main {
    public static void main(String[] args) {
        Day today = Day.MONDAY;

        switch (today) {
            case MONDAY:
                System.out.println("Today is Monday");
                break;
            // 他のケース
        }
    }
}
```

* 定数は、'final'キーワードを使って定義され、プログラムの実行中に変更されない。
* 定数の命令規則は、全て大文字のアルファベットを使い、単語の区切りにはアンダースコアを使用
* 列挙型（enum）は、一連の定数を定義するための特別なクラスであり、特定の値のみを持つ型を定義するのに便利。

### 変数のスコープ
変数のスコープ（有効範囲）とは、変数がアクセス可能な範囲のことです。Javaにおいて、変数のスコープは主な４種類に分類されます。
1\. ブロックスコープ（ローカル変数）
2\. メソッドスコープ（パラメータ）
3\. クラススコープ（インスタンス変数）
4\. クラススコープ（クラス変数、静的変数）

1\. ブロックスコープ（ローカル変数）
ローカル変数は、メソッド内のブロック（'{}'）内で定義される変数で、そのブロックの中でのみ有効です。ブロックの外では、ローカル変数にアクセスすることはできません。
```java
public void myMethod() {
    int localVariable = 10; // ローカル変数
    if (localVariable > 5) {
        int blockVariable = 20; // ブロックスコープの変数
        System.out.println(blockVariable);
    }
    // blockVariableはここでは使えない
    // System.out.println(blockVariable); // エラー
}
```

2\. メソッドスコープ（パラメータ）
メソッドのパラメータも一種のローカル変数で、そのメソッド内でのみ有効です。メソッドの呼び出し時に渡される引数として扱われます。

```java
public void myMethod(int parameter) {
    System.out.println(parameter); // parameterはメソッド内でのみ有効
}
```

3\. クラススコープ（インスタンス変数）
インスタンス変数は、クラスのインスタンスに関連づけられ、そのクラスのどのメソッドからでもアクセス可能です。インスタンス変数は、クラスの外部からも、そのクラスのオブジェクトを通じてアクセスすることができます。
```java
public class MyClass {
    private int instanceVariable; // インスタンス変数

    public void setVariable(int value) {
        this.instanceVariable = value; // thisを使ってインスタンス変数にアクセス
    }

    public int getVariable() {
        return this.instanceVariable;
    }
}

MyClass obj = new MyClass();
obj.setVariable(5);
System.out.println(obj.getVariable()); // 5
```

4\. クラススコープ（クラス変数、静的変数）
クラス変数（静的変数）は'static'キーワードを使って定義され、クラス全体で共有されます。
クラス変数は、クラスのどのメソッドからでもアクセス可能であり、クラスのインスタンスを作成せずアクセスすることができます。
```java
public class MyClass {
    private static int staticVariable; // クラス変数（静的変数）

    public static void setStaticVariable(int value) {
        MyClass.staticVariable = value;
    }

    public static int getStaticVariable() {
        return MyClass.staticVariable;
    }
}

MyClass.setStaticVariable(10);
System.out.println(MyClass.getStaticVariable()); // 10

```

### ローカル変数型の型推論
#### 特徴
1\. 型推論：
コンパイラが右辺の初期化式を基に変数の型を推論します。'var'自体は型ではなく、あくまでコンパイラによる型推論を指示するキーワードです。

2\. ローカル変数のみ：
'var'はローカル変数の宣言のみ使用できます。メソッドのパラメータ、フィールド、キャッチブロックの変数には使用できません。

3\. 初期化が必須：
'var'を使う場合、変数は必ず初期化されなければなりません。初期化されない変数宣言には使用できません。

4\. メモリ管理：
ローカル変数はスタックメモリに格納されます。スタックメモリは自動的に管理され、メソッドやブロックが終了すると自動的に解放されます。

#### 使用例
以下は、varを使った変数宣言の例です。
```java
public class VarExample {
    public static void main(String[] args) {
        var number = 10; // int型として推論される
        var message = "Hello, World!"; // String型として推論される
        var list = List.of(1, 2, 3); // List<Integer>型として推論される

        System.out.println("number: " + number);
        System.out.println("message: " + message);
        System.out.println("list: " + list);

        // 以下は、型推論の結果を明示的に示すための例です。
        int numberExplicit = 10;
        String messageExplicit = "Hello, World!";
        List<Integer> listExplicit = List.of(1, 2, 3);
    }
}
```

最初のページ
[[備忘録 その１] Java Silver ～Javaプログラミング基礎～](https://qiita.com/MagicShowTime/items/9fcf3a2cb4a7162aafcf "[備忘録 その１] Java Silver ～Javaプログラミング基礎～")

前のページ
[[備忘録 その２] Java Silver ～Javaプログラミング基礎～](https://qiita.com/MagicShowTime/items/738335281da58f45b6cf "[備忘録 その２] Java Silver ～Javaプログラミング基礎～")

次のページ
[[備忘録 その４] Java Silver ～変数と配列 その２～](https://qiita.com/MagicShowTime/items/a062e1385e9b963b519c "[備忘録 その４] Java Silver ～変数と配列 その２～")