Bloco 1 · Setup

Java em 2026

• JDK 21+ (Long Term Support).
• OpenJDK (gratuito) — Adoptium, Amazon Corretto.
• IDE: IntelliJ IDEA (Community, gratuito) ou VSCode.
• Build tool: Maven ou Gradle.

java --version
# openjdk 21.0.x
javac --version
# javac 21.0.x

Hello World

// HelloWorld.java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Olá mundo!");
    }
}

javac HelloWorld.java   # compila → HelloWorld.class
java HelloWorld         # executa

Toda a aplicação Java começa em public static void main.

Estrutura de projecto Maven

projecto/
├── pom.xml
└── src/
    ├── main/
    │   └── java/
    │       └── com/exemplo/App.java
    └── test/
        └── java/
            └── com/exemplo/AppTest.java

pom.xml = manifesto do projecto (dependências, plugins, build config).

Bloco 2 · Sintaxe

Tipos primitivos

int idade = 25;
long populacao = 8_000_000_000L;
double preco = 9.99;
float taxa = 0.21f;
boolean activo = true;
char letra = 'A';
String nome = "Ana";  // String é objecto, não primitivo

var (Java 10+) infere o tipo:

var idade = 25;       // int
var nome = "Ana";     // String
var lista = new ArrayList<String>();

Operadores

// Aritméticos
int soma = 5 + 3;        // 8
int divisao = 10 / 3;    // 3 (int division!)
double real = 10.0 / 3;  // 3.333

// Comparação
boolean igual = (a == b);
boolean diferente = (a != b);

// Lógicos
boolean ambos = a && b;
boolean qualquer = a || b;
boolean negacao = !a;

// String
String saudacao = "Olá, " + nome;

Estruturas controlo

// If
if (idade >= 18) {
    System.out.println("Adulto");
} else if (idade >= 13) {
    System.out.println("Adolescente");
} else {
    System.out.println("Criança");
}

// Switch (moderno)
String dia = switch(numeroDia) {
    case 1, 2, 3, 4, 5 -> "Útil";
    case 6, 7 -> "Fim-de-semana";
    default -> "Inválido";
};

Loops

// For tradicional
for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

// Enhanced for (foreach)
String[] nomes = {"Ana", "Bruno", "Carla"};
for (String nome : nomes) {
    System.out.println(nome);
}

// While
int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

Bloco 3 · OOP

Classes

public class Pessoa {
    // Atributos
    private String nome;
    private int idade;
    
    // Construtor
    public Pessoa(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }
    
    // Getters
    public String getNome() { return nome; }
    public int getIdade() { return idade; }
    
    // Método
    public void apresentar() {
        System.out.println("Olá, sou " + nome);
    }
}

Usar a classe

Pessoa p = new Pessoa("Ana", 25);
p.apresentar();              // Olá, sou Ana
System.out.println(p.getNome());  // Ana

Encapsulamento: atributos private, acesso via getters/setters.

Herança

public class Empregado extends Pessoa {
    private double salario;
    
    public Empregado(String nome, int idade, double salario) {
        super(nome, idade);   // chama construtor pai
        this.salario = salario;
    }
    
    @Override
    public void apresentar() {
        super.apresentar();
        System.out.println("Salário: " + salario + "€");
    }
}

@Override indica que método sobrepõe o do pai.

Interfaces

public interface Animal {
    void emitirSom();
    
    // Método default (Java 8+)
    default void dormir() {
        System.out.println("Zzz...");
    }
}

public class Cao implements Animal {
    @Override
    public void emitirSom() {
        System.out.println("Au au!");
    }
}

Uma classe pode implementar múltiplas interfaces.

Modificadores

public      // Acessível de qualquer lado
private     // Só dentro da classe
protected   // Classe + subclasses + mesmo package
(default)   // Só mesmo package

static      // Pertence à classe, não às instâncias
final       // Constante / não pode ser sobrescrito
abstract    // Não pode ser instanciado

Bloco 4 · Colecções

List (ArrayList)

import java.util.ArrayList;
import java.util.List;

List<String> nomes = new ArrayList<>();
nomes.add("Ana");
nomes.add("Bruno");
nomes.add("Carla");

System.out.println(nomes.size());      // 3
System.out.println(nomes.get(0));      // Ana
nomes.remove("Bruno");
nomes.contains("Ana");                 // true

for (String n : nomes) {
    System.out.println(n);
}

Map (HashMap)

import java.util.HashMap;
import java.util.Map;

Map<String, Integer> idades = new HashMap<>();
idades.put("Ana", 25);
idades.put("Bruno", 30);

System.out.println(idades.get("Ana"));   // 25
idades.containsKey("Ana");                // true

for (Map.Entry<String, Integer> e : idades.entrySet()) {
    System.out.println(e.getKey() + ": " + e.getValue());
}

Set (HashSet)

import java.util.HashSet;
import java.util.Set;

Set<String> unicos = new HashSet<>();
unicos.add("Ana");
unicos.add("Ana");      // ignorado, já existe
unicos.add("Bruno");

System.out.println(unicos.size());  // 2

Set = sem duplicados, sem ordem garantida.

Streams (funcional)

import java.util.stream.Collectors;

List<Integer> numeros = List.of(1, 2, 3, 4, 5);

// Filtrar pares e dobrar
List<Integer> resultado = numeros.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * 2)
    .collect(Collectors.toList());

// [4, 8]

// Soma
int soma = numeros.stream()
    .mapToInt(Integer::intValue)
    .sum();

Bloco 5 · Excepções

Try-catch

try {
    int resultado = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Erro: " + e.getMessage());
} finally {
    System.out.println("Sempre executa");
}

Checked exceptions: declaradas em assinaturas (throws).
Unchecked: RuntimeException e subclasses.

Throw / throws

public void sacarDinheiro(double valor) 
        throws SaldoInsuficienteException {
    if (valor > saldo) {
        throw new SaldoInsuficienteException(
            "Saldo: " + saldo + "€"
        );
    }
    saldo -= valor;
}

// Excepção custom
public class SaldoInsuficienteException extends Exception {
    public SaldoInsuficienteException(String msg) {
        super(msg);
    }
}

Bloco 6 · Ficheiros

Ler ficheiro

import java.nio.file.*;
import java.io.IOException;
import java.util.List;

// Tudo de uma vez
String conteudo = Files.readString(Path.of("dados.txt"));

// Linha a linha
List<String> linhas = Files.readAllLines(Path.of("dados.txt"));
for (String linha : linhas) {
    System.out.println(linha);
}

Escrever ficheiro

// Escrever string
Files.writeString(Path.of("output.txt"), "Olá mundo!");

// Escrever lista de linhas
List<String> linhas = List.of("linha 1", "linha 2", "linha 3");
Files.write(Path.of("output.txt"), linhas);

// Append
Files.writeString(
    Path.of("log.txt"), 
    "Nova entrada\n",
    StandardOpenOption.APPEND
);

Bloco 7 · JDBC

Conectar a MySQL

import java.sql.*;

String url = "jdbc:mysql://localhost:3306/loja";
String user = "root";
String password = "senha";

try (Connection conn = DriverManager.getConnection(url, user, password)) {
    String sql = "SELECT * FROM produtos";
    try (PreparedStatement stmt = conn.prepareStatement(sql);
         ResultSet rs = stmt.executeQuery()) {
        
        while (rs.next()) {
            System.out.println(rs.getString("nome"));
            System.out.println(rs.getDouble("preco"));
        }
    }
}

INSERT / UPDATE com parâmetros

String sql = "INSERT INTO produtos (nome, preco) VALUES (?, ?)";

try (PreparedStatement stmt = conn.prepareStatement(sql)) {
    stmt.setString(1, "Caneta");
    stmt.setDouble(2, 1.50);
    stmt.executeUpdate();
}

Usar sempre PreparedStatement — evita SQL injection.

Bloco 8 · Boas práticas

Convenções

• Classes: PascalCase (Pessoa, BancoCentral).
• Métodos/variáveis: camelCase (getNome, totalVendas).
• Constantes: UPPER_SNAKE (MAX_TENTATIVAS).
• Packages: lowercase.dotted (com.empresa.app).

Maven dependency exemplo

<dependencies>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version>
  </dependency>
  <dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
  </dependency>
</dependencies>