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

Nå som du vet hvordan du oppretter variabler, er det på tide å forstå hvilken type data du kan legge inn i dem. I Java er **primitive datatyper** de mest grunnleggende typene data vi kan lagre — de definerer hvilken type informasjon vi arbeider med, enten det er tall, sann/usann-verdier eller enkelttegn.


## Heltallstyper

Brukes når du arbeider med tall uten desimaler, som antall, summer eller mengder.

**`byte`** — for svært små tall, når du vet at verdien vil forbli liten:
```java
byte freeSamples = 12;
```

**`short`** — litt større enn `byte`, for små til middels store tall:
```java
short dailyCustomers = 850;
```

**`int`** — den mest brukte heltallstypen, standardvalget i de fleste situasjoner:
```java
int monthlyOrders = 24500;
```

**`long`** — for svært store tall som går langt utover vanlig daglig bruk. Merk suffikset `L`:
```java
long totalCoffeeBeansUsed = 5000000000L;
```

## Desimaltallstyper

Brukes når vi trenger presisjon, som ved prissetting eller målinger.

**`float`** — når vi ikke trenger veldig høy presisjon. Merk suffikset `f`:
```java
float coffeeTemperature = 22.5f;
```

**`double`** — den mest brukte desimaltypen, standardvalget når du arbeider med penger eller priser:
```java
double lattePrice = 4.99;
```

## Boolsk type

`boolean` lagrer kun to verdier — `true` eller `false`. Ingen "kanskje", bare et klart ja eller nei:
```java
boolean isCoffeeShopOpen = true;
```

## Tegntype

`char` lagrer ett enkelt tegn — én bokstav, symbol eller tall. Merk de enkle anførselstegnene:
```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

Fordyp deg i grunnleggende Java ved å lære kjernebegrepene som driver moderne applikasjoner. Utforsk variabler, datatyper, operatorer, betingelser og strenger mens du bygger et solid fundament i programmering. Gjennom praktiske eksempler og oppgaver utvikler du ferdighetene som trengs for å skrive, forstå og feilsøke Java-kode med selvtillit.

Oppdag hvordan du kan starte din Java-reise ved å lære hva Java er, hvor det brukes, og hvordan Java-programmer er strukturert. Forstå hvordan du skriver ut output, skriver kommentarer, og bygger grunnlaget som trengs for alle fremtidige programmeringskonsepter.

Behersk ferdighetene som trengs for å lagre, håndtere og arbeide med data i Java. Lær hvordan variabler, konstanter, datatyper, operatorer og typekonvertering fungerer, og anvend disse konseptene gjennom praktiske kodeøvelser og eksempler fra virkeligheten.

Utforsk det grunnleggende innen beslutningstaking i Java ved å arbeide med sammenlignings- og logiske operatorer, betingede setninger og switch-uttrykk. Lær hvordan programmer evaluerer betingelser, tar valg og responderer på ulike situasjoner gjennom praktiske eksempler og utfordringer.

Fordyp deg i grunnleggende arbeid med tekst i Java. Lær hvordan strenger opprettes og manipuleres, utforsk teknikker for formatering og sammenligning, valider brukerinput, hent ut nyttig informasjon fra tekst, og anvend disse ferdighetene i realistiske programmeringssituasjoner.

Primitiver Datatyper

Heltallstyper

Desimaltallstyper

Boolsk type

Tegntype

Løsning