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

Nu je weet hoe je variabelen maakt, is het tijd om te begrijpen welk soort gegevens je erin kunt opslaan. In Java zijn **primitieve gegevenstypen** de meest basale typen gegevens die we kunnen opslaan — ze bepalen met welk soort informatie we werken, of dat nu getallen, waar/onwaar-waarden of enkele tekens zijn.


## Gehele getaltypen

Gebruikt bij het werken met getallen zonder decimalen, zoals aantallen, totalen of hoeveelheden.

**`byte`** — voor zeer kleine getallen, wanneer je weet dat de waarde klein blijft:
```java
byte freeSamples = 12;
```

**`short`** — iets groter dan `byte`, voor kleine tot middelgrote getallen:
```java
short dailyCustomers = 850;
```

**`int`** — het meest gebruikte type voor gehele getallen, de standaardkeuze voor de meeste situaties:
```java
int monthlyOrders = 24500;
```

**`long`** — voor zeer grote getallen die veel verder gaan dan normaal dagelijks gebruik. Let op het `L`-achtervoegsel:
```java
long totalCoffeeBeansUsed = 5000000000L;
```

## Decimale getaltypen

Gebruikt wanneer we precisie nodig hebben, zoals bij prijzen of metingen.

**`float`** — wanneer we geen zeer hoge precisie nodig hebben. Let op het `f`-achtervoegsel:
```java
float coffeeTemperature = 22.5f;
```

**`double`** — het meest gebruikte decimale type, de standaardkeuze bij het werken met geld of prijzen:
```java
double lattePrice = 4.99;
```

## Booleaanse type

`boolean` slaat slechts twee waarden op — `true` of `false`. Geen "misschien", alleen een duidelijk ja of nee:
```java
boolean isCoffeeShopOpen = true;
```

## Karaktertype

`char` slaat één enkel teken op — één letter, symbool of cijfer. Let op de enkele aanhalingstekens:
```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

Duik in de basisprincipes van Java door de kernconcepten te leren die moderne applicaties aandrijven. Verken variabelen, gegevenstypen, operatoren, conditionals en strings terwijl je een sterke basis in programmeren opbouwt. Door middel van praktische voorbeelden en hands-on uitdagingen ontwikkel je de vaardigheden die nodig zijn om Java-code met vertrouwen te schrijven, te begrijpen en te debuggen.

Ontdek hoe je je Java-reis begint door te leren wat Java is, waar het wordt gebruikt en hoe Java-programma's zijn opgebouwd. Begrijp hoe je uitvoer afdrukt, opmerkingen schrijft en de basis legt die nodig is voor alle toekomstige programmeerconcepten.

Beheers de vaardigheden die nodig zijn om gegevens op te slaan, te beheren en ermee te werken in Java. Leer hoe variabelen, constanten, gegevenstypen, operatoren en typecasting werken, en pas deze concepten toe via praktische programmeeroefeningen en voorbeelden uit de praktijk.

Ontdek de basisprincipes van besluitvorming in Java door te werken met vergelijkings- en logische operatoren, conditionele uitspraken en switch-expressies. Leer hoe programma's voorwaarden evalueren, keuzes maken en reageren op verschillende situaties aan de hand van praktische voorbeelden en uitdagingen.

Duik in de basisprincipes van het werken met tekst in Java. Leer hoe strings worden aangemaakt en gemanipuleerd, verken technieken voor formatteren en vergelijken, valideer gebruikersinvoer, extraheer bruikbare informatie uit tekst en pas deze vaardigheden toe in realistische programmeerscenario's.

Primitieve Gegevenstypen

Gehele getaltypen

Decimale getaltypen

Booleaanse type

Karaktertype

Oplossing