Summary  
This chapter introduces Java’s primitive data types—byte, short, int, long, float, double, boolean, and char—explaining how to declare variables of each type and describing their memory usage and valid value ranges.

General domain of usage  
Coffee shop operations

変数の作成方法を理解したところで、次は変数にどのようなデータを格納できるかを学びます。Javaでは、**プリミティブデータ型**が最も基本的なデータ型であり、数値、真偽値、または単一文字など、どのような情報を扱うかを定義します。


## 整数型

小数点を含まない数値（個数、合計、数量など）を扱う場合に使用。

**`byte`** — 非常に小さい数値用。値が小さい範囲に収まると分かっている場合に使用：
```java
byte freeSamples = 12;
```

**`short`** — `byte`より少し大きい範囲の小〜中規模の数値用：
```java
short dailyCustomers = 850;
```

**`int`** — 最も一般的に使われる整数型。ほとんどの場面でのデフォルト選択：
```java
int monthlyOrders = 24500;
```

**`long`** — 通常の使用範囲を大きく超える非常に大きな数値用。`L`サフィックスに注意：
```java
long totalCoffeeBeansUsed = 5000000000L;
```

## 小数型

価格や測定値など、精度が必要な場合に使用。

**`float`** — 高い精度が不要な場合に使用。`f`サフィックスに注意：
```java
float coffeeTemperature = 22.5f;
```

**`double`** — 最も一般的に使われる小数型。金額や価格を扱う際のデフォルト選択：
```java
double lattePrice = 4.99;
```

## ブール型

`boolean`は`true`または`false`の2つの値のみを格納。"もしかして"はなく、明確なはい・いいえのみ：
```java
boolean isCoffeeShopOpen = true;
```

## 文字型

`char`は1文字（1つの文字、記号、または数字）を格納。シングルクォートに注意：
```java
char drinkSize = 'M';
```

-2⁻¹⁴⁹ to (2 - 2⁻²³) * 2¹²⁷

-2⁻¹⁰⁷⁴ to (2 - 2⁻⁵²) * 2¹⁰²³

package com.example;
import com.github.javaparser.StaticJavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.VariableDeclarator;
import com.github.javaparser.ast.expr.Expression;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.PrintStream;
import java.util.Optional;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.*;
import static org.junit.jupiter.api.DynamicTest.dynamicTest;

public class MainTest {
    private static CompilationUnit cu;

    @BeforeAll
    public static void setup() throws Exception {
        File projectRoot = new File(
            MainTest.class.getProtectionDomain().getCodeSource().getLocation().toURI()
        ).getParentFile().getParentFile();
        File file = new File(projectRoot, "src/main/java/com/example/Main.java");
        cu = StaticJavaParser.parse(file);
    }

    private String getVariableValue(String varName) {
        Optional<VariableDeclarator> var = cu.findAll(VariableDeclarator.class).stream()
                .filter(v -> v.getNameAsString().equals(varName))
                .findFirst();
        return var.flatMap(v -> v.getInitializer().map(Object::toString)).orElse(null);
    }

    @TestFactory
    Stream<DynamicTest> variableValueTests() {
        return Stream.of(
                new String[]{"firstNumber", "9"},
                new String[]{"secondNumber", "4"},
                new String[]{"thirdNumber", "2.0"}
        ).map(pair -> {
            String varName = pair[0];
            String expectedValue = pair[1];
            String actualValue = getVariableValue(varName);
            boolean passed = expectedValue.equals(actualValue);
            String displayName = passed ?
                    varName + " has expected value: " + expectedValue :
                    "Expected " + varName + " = " + expectedValue + ", but got: " + actualValue;
            return dynamicTest(displayName, () -> assertEquals(expectedValue, actualValue));
        });
    }

    @TestFactory
    Stream<DynamicTest> outputTest() {
        return Stream.of(dynamicTest("Result value matches output", () -> {
            ByteArrayOutputStream outContent = new ByteArrayOutputStream();
            PrintStream originalOut = System.out;
            System.setOut(new PrintStream(outContent));
            Main.main(new String[]{});
            System.setOut(originalOut);
            String output = outContent.toString().trim();
            String expectedResult = "6.5";
            String testName = output.equals(expectedResult)
                    ? "result has correct value: " + expectedResult
                    : "Expected result = " + expectedResult + ", but got: " + output;
            assertEquals(expectedResult, output, testName);
        }));
    }

    @TestFactory
    Stream<DynamicTest> hardcodedExpressionCheck() {
        Optional<VariableDeclarator> resultVar = cu.findAll(VariableDeclarator.class).stream()
                .filter(v -> v.getNameAsString().equals("result"))
                .findFirst();
        String displayName;
        if (resultVar.isPresent()) {
            Expression init = resultVar.get().getInitializer().orElse(null);
            boolean usesVariables = init != null && init.toString().contains("firstNumber") && init.toString().contains("secondNumber");
            displayName = usesVariables
                    ? "result expression uses declared variables"
                    : "result expression uses hardcoded values (should use variables)";
            return Stream.of(dynamicTest(displayName, () -> assertTrue(usesVariables, "Detected hardcoded numbers in result expression: " + init)));
        }
        return Stream.of(dynamicTest("result variable not found", () -> fail("Variable 'result' not found")));
    }
}

MainTest.java

Javaの基礎を学び、現代のアプリケーションを支えるコアコンセプトを探求します。変数、データ型、演算子、条件分岐、文字列について学びながら、プログラミングの強固な基礎を築きます。実践的な例やハンズオン課題を通じて、Javaコードの記述、理解、トラブルシューティングに必要なスキルを自信を持って身につけます。

Javaとは何か、どこで使用されているか、Javaプログラムの構造について学び、Javaの学習を始めましょう。出力の表示方法、コメントの記述方法を理解し、今後のすべてのプログラミング概念の基礎を築きます。

Javaでデータを保存、管理、操作するために必要なスキルを習得します。変数、定数、データ型、演算子、型変換の仕組みを学び、実践的なコーディング演習や実例を通じてこれらの概念を応用します。

Javaにおける意思決定の基本を、比較演算子や論理演算子、条件文、switch式を使って学びます。プログラムが条件を評価し、選択を行い、さまざまな状況に応じて応答する方法を、実践的な例や課題を通じて理解します。

Javaにおけるテキスト操作の基礎を学びます。文字列の生成と操作方法、フォーマットや比較の手法、ユーザー入力の検証、テキストからの有用な情報の抽出、そしてこれらのスキルを実際のプログラミングシナリオで応用する方法を探求します。

プリミティブデータ型

整数型

小数型

ブール型

文字型

解答