UC00619

Programação em Java

OOP, colecções, ficheiros, JDBC

Curso profissional · 50h · Linguagem industrial

Plano

  1. Setup: JDK + IDE
  2. Sintaxe básica
  3. OOP em Java
  4. Colecções (List, Map, Set)
  5. Excepções e tratamento de erros
  6. Ficheiros e I/O
  7. JDBC — base de dados
  8. Projecto final

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>

UC00619 · resumo

  • Java é tipado, OOP, multi-plataforma (JVM).
  • OOP: classes, herança, interfaces, encapsulamento.
  • Colecções: List, Map, Set + Streams.
  • Excepções com try/catch para erros recuperáveis.
  • Ficheiros com Files.readString / writeString.
  • JDBC + PreparedStatement para BD.
  • Maven para build e dependências.
  • Base para Spring Boot, Android, sistemas enterprise.

NOTAS DO PROFESSOR 📖 O ecossistema Java em 2026 Importa que os formandos percebam o papel das versões LTS: são as que recebem suporte prolongado e as que as empresas usam em produção. O OpenJDK gratuito remove a barreira de licenciamento. Distinguir `java` (executar) de `javac` (compilar) prepara o conceito de código compilado que vem a seguir. 🗣️ Pontos a desenvolver oralmente • Explicar o que significa LTS e porque não se escolhe sempre a versão mais recente. • Clarificar que existem vários distribuidores de OpenJDK, todos compatíveis. • Referir que a escolha entre Maven e Gradle não muda o código, só o build.

NOTAS DO PROFESSOR 📖 O ciclo compilar-executar Ao contrário de Python, Java é compilado: o `javac` transforma o `.java` em bytecode `.class` que a JVM executa. Este passo extra deteta muitos erros antes do programa correr. A rigidez do `public static void main` e do nome de classe igual ao ficheiro confunde no início, mas é previsível. 🗣️ Pontos a desenvolver oralmente • Demonstrar os dois passos (`javac` depois `java`) e mostrar o ficheiro `.class` gerado. • Explicar o papel da JVM como camada que torna Java multi-plataforma. • Decompor `public static void main(String[] args)` palavra a palavra.

NOTAS DO PROFESSOR 📖 Convenção sobre configuração O Maven impõe uma estrutura de pastas padrão que todos os projetos Java seguem, o que torna qualquer projeto familiar. O `pom.xml` centraliza dependências e build, evitando descarregar bibliotecas à mão. A correspondência entre packages e pastas é obrigatória e merece ênfase. 🗣️ Pontos a desenvolver oralmente • Mostrar que `src/main` é o código e `src/test` os testes, por convenção. • Explicar como o Maven descarrega dependências automaticamente do repositório central. • Ligar a estrutura de pastas `com/exemplo` à declaração de `package`.

NOTAS DO PROFESSOR 📖 Tipagem estática e tipos primitivos Em Java cada variável tem um tipo fixo declarado, e o compilador rejeita atribuições incompatíveis. A distinção entre primitivos (int, double) e objetos (String) é central. O `var` infere o tipo mas continua estático — não torna Java dinâmico como Python. 🗣️ Pontos a desenvolver oralmente • Explicar a diferença entre primitivos e tipos de referência (objetos). • Mostrar os sufixos `L` e `f` e porque são necessários. • Esclarecer que `var` só funciona em variáveis locais com valor inicial.

NOTAS DO PROFESSOR 📖 O perigo da divisão inteira O caso `10 / 3` dar 3 (e não 3.333) é um erro clássico: quando ambos os operandos são inteiros, o resultado é inteiro. Basta um ser `double` para obter resultado real. Convém também distinguir `==` (comparação) de `=` (atribuição), confusão frequente. 🗣️ Pontos a desenvolver oralmente • Demonstrar `10 / 3` vs `10.0 / 3` e explicar a promoção de tipos. • Avisar que `==` em objetos compara referências, não conteúdo (preparar `.equals`). • Mostrar o curto-circuito de `&&` e `||`.

NOTAS DO PROFESSOR 📖 O switch moderno é mais seguro O switch com seta (`->`) eliminou o velho problema do "fall-through" que obrigava a escrever `break` em cada caso. Além disso pode devolver um valor diretamente, o que o torna mais expressivo. As chavetas são obrigatórias mesmo em blocos de uma linha, ao contrário de Python. 🗣️ Pontos a desenvolver oralmente • Contrastar o switch novo com o antigo e o bug do `break` esquecido. • Mostrar como agrupar vários casos com vírgulas. • Reforçar o papel das chavetas para delimitar blocos.

NOTAS DO PROFESSOR 📖 Três formas de iterar O `for` tradicional dá controlo total sobre o índice; o enhanced for (foreach) é mais limpo quando só se quer percorrer elementos; o `while` serve quando o número de iterações é desconhecido. Convém ensinar a escolher o ciclo certo conforme a situação, não usar sempre o mesmo. 🗣️ Pontos a desenvolver oralmente • Mostrar quando o foreach é preferível ao for tradicional. • Demonstrar o erro de off-by-one (usar `<=` em vez de `<`). • Ligar o foreach às coleções que virão no bloco seguinte.

NOTAS DO PROFESSOR 📖 A classe como unidade fundamental de Java Em Java tudo vive dentro de classes. Esta primeira classe junta os pilares da OOP: atributos privados (estado), construtor (inicialização) e métodos (comportamento). O `this` distingue o atributo do parâmetro com o mesmo nome — ponto a explicar com calma. 🗣️ Pontos a desenvolver oralmente • Explicar porque os atributos são `private` por omissão (encapsulamento). • Esclarecer o papel do construtor e o uso de `this`. • Distinguir o molde (classe) das instâncias criadas com `new`.

NOTAS DO PROFESSOR 📖 Criar e usar objetos O `new` aloca um novo objeto e chama o construtor. O acesso ao estado faz-se através de métodos públicos (getters), nunca diretamente aos campos privados. Este padrão getter/setter é tão omnipresente em Java que as IDEs o geram automaticamente. 🗣️ Pontos a desenvolver oralmente • Demonstrar a geração automática de getters/setters na IDE. • Explicar a vantagem de aceder via método: permite validar ou alterar lógica depois. • Mostrar que cada `new` cria um objeto independente com o seu estado.

NOTAS DO PROFESSOR 📖 Herança e reutilização de código O `extends` permite que uma classe herde atributos e métodos da mãe, e o `super` invoca a versão da mãe — tanto no construtor como num método sobreposto. A anotação `@Override` é mais do que decoração: faz o compilador verificar que realmente se está a sobrepor um método existente. 🗣️ Pontos a desenvolver oralmente • Explicar a obrigatoriedade de chamar `super(...)` no construtor da subclasse. • Mostrar como `@Override` deteta erros de assinatura mal escrita. • Distinguir estender (herança) de implementar (interface), que vem a seguir.

NOTAS DO PROFESSOR 📖 Contratos sem implementação A interface define o que uma classe deve fazer, sem dizer como. É a forma de Java garantir que classes distintas partilham um conjunto de comportamentos, permitindo polimorfismo. Como uma classe só herda de uma mãe mas implementa várias interfaces, são a solução para "herança múltipla" de comportamento. 🗣️ Pontos a desenvolver oralmente • Contrastar interface (contrato) com classe abstrata. • Explicar os métodos default e porque foram acrescentados no Java 8. • Dar um exemplo de código que trabalha com o tipo interface, não com a classe concreta.

NOTAS DO PROFESSOR 📖 Controlar visibilidade e comportamento Os modificadores de acesso definem quem pode usar cada membro, sustentando o encapsulamento. Os modificadores não-de-acesso (`static`, `final`, `abstract`) alteram comportamento: `static` pertence à classe, `final` impede alteração, `abstract` obriga a especializar. Dominar estes conceitos é essencial para ler código real. 🗣️ Pontos a desenvolver oralmente • Esclarecer a diferença entre membro de instância e membro `static`. • Dar exemplos práticos de `final` (constantes, classes não-extensíveis). • Explicar porque uma classe `abstract` não pode ser instanciada diretamente.

NOTAS DO PROFESSOR 📖 Listas dinâmicas com generics O `ArrayList` é a lista de tamanho variável do dia-a-dia, ao contrário dos arrays fixos. Os generics `<String>` garantem em tempo de compilação que só entram elementos do tipo certo. Convém programar para a interface `List` e não para a implementação `ArrayList`. 🗣️ Pontos a desenvolver oralmente • Contrastar arrays de tamanho fixo com o ArrayList dinâmico. • Explicar o valor dos generics para apanhar erros de tipo cedo. • Mostrar porque se declara `List` e se instancia `ArrayList`.

NOTAS DO PROFESSOR 📖 Associações chave-valor O `HashMap` é o equivalente Java ao dicionário: guarda pares chave→valor com acesso rápido. A iteração faz-se sobre o `entrySet()`, que dá acesso simultâneo a chave e valor. Convém alertar que a ordem de iteração não é garantida num HashMap. 🗣️ Pontos a desenvolver oralmente • Mostrar `get`, `put` e `containsKey` como operações essenciais. • Explicar o padrão `Map.Entry` para percorrer o mapa. • Referir alternativas ordenadas (LinkedHashMap, TreeMap) para quando a ordem importa.

NOTAS DO PROFESSOR 📖 Coleções sem repetidos O `HashSet` rejeita silenciosamente elementos duplicados, sendo ideal para garantir unicidade. A escolha entre List, Set e Map deve guiar-se pela pergunta: a ordem importa? Há duplicados? Preciso de associar chaves a valores? Esta decisão é uma competência prática importante. 🗣️ Pontos a desenvolver oralmente • Mostrar que adicionar um duplicado não dá erro, simplesmente não acontece. • Construir uma tabela de decisão List vs Set vs Map. • Referir que igualdade no Set depende de `equals` e `hashCode`.

NOTAS DO PROFESSOR 📖 Estilo funcional sobre coleções As Streams permitem processar coleções de forma declarativa, encadeando operações (filter, map, collect) numa pipeline legível. Substituem ciclos verbosos por uma descrição do que se quer. Convém clarificar que a stream não altera a coleção original — produz um novo resultado. 🗣️ Pontos a desenvolver oralmente • Comparar a mesma transformação com um ciclo `for` e com stream. • Explicar operações intermédias (lazy) vs terminais (collect, sum). • Introduzir a sintaxe lambda `n -> n * 2` para quem vem de Python.

NOTAS DO PROFESSOR 📖 Erros recuperáveis vs erros de programação O try/catch permite reagir a falhas em runtime. A distinção Java entre checked (obrigatório declarar/apanhar) e unchecked (runtime) é particular da linguagem e merece atenção. O `finally` corre sempre, sendo o lugar para libertar recursos. 🗣️ Pontos a desenvolver oralmente • Dar exemplos concretos de checked (IOException) e unchecked (NullPointer). • Explicar porque apanhar `Exception` genérica esconde problemas. • Mostrar o try-with-resources como evolução do finally para fechar recursos.

NOTAS DO PROFESSOR 📖 Lançar e propagar exceções O `throw` levanta uma exceção e o `throws` na assinatura declara que o método pode falhar, obrigando quem chama a tratar. Criar exceções personalizadas dá mensagens de erro com significado de negócio (SaldoInsuficiente), muito mais úteis do que erros genéricos. 🗣️ Pontos a desenvolver oralmente • Distinguir `throw` (ação) de `throws` (declaração na assinatura). • Justificar quando vale a pena criar uma exceção personalizada. • Mostrar como a mensagem da exceção ajuda na depuração.

NOTAS DO PROFESSOR 📖 A API moderna de ficheiros A classe `Files` do pacote NIO tornou a leitura de ficheiros trivial: uma linha para ler tudo ou todas as linhas. Convém referir que estes métodos lançam `IOException`, uma checked exception que tem de ser tratada. Para ficheiros muito grandes há alternativas que não carregam tudo na memória. 🗣️ Pontos a desenvolver oralmente • Mostrar a evolução face às antigas classes de I/O baseadas em streams. • Avisar sobre o consumo de memória ao ler ficheiros enormes de uma só vez. • Ligar a `IOException` ao tema das checked exceptions.

NOTAS DO PROFESSOR 📖 Escrever e acrescentar Por omissão, escrever num ficheiro substitui todo o conteúdo; é preciso a opção `APPEND` para acrescentar sem apagar. Esta distinção é fonte frequente de perda acidental de dados. Convém demonstrar os dois comportamentos lado a lado. 🗣️ Pontos a desenvolver oralmente • Avisar que `writeString` sem APPEND apaga o que já lá estava. • Mostrar o caso de uso típico de APPEND: ficheiros de log. • Reforçar que escrever em ficheiro também pode lançar IOException.

NOTAS DO PROFESSOR 📖 Ligar a aplicação à base de dados O JDBC é a ponte entre Java e a base de dados relacional. O try-with-resources garante que a ligação e os statements são fechados automaticamente — fundamental para não esgotar ligações. O `ResultSet` percorre as linhas devolvidas com `next()`. 🗣️ Pontos a desenvolver oralmente • Explicar a importância de fechar ligações e como o try-with-resources ajuda. • Mostrar o padrão de iterar o ResultSet com `while (rs.next())`. • Referir que em projetos reais se usa muitas vezes uma camada ORM por cima do JDBC.

NOTAS DO PROFESSOR 📖 Parâmetros protegem contra SQL injection Os placeholders `?` separam o comando SQL dos dados, impedindo que input malicioso altere a query. Esta é uma das lições de segurança mais importantes do curso. Concatenar valores diretamente na string SQL é uma vulnerabilidade clássica que nunca se deve cometer. 🗣️ Pontos a desenvolver oralmente • Demonstrar como uma string concatenada permite SQL injection. • Explicar que `setString`/`setDouble` tratam o escaping automaticamente. • Ligar este tema à responsabilidade profissional de proteger dados.

NOTAS DO PROFESSOR 📖 Convenções tornam o código universal Estas convenções de nomenclatura são seguidas por toda a comunidade Java, pelo que respeitá-las torna o código imediatamente legível por qualquer programador. Não são impostas pelo compilador, mas desviar delas marca código amador. As IDEs avisam quando se quebra a convenção. 🗣️ Pontos a desenvolver oralmente • Mostrar como a IDE sinaliza nomes fora da convenção. • Explicar que nomes descritivos valem mais do que abreviaturas curtas. • Ligar a convenção de packages à estrutura de pastas vista antes.

NOTAS DO PROFESSOR 📖 Gerir dependências de forma declarativa Cada `<dependency>` é identificada por grupo, artefacto e versão — as coordenadas que o Maven usa para descarregar a biblioteca. O `<scope>test</scope>` indica que o JUnit só é necessário durante os testes, não em produção. Isto evita o caos de gerir JARs manualmente. 🗣️ Pontos a desenvolver oralmente • Explicar as três coordenadas: groupId, artifactId, version. • Mostrar o significado dos scopes (compile, test, provided). • Demonstrar como acrescentar uma nova dependência e o Maven a descarrega.

NOTAS DO PROFESSOR 📖 Java como porta de entrada para o mundo enterprise Este resumo recapitula os pilares: OOP rigorosa, coleções tipadas, tratamento de erros e acesso a dados. Vale a pena sublinhar que estas bases sustentam frameworks como Spring Boot e o desenvolvimento Android, abrindo caminhos de carreira concretos. A disciplina da tipagem estática é um investimento que compensa em projetos grandes. 🗣️ Pontos a desenvolver oralmente • Pedir aos formandos que comparem Java com outra linguagem que conheçam. • Apontar Spring Boot e Android como destinos naturais de aprofundamento. • Reforçar que a rigidez de Java é um aliado em equipas e projetos de longa vida.