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

Agora que você sabe como criar variáveis, é hora de entender que tipo de dados pode colocar nelas. Em Java, **tipos de dados primitivos** são os tipos mais básicos de dados que podemos armazenar — eles definem com que tipo de informação estamos lidando, seja números, valores verdadeiro/falso ou caracteres únicos.


## Tipos de Números Inteiros

Utilizados ao trabalhar com números sem casas decimais, como contagens, totais ou quantidades.

**`byte`** — para números muito pequenos, quando você sabe que o valor permanecerá baixo:
```java
byte freeSamples = 12;
```

**`short`** — um pouco maior que `byte`, para números de pequeno a médio porte:
```java
short dailyCustomers = 850;
```

**`int`** — o tipo de número inteiro mais utilizado, escolha padrão para a maioria das situações:
```java
int monthlyOrders = 24500;
```

**`long`** — para números muito grandes que vão além do uso diário normal. Observe o sufixo `L`:
```java
long totalCoffeeBeansUsed = 5000000000L;
```

## Tipos de Números Decimais

Utilizados quando precisamos de precisão, como em preços ou medições.

**`float`** — quando não precisamos de precisão muito alta. Observe o sufixo `f`:
```java
float coffeeTemperature = 22.5f;
```

**`double`** — o tipo decimal mais utilizado, escolha padrão ao trabalhar com dinheiro ou preços:
```java
double lattePrice = 4.99;
```

## Tipo Booleano

`boolean` armazena apenas dois valores — `true` ou `false`. Não existe "talvez", apenas sim ou não:
```java
boolean isCoffeeShopOpen = true;
```

## Tipo Caractere

`char` armazena um único caractere — uma letra, símbolo ou número. Observe as aspas simples:
```java
char drinkSize = 'M';
```

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

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

Mergulhe nos fundamentos do Java aprendendo os conceitos centrais que impulsionam aplicações modernas. Explore variáveis, tipos de dados, operadores, condicionais e strings enquanto constrói uma base sólida em programação. Por meio de exemplos práticos e desafios interativos, você desenvolverá as habilidades necessárias para escrever, compreender e depurar código Java com confiança.

Descubra como iniciar sua jornada em Java aprendendo o que é Java, onde é utilizado e como os programas Java são estruturados. Compreenda como exibir saídas, escrever comentários e construir a base necessária para todos os conceitos futuros de programação.

Domine as habilidades necessárias para armazenar, gerenciar e trabalhar com dados em Java. Aprenda como variáveis, constantes, tipos de dados, operadores e conversão de tipos funcionam, e aplique esses conceitos por meio de exercícios práticos de programação e exemplos do mundo real.

Explore os fundamentos da tomada de decisão em Java ao trabalhar com operadores de comparação e lógicos, instruções condicionais e expressões switch. Aprenda como os programas avaliam condições, tomam decisões e respondem a diferentes situações por meio de exemplos práticos e desafios.

Mergulhe nos fundamentos do trabalho com texto em Java. Aprenda como as strings são criadas e manipuladas, explore técnicas de formatação e comparação, valide a entrada do usuário, extraia informações úteis de textos e aplique essas habilidades em cenários de programação realistas.

Tipos de Dados Primitivos

Tipos de Números Inteiros

Tipos de Números Decimais

Tipo Booleano

Tipo Caractere

Solução