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 hvor du ved, hvordan man opretter variabler, er det tid til at forstå, hvilken slags data du kan placere i dem. I Java er **primitiver datatyper** de mest grundlæggende datatyper, vi kan gemme — de definerer, hvilken slags information vi arbejder med, uanset om det er tal, sand/falsk-værdier eller enkelte tegn.


## Heltalstyper

Bruges, når man arbejder med tal uden decimaler, såsom optællinger, totaler eller mængder.

**`byte`** — til meget små tal, når du ved, at værdien forbliver lille:
```java
byte freeSamples = 12;
```

**`short`** — lidt større end `byte`, til små til mellemstore tal:
```java
short dailyCustomers = 850;
```

**`int`** — den mest almindeligt anvendte heltalstype, standardvalget i de fleste situationer:
```java
int monthlyOrders = 24500;
```

**`long`** — til meget store tal, der ligger langt over normal daglig brug. Bemærk suffikset `L`:
```java
long totalCoffeeBeansUsed = 5000000000L;
```

## Decimaltyper

Bruges, når vi har brug for præcision, såsom priser eller målinger.

**`float`** — når vi ikke har brug for meget høj præcision. Bemærk suffikset `f`:
```java
float coffeeTemperature = 22.5f;
```

**`double`** — den mest almindeligt anvendte decimaltype, standardvalget ved arbejde med penge eller priser:
```java
double lattePrice = 4.99;
```

## Boolesk type

`boolean` gemmer kun to værdier — `true` eller `false`. Ingen "måske", kun et klart ja eller nej:
```java
boolean isCoffeeShopOpen = true;
```

## Tegntype

`char` gemmer et enkelt tegn — ét bogstav, symbol eller tal. Bemærk de enkelte anførselstegn:
```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

Dyk ned i Java's grundlæggende principper ved at lære de kernekoncepter, der driver moderne applikationer. Udforsk variabler, datatyper, operatorer, betingelser og strenge, mens du opbygger et solidt fundament i programmering. Gennem praktiske eksempler og øvelsesopgaver udvikler du de nødvendige færdigheder til at skrive, forstå og fejlfinde Java-kode med selvtillid.

Opdag, hvordan du påbegynder din Java-rejse ved at lære, hvad Java er, hvor det anvendes, og hvordan Java-programmer er opbygget. Forstå, hvordan man udskriver output, skriver kommentarer og opbygger det fundament, der er nødvendigt for alle fremtidige programmeringskoncepter.

Opnå færdighederne til at lagre, håndtere og arbejde med data i Java. Lær hvordan variabler, konstanter, datatyper, operatorer og typekonvertering fungerer, og anvend disse begreber gennem praktiske kodeøvelser og eksempler fra virkeligheden.

Udforsk det grundlæggende i beslutningstagning i Java ved at arbejde med sammenlignings- og logiske operatorer, betingede udsagn og switch-udtryk. Lær, hvordan programmer evaluerer betingelser, træffer valg og reagerer på forskellige situationer gennem praktiske eksempler og udfordringer.

Dyk ned i grundlæggende arbejde med tekst i Java. Lær hvordan strenge oprettes og manipuleres, udforsk formaterings- og sammenligningsteknikker, valider brugerinput, udtræk nyttig information fra tekst, og anvend disse færdigheder i realistiske programmeringssituationer.

Primitiver Datatyper

Heltalstyper

Decimaltyper

Boolesk type

Tegntype

Løsning