Java: Documentação Essencial

1. Introdução ao Java

Java é uma linguagem de programação orientada a objetos, de alto nível e multiplataforma, amplamente utilizada para desenvolvimento de aplicações empresariais, web, desktop e mobile.

Sua filosofia central é a robustez. Diferente de linguagens que permitem "gambiarras", o Java força o desenvolvedor a escrever código estruturado e tipado, prevenindo erros em grandes escalas.

2. O Ecossistema: Para que serve?

• Aplicações Web: Desenvolvimento de sistemas robustos com Spring e Jakarta EE.
• Desenvolvimento Mobile: Aplicações Android com Java e Kotlin.
• Sistemas Corporativos: Softwares empresariais e sistemas de grande porte (ERP, CRM).
• Jogos: Desenvolvimento de jogos com a biblioteca LibGDX (ex: Minecraft foi feito em Java).
• IoT e Computação Embarcada: Dispositivos inteligentes e automação.

3. Instalação e Ambiente

Para começar a programar em Java, instale o JDK (Java Development Kit). Baixe a versão mais recente do site oficial da Oracle ou use o OpenJDK:

sudo apt install openjdk-17-jdk

Verifique a instalação com:

java -version

Dica Pro (SDKMAN): Se você usa Linux ou Mac, recomendo usar o sdkman para gerenciar múltiplas versões do Java (Java 8, 11, 17, 21) na mesma máquina facilmente.

4. Sintaxe e Comandos Essenciais

O Java é verboso por design, para garantir clareza.

5. Tipos de Dados Primitivos

Java é Fortemente Tipado. Cada variável precisa ter seu tipo declarado.

• int: Números inteiros (ex: 10, -5).
• double: Números decimais de dupla precisão (ex: 3.14).
• boolean: Lógica binária (true ou false).
• char: Um único caractere Unicode (ex: 'A').
• String: Sequência de caracteres (Objeto, não primitivo).

6. Hello World: A Estrutura Básica

Todo código Java deve estar dentro de uma class.

public class Main {
    public static void main(String[] args) {
        System.out.println("Olá, Mundo!");
    }
}

7. Orientação a Objetos (POO)

Java é uma linguagem totalmente orientada a objetos. Isso significa que tudo em Java é um objeto, exceto os tipos primitivos. Os 4 pilares são:

• Encapsulamento: Esconder detalhes internos (private) e expor apenas o necessário (public).
• Herança: Permite que uma classe herde atributos e métodos de outra classe (Reutilização de código).
• Polimorfismo: Permite que objetos de diferentes classes sejam tratados como objetos de uma classe base.
• Abstração: Simplificar a complexidade ao focar apenas nos aspectos essenciais (Interfaces e Classes Abstratas).

class Animal {
    void fazerSom() {
        System.out.println("Som do animal");
    }
}

class Cachorro extends Animal {
    @Override
    void fazerSom() {
        System.out.println("Au Au!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal meuCachorro = new Cachorro();
        meuCachorro.fazerSom(); // Au Au!
    }
}

8. Arquitetura JVM: Como funciona?

O lema do Java é "Write Once, Run Anywhere".

Java é multiplataforma porque o código-fonte (.java) é compilado para um formato intermediário chamado bytecode (.class). Esse bytecode não roda no processador, ele roda na JVM (Java Virtual Machine).

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

9. Gerenciamento de Memória (Garbage Collector)

Você não precisa deletar objetos da memória manualmente (como em C++). Java possui um Coletor de Lixo (Garbage Collector - GC) que passa periodicamente limpando objetos que não são mais usados.

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 1000000; i++) {
            // Cria objetos temporários que serão limpos pelo GC
            String temp = new String("Objeto " + i);
        }
    }
}

10. Java Standard Library (API)

A força do Java está nas suas bibliotecas nativas ("Baterias Inclusas").

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // ArrayList é uma lista dinâmica (cresce sozinha)
        ArrayList lista = new ArrayList<>();
        lista.add("Java");
        lista.add("Python");
        System.out.println(lista); // [Java, Python]
    }
}

11. Segurança

Java foi projetado para ambientes hostis (como a internet). A JVM possui um Security Manager que isola o código (Sandbox).

public class Main {
    public static void main(String[] args) {
        System.setSecurityManager(new SecurityManager());
        try {
            System.out.println("Tentando acessar arquivo...");
            new java.io.FileInputStream("arquivo.txt");
        } catch (Exception e) {
            System.out.println("Acesso negado: " + e.getMessage());
        }
    }
}

12. Concorrência (Multithreading)

Java possui suporte nativo para executar múltiplas tarefas ao mesmo tempo (Threads), vital para servidores modernos.

public class Main {
    public static void main(String[] args) {
        Runnable tarefa = () -> {
            System.out.println("Thread em execução");
        };
        Thread thread = new Thread(tarefa);
        thread.start();
    }
}

13. O Poder do Ecossistema: Spring Boot

Hoje em dia, raramente se usa Java puro para web. Usamos frameworks como Spring Boot que facilitam a criação de APIs REST.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }

    @GetMapping("/")
    public String hello() {
        return "Olá, Spring Boot!";
    }
}

14. Comunidade e Aplicações

Java tem uma das maiores comunidades de desenvolvedores do mundo. É a linguagem padrão para sistemas de alta performance, desde servidores da Amazon e Netflix até aplicativos Android.

15. Evolução: Java Moderno

O Java evoluiu. A versão Java 21 (LTS) trouxe recursos modernos como Records (classes de dados imutáveis) para reduzir a verbosidade.

// Record: Cria construtor, getters, toString e equals automaticamente
public record Pessoa(String nome, int idade) {}

public class Main {
    public static void main(String[] args) {
        Pessoa pessoa = new Pessoa("João", 25);
        System.out.println(pessoa.nome()); // João
        System.out.println(pessoa.idade()); // 25
    }
}

16. Ferramentas (IDEs)

• IntelliJ IDEA: A favorita do mercado atual. Poderosa e inteligente.
• Eclipse: Clássica, robusta e gratuita.
• Maven/Gradle: Gerenciadores de dependência essenciais.

17. Glossário: Palavras Reservadas

Lista de referência rápida para todas as keywords da linguagem.

18. Fundamentos da Lógica Java

Classes

Uma classe em Java é um modelo para criar objetos. Ela define atributos e métodos que os objetos terão. Exemplo:

class Animal {
    String nome;
    void emitirSom() {
        System.out.println("Som genérico");
    }
}

Métodos

Métodos são blocos de código que executam uma tarefa específica. Eles podem ter parâmetros e retornar valores.

class Calculadora {
    int somar(int a, int b) {
        return a + b;
    }
}

Estruturas de Controle

Como controlar o fluxo do seu programa:

Condicionais (Decisão)

if (idade >= 18) {
    System.out.println("Maior de idade");
} else {
    System.out.println("Menor de idade");
}

Laços de Repetição (Loops)

for (int i = 0; i < 5; i++) {
    System.out.println("Número: " + i);
}

while (contador < 5) {
    System.out.println("Contando: " + contador);
    contador++;
}

19. Resumo dos Fundamentos

Dominar o uso de classes, métodos e estruturas de controle é fundamental para se tornar um programador Java eficiente. As classes permitem organizar o código de forma modular, os métodos encapsulam comportamentos específicos, e as estruturas de controle garantem a lógica e o fluxo do programa. Com esses conceitos bem compreendidos, você estará preparado para desenvolver aplicações robustas, escaláveis e de fácil manutenção em Java.

20. Projeto Prático: CRUD Completo com Spring Boot

Vamos aplicar tudo o que aprendemos em um projeto real. O padrão MVC (Model-View-Controller) é o padrão da indústria para separar responsabilidades.

Estrutura de Diretórios Profissional

A organização é vital em projetos Java.

src/
├─ main/
│  ├─ java/com/exemplo/crud/
│  │  ├─ CrudApplication.java        // O ponto de partida
│  │  ├─ model/Item.java             // O Molde (Banco de Dados)
│  │  ├─ repository/ItemRepository.java // O Acesso aos Dados (SQL)
│  │  ├─ service/ItemService.java    // A Regra de Negócio
│  │  └─ controller/ItemController.java // A Porta de Entrada (API)
│  └─ resources/
│     └─ application.properties      // Configurações

1. Model (Entidade)

Representa a tabela no banco de dados.

package com.exemplo.crud.model;
  
import jakarta.persistence.*;
  
@Entity
public class Item {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
  
    private String nome;
    private String descricao;
  
    // Getters e Setters (Omissão para brevidade, mas são obrigatórios)
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
  
    public String getNome() { return nome; }
    public void setNome(String nome) { this.nome = nome; }
  
    public String getDescricao() { return descricao; }
    public void setDescricao(String descricao) { this.descricao = descricao; }
}

2. Repository (Camada de Dados)

Interface que herda do JPA para fazer as queries SQL automaticamente.

package com.exemplo.crud.repository;
  
import com.exemplo.crud.model.Item;
import org.springframework.data.jpa.repository.JpaRepository;
  
public interface ItemRepository extends JpaRepository<Item, Long> {
    // O Spring cria os métodos findAll, save, delete automaticamente!
}

3. Service (Regra de Negócio)

Aqui fica a lógica. O Controller chama o Service, e o Service chama o Repository.

package com.exemplo.crud.service;
  
import com.exemplo.crud.model.Item;
import com.exemplo.crud.repository.ItemRepository;
import org.springframework.stereotype.Service;
  
import java.util.List;
import java.util.Optional;
  
@Service
public class ItemService {
  
    private final ItemRepository itemRepository;
  
    public ItemService(ItemRepository itemRepository) {
        this.itemRepository = itemRepository;
    }
  
    public List<Item> listarTodos() {
        return itemRepository.findAll();
    }
  
    public Optional<Item> buscarPorId(Long id) {
        return itemRepository.findById(id);
    }
  
    public Item salvar(Item item) {
        return itemRepository.save(item);
    }
  
    public void excluir(Long id) {
        itemRepository.deleteById(id);
    }
}

4. Controller (API REST)

Define as rotas (endpoints) que o frontend ou mobile vão acessar.

package com.exemplo.crud.controller;

import com.exemplo.crud.model.Item;
import com.exemplo.crud.service.ItemService;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/itens")
public class ItemController {

    private final ItemService itemService;

    public ItemController(ItemService itemService) {
        this.itemService = itemService;
    }

    @GetMapping
    public List<Item> listar() {
        return itemService.listarTodos();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Item> buscar(@PathVariable Long id) {
        return itemService.buscarPorId(id)
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }

    @PostMapping
    public Item criar(@RequestBody Item item) {
        return itemService.salvar(item);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Item> atualizar(@PathVariable Long id, @RequestBody Item itemAtualizado) {
        return itemService.buscarPorId(id)
                .map(item -> {
                    item.setNome(itemAtualizado.getNome());
                    item.setDescricao(itemAtualizado.getDescricao());
                    return ResponseEntity.ok(itemService.salvar(item));
                })
                .orElse(ResponseEntity.notFound().build());
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> excluir(@PathVariable Long id) {
        if (itemService.buscarPorId(id).isPresent()) {
            itemService.excluir(id);
            return ResponseEntity.noContent().build();
        }
        return ResponseEntity.notFound().build();
    }
}

5. Configurações (application.properties)

Configura o banco de dados H2 (em memória) para testes rápidos.

spring.datasource.url=jdbc:h2:mem:cruddb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.jpa.show-sql=true

6. Rodando a Aplicação

Use o comando abaixo no terminal para iniciar a aplicação:

./mvnw spring-boot:run

Ou rode diretamente pela sua IDE (IntelliJ, VS Code, Eclipse...). Agora você tem uma API completa rodando!