Especialização em Sistemas com Java 21 LTS • Módulo de Fundamentos

🗺️ Mapa Conceitual do Tópico

flowchart TD
    A["Código Fonte (.java)"] -->|Compilador javac| B["Bytecode Portável (.class)"]
    B -->|Class Loader| C["Java Virtual Machine (JVM)"]
    C -->|JIT Compiler + GC| D["Código Nativo de Máquina / SO Windows"]
    
    subgraph TIPOS["Tipagem Primitiva & Exata"]
        E["Inteiros: byte, short, int, long"]
        F["Ponto Flutuante: float, double"]
        G["Monetário: java.math.BigDecimal"]
    end
    
    subgraph IO["Entrada e Saída Formatada"]
        H["Scanner sc = new Scanner(System.in)"]
        I["System.out.printf('%.2f', valor)"]
    end

    C --> TIPOS
    C --> IO
    
    style A fill:#e1f5fe,stroke:#03a9f4,stroke-width:2px
    style B fill:#fff3e0,stroke:#ff9800,stroke-width:2px
    style C fill:#ede7f6,stroke:#7e57c2,stroke-width:2px
    style D fill:#e8f5e9,stroke:#4caf50,stroke-width:2px

🏛️ 1. A Plataforma Java e a Java Virtual Machine (JVM)

Java é uma linguagem de alto nível, fortemente tipada e orientada a objetos. O código-fonte (.java) é compilado pelo javac em Bytecode intermediário (.class), que é executado pela Java Virtual Machine (JVM) sob o lema Write Once, Run Anywhere.

Componentes da Plataforma:

  • JDK (Java Development Kit): Kit de desenvolvimento contendo o compilador javac, depuradores e ferramentas de diagnóstico.
  • JVM (Java Virtual Machine): Motor de execução responsável pela compilação dinâmica (Just-In-Time Compiler - JIT), segurança e gestão de memória pelo Garbage Collector (GC).
  • Java 21 LTS: Versão estável com Suporte de Longo Prazo (Long-Term Support), trazendo Virtual Threads, Pattern Matching e otimizações de runtime.

🔢 2. Tabela Detalhada dos 8 Tipos Primitivos (Primitive Types)

Os tipos primitivos armazenam valores escalares diretamente na Stack da JVM, sem a sobrecarga de cabeçalhos de objetos.

Tipo Primitivo Categoria Tamanho Faixa de Valores (Range) Valor Padrão Literal / Sufixo Classe Wrapper Exemplo de Uso
byte Inteiro 8 bits (1 byte) -128 a +127 0 (sem sufixo) java.lang.Byte byte nivel = 12;
short Inteiro 16 bits (2 bytes) -32.768 a +32.767 0 (sem sufixo) java.lang.Short short porta = 8080;
int Inteiro (padrão) 32 bits (4 bytes) -2.147.483.648 a +2.147.483.647 0 (sem sufixo) java.lang.Integer int estoque = 1500;
long Inteiro Longo 64 bits (8 bytes) -9.223.372.036.854.775.808 a +9.223.372.036.854.775.807 0L L ou l java.lang.Long long id = 10500980L;
float Ponto Flutuante 32 bits (4 bytes) ±1.4 × 10⁻⁴⁵ a ±3.4 × 10³⁸ (6 a 7 dígitos de precisão) 0.0f F ou f java.lang.Float float taxa = 0.055f;
double Ponto Flutuante (padrão) 64 bits (8 bytes) ±4.9 × 10⁻³²⁴ a ±1.8 × 10³⁰⁸ (15 a 17 dígitos de precisão) 0.0d D ou d java.lang.Double double peso = 82.45;
char Caractere Unicode 16 bits (2 bytes) ‘\u0000’ (0) a ‘\uffff’ (65.535) (UTF-16) '\u0000' Aspas simples ' ' java.lang.Character char status = 'A';
boolean Lógico / Booleano 1 byte na JVM true ou false false true / false java.lang.Boolean boolean aprovado = true;

📦 3. Tabela de Classes Empacotadoras (Wrapper Classes)

As classes Wrapper encapsulam tipos primitivos como objetos no Heap, permitindo seu uso em estruturas genéricas da Java Collections Framework (List<Integer>, Map<String, Double>) e suportando o valor null.

Primitivo Wrapper Class Suporta null? Método de Parsing de String Método de Conversão de Objeto Uso Recomendado
byte Byte Sim Byte.parseByte("10") Byte.valueOf("10") Leitura de buffers e fluxos binários.
short Short Sim Short.parseShort("100") Short.valueOf("100") Otimização de matrizes numéricas volumosas.
int Integer Sim Integer.parseInt("500") Integer.valueOf("500") IDs, chaves de dicionário, índices de listas.
long Long Sim Long.parseLong("999999") Long.valueOf("999999") Chaves primárias em bancos de dados relacionais.
float Float Sim Float.parseFloat("12.5") Float.valueOf("12.5") Processamento gráfico e áudio digital.
double Double Sim Double.parseDouble("99.9") Double.valueOf("99.9") Cálculos científicos e estatísticos.
char Character Sim str.charAt(0) Character.valueOf('A') Validação e manipulação alfanumérica.
boolean Boolean Sim Boolean.parseBoolean("true") Boolean.valueOf("true") Flags opcionais e colunas de banco que aceitam NULL.

🔀 4. Tabela de Conversão e Regras de Casting

flowchart LR
    byte["byte (8b)"] --> short["short (16b)"]
    short --> int["int (32b)"]
    char["char (16b)"] --> int
    int --> long["long (64b)"]
    long --> float["float (32b)"]
    float --> double["double (64b)"]

    style byte fill:#e1f5fe,stroke:#03a9f4,stroke-width:2px
    style int fill:#ede7f6,stroke:#7e57c2,stroke-width:2px
    style double fill:#e8f5e9,stroke:#4caf50,stroke-width:2px
Tipo de Conversão Direção Necessita Cast Explícito? Risco de Perda de Dados? Exemplo de Código
Widening (Alargamento) Menor → Maior (int para double) Não (Automático) Não int a = 10; double b = a;
Narrowing (Estreitamento) Maior → Menor (double para int) Sim ((tipo)) Sim (Trunca decimais ou gera overflow) double d = 9.99; int i = (int) d; // i = 9
Promoção Numérica Operações com tipos menores que int Automático (Promove para int) Não byte x = 1, y = 2; int z = x + y;

💼 5. Precisão Numérica: double vs BigDecimal em Faturamento

⚠️ Atenção Financeira (Padrão IEEE 754): Tipos de ponto flutuante binário (double/float) não conseguem representar frações decimais exatas como 0,1 ou 0,07, introduzindo resíduos de arredondamento. Em aplicações fiscais, bancárias e corporativas, utilize sempre java.math.BigDecimal com RoundingMode.HALF_EVEN.

Critério double (IEEE 754) java.math.BigDecimal
Representação Binária de 64 bits Objeto arbitrário com base decimal e escala
Precisão 15 a 17 dígitos significativos (Aproximada) Exata (Definida pelo programador)
Velocidade Processamento direto na FPU / CPU (Ultrarrápido) Processamento por software (Mais lento)
Operadores Aritméticos nativos (+, -, *, /) Métodos da classe (add(), subtract(), multiply(), divide())
Recomendação Gráficos 3D, física, jogos, machine learning Sistemas contábeis, ERPs, folhas de pagamento, e-commerce

📥 6. Entrada e Saída Formatada no Windows

  • Leitura com Scanner: 
    Scanner sc = new Scanner(System.in);
System.out.print("Informe o salário: ");
double salario = sc.nextDouble();
  • Saída Formatada com printf: 
    System.out.printf("Total Faturado: R$ %10.2f%n", total);

    (O marcador %n garante a quebra de linha correta no Windows sem problemas de portabilidade).

💻 7. Código de Demonstração Corporativo (Java 21 LTS)

// Exemplo01EcossistemaSequencial.java - Processamento Sequencial com BigDecimal
package com.empresa.fundamentos;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Locale;

public class Exemplo01EcossistemaSequencial {

    public static final BigDecimal ALIQUOTA_INSS = new BigDecimal("0.11"); // 11%
    public static final BigDecimal VALOR_TRANSPORTE = new BigDecimal("180.00");

    public static void main(String[] args) {
        Locale.setDefault(Locale.US);

        String colaborador = "Camila Duarte";
        BigDecimal salarioBruto = new BigDecimal("5400.00");
        int diasTrabalhados = 30;

        // Cálculo com precisão contábil e arredondamento bancário (HALF_EVEN)
        BigDecimal fatorDias = new BigDecimal(diasTrabalhados).divide(new BigDecimal("30"), 4, RoundingMode.HALF_EVEN);
        BigDecimal proventoBase = salarioBruto.multiply(fatorDias).setScale(2, RoundingMode.HALF_EVEN);
        BigDecimal descontoInss = proventoBase.multiply(ALIQUOTA_INSS).setScale(2, RoundingMode.HALF_EVEN);
        BigDecimal salarioLiquido = proventoBase.subtract(descontoInss).subtract(VALOR_TRANSPORTE);

        System.out.println("=================================================");
        System.out.println("   DEMONSTRATIVO DE PAGAMENTO (JAVA 21 LTS)      ");
        System.out.println("=================================================");
        System.out.printf("Colaborador        : %s%n", colaborador);
        System.out.printf("Salário Base (30d) : R$%10.2f%n", proventoBase); System.out.printf("(-) Desconto INSS : R$ %10.2f (11%%)%n", descontoInss);
        System.out.printf("(-) Transporte     : R$%10.2f%n", VALOR_TRANSPORTE); System.out.println("-------------------------------------------------"); System.out.printf("LÍQUIDO A RECEBER : R$ %10.2f%n", salarioLiquido);
        System.out.println("=================================================");
    }
}

🔗 Recursos Pedagógicos do Capítulo 01

Recurso Didático Finalidade Link de Acesso
📊 Slides de Aula Apresentação visual interativa com Dark Mode e suporte a teclado Ver Slides
🧠 Quiz Formativo Teste interativo de fixação com feedback imediato por alternativa Fazer Quiz
💻 Exemplos de Código Demonstrações funcionais compiláveis com saída no console Ver Exemplos
🧩 Exercícios em 4 Níveis Lista progressiva de fixação com gabarito em bloco colapsável Resolver Exercícios
⬅️ Voltar ao Sumário 📚 Sumário de Tópicos 🔀 Próximo Capítulo: Estrutura Condicional ➡️