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

Nyt kun osaat luoda muuttujia, on aika ymmärtää, millaista dataa niihin voi tallentaa. Javassa **primitiiiviset tietotyypit** ovat perusmuotoisia tietotyyppejä — ne määrittelevät, minkälaista tietoa käsittelemme, olipa kyseessä sitten luvut, tosi/epätosi-arvot tai yksittäiset merkit.


## Kokonaislukutyypit

Käytetään, kun käsitellään lukuja ilman desimaaleja, kuten määriä, summia tai kappalemääriä.

**`byte`** — hyvin pienille luvuille, kun tiedät arvon pysyvän pienenä:
```java
byte freeSamples = 12;
```

**`short`** — hieman suuremmille luvuille kuin `byte`, pienistä keskisuuriin lukuihin:
```java
short dailyCustomers = 850;
```

**`int`** — yleisimmin käytetty kokonaislukutyyppi, oletusvalinta useimmissa tilanteissa:
```java
int monthlyOrders = 24500;
```

**`long`** — erittäin suurille luvuille, jotka ylittävät normaalin päivittäisen käytön. Huomaa `L`-pääte:
```java
long totalCoffeeBeansUsed = 5000000000L;
```

## Desimaalilukutyypit

Käytetään, kun tarvitaan tarkkuutta, kuten hinnoissa tai mittauksissa.

**`float`** — kun ei tarvita erittäin suurta tarkkuutta. Huomaa `f`-pääte:
```java
float coffeeTemperature = 22.5f;
```

**`double`** — yleisimmin käytetty desimaalilukutyyppi, oletusvalinta rahan tai hintojen kanssa:
```java
double lattePrice = 4.99;
```

## Totuusarvotyyppi

`boolean` tallentaa vain kaksi arvoa — `true` tai `false`. Ei "ehkä", vain selkeä kyllä tai ei:
```java
boolean isCoffeeShopOpen = true;
```

## Merkkityyppi

`char` tallentaa yhden merkin — yhden kirjaimen, symbolin tai numeron. Huomaa yksittäiset lainausmerkit:
```java
char drinkSize = 'M';
```

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

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

Sukella Java-ohjelmoinnin perusteisiin oppimalla ydinkäsitteet, jotka ovat nykyaikaisten sovellusten taustalla. Tutustu muuttujiin, tietotyyppeihin, operaattoreihin, ehtoihin ja merkkijonoihin samalla, kun rakennat vahvan pohjan ohjelmoinnille. Käytännön esimerkkien ja harjoitustehtävien avulla kehität taidot, joita tarvitset Java-koodin kirjoittamiseen, ymmärtämiseen ja virheiden korjaamiseen luottavaisesti.

Opi, miten aloittaa Java-ohjelmoinnin matka tutustumalla siihen, mitä Java on, missä sitä käytetään ja miten Java-ohjelmat rakentuvat. Ymmärrä, miten tulostetaan tulosteita, kirjoitetaan kommentteja ja luodaan perusta kaikille tuleville ohjelmointikäsitteille.

Hallitse taidot, joita tarvitaan tiedon tallentamiseen, hallintaan ja käsittelyyn Javassa. Opiskele, miten muuttujat, vakiot, tietotyypit, operaattorit ja tyyppimuunnokset toimivat, ja sovella näitä käsitteitä käytännön koodausharjoitusten ja tosielämän esimerkkien avulla.

Tutustu päätöksenteon perusteisiin Javassa työskentelemällä vertailu- ja loogisten operaattoreiden, ehtolauseiden ja switch-lausekkeiden kanssa. Opiskele, miten ohjelmat arvioivat ehtoja, tekevät valintoja ja reagoivat erilaisiin tilanteisiin käytännön esimerkkien ja haasteiden avulla.

Sukella tekstin käsittelyn perusteisiin Javassa. Opiskele, miten merkkijonot luodaan ja muokataan, tutustu muotoilu- ja vertailutekniikoihin, validoi käyttäjän syötteet, poimi hyödyllistä tietoa tekstistä ja sovella näitä taitoja realistisissa ohjelmointitilanteissa.

Primitiiviset tietotyypit

Kokonaislukutyypit

Desimaalilukutyypit

Totuusarvotyyppi

Merkkityyppi

Ratkaisu