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

Nachdem du nun weißt, wie man Variablen erstellt, ist es an der Zeit zu verstehen, welche Art von Daten du darin speichern kannst. In Java sind **primitive Datentypen** die grundlegendsten Datentypen, die wir speichern können — sie definieren, mit welcher Art von Information wir arbeiten, sei es Zahlen, Wahr/Falsch-Werte oder einzelne Zeichen.

## Ganzzahlige Datentypen

Verwendet bei Zahlen ohne Dezimalstellen, wie Zählungen, Summen oder Mengen.

**`byte`** — für sehr kleine Zahlen, wenn der Wert garantiert klein bleibt:
```java
byte freeSamples = 12;
```

**`short`** — etwas größer als `byte`, für kleine bis mittlere Zahlen:
```java
short dailyCustomers = 850;
```

**`int`** — der am häufigsten verwendete ganzzahlige Datentyp, die Standardwahl für die meisten Situationen:
```java
int monthlyOrders = 24500;
```

**`long`** — für sehr große Zahlen, die weit über den normalen Tagesgebrauch hinausgehen. Beachte das `L` am Ende:
```java
long totalCoffeeBeansUsed = 5000000000L;
```

## Dezimalzahl-Datentypen

Verwendet, wenn Präzision benötigt wird, wie bei Preisen oder Messwerten.

**`float`** — wenn keine sehr hohe Genauigkeit erforderlich ist. Beachte das `f` am Ende:
```java
float coffeeTemperature = 22.5f;
```

**`double`** — der am häufigsten verwendete Dezimaltyp, die Standardwahl bei Geldbeträgen oder Preisen:
```java
double lattePrice = 4.99;
```

## Boolean-Typ

`boolean` speichert nur zwei Werte — `true` oder `false`. Kein "vielleicht", nur ein klares Ja oder Nein:
```java
boolean isCoffeeShopOpen = true;
```

## Zeichen-Typ

`char` speichert ein einzelnes Zeichen — einen Buchstaben, ein Symbol oder eine Zahl. Beachte die einfachen Anführungszeichen:
```java
char drinkSize = 'M';
```

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

-2⁻¹⁰⁷⁴ bis (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

Tauchen Sie ein in die Grundlagen von Java, indem Sie die Kernkonzepte kennenlernen, die moderne Anwendungen antreiben. Erkunden Sie Variablen, Datentypen, Operatoren, Kontrollstrukturen und Strings, während Sie ein solides Fundament in der Programmierung aufbauen. Durch praxisnahe Beispiele und praktische Herausforderungen entwickeln Sie die Fähigkeiten, Java-Code sicher zu schreiben, zu verstehen und zu debuggen.

Entdecken Sie, wie Sie Ihre Java-Reise beginnen, indem Sie lernen, was Java ist, wo es verwendet wird und wie Java-Programme aufgebaut sind. Verstehen Sie, wie Ausgaben ausgegeben werden, Kommentare geschrieben werden und das Fundament für alle zukünftigen Programmierkonzepte gelegt wird.

Beherrschen Sie die Fähigkeiten, die erforderlich sind, um Daten in Java zu speichern, zu verwalten und zu verarbeiten. Lernen Sie, wie Variablen, Konstanten, Datentypen, Operatoren und Typumwandlungen funktionieren, und wenden Sie diese Konzepte durch praktische Programmierübungen und praxisnahe Beispiele an.

Erkunden Sie die Grundlagen der Entscheidungsfindung in Java durch die Arbeit mit Vergleichs- und logischen Operatoren, bedingten Anweisungen und Switch-Ausdrücken. Lernen Sie, wie Programme Bedingungen auswerten, Entscheidungen treffen und auf verschiedene Situationen anhand praktischer Beispiele und Herausforderungen reagieren.

Tauchen Sie ein in die Grundlagen der Arbeit mit Texten in Java. Erfahren Sie, wie Strings erstellt und manipuliert werden, erkunden Sie Formatierungs- und Vergleichstechniken, validieren Sie Benutzereingaben, extrahieren Sie nützliche Informationen aus Texten und wenden Sie diese Fähigkeiten in realistischen Programmier­szenarien an.

Primitive Datentypen

Ganzzahlige Datentypen

Dezimalzahl-Datentypen

Boolean-Typ

Zeichen-Typ

Lösung