Java (UC00619)

Há um pacote premium desta unidade: um PowerPoint editável de 100 ou mais diapositivos, um manual em PDF e dois testes com correção. Esta sebenta continua gratuita.

Introdução

Java é uma das linguagens mais usadas no mundo. Criada em 1995 pela Sun Microsystems (hoje Oracle), domina bancos, sistemas empresariais, Android, big data (Hadoop, Spark) e milhares de aplicações que provavelmente usas todos os dias. Aprender Java significa entrar num ecossistema vasto, maduro e bem remunerado.

Esta sebenta cobre Java moderno (JDK 17 e 21, ambas versões de suporte prolongado) com programação orientada por objetos completa, coleções, exceções, ficheiros, JDBC para bases de dados, testes e princípios de boa engenharia. Segue o percurso de um programador a sério: primeiro pensa-se no problema (algoritmos e planeamento), depois prepara-se o ambiente, depois escreve-se, testa-se e corrige-se.

No fim da unidade deves ser capaz de:

• Planear as etapas de desenvolvimento de uma aplicação, do requisito ao código entregue.
• Estruturar programas em classes, interfaces e pacotes, num projeto Maven.
• Testar e depurar programas, escrevendo testes automáticos e corrigindo os erros que eles revelam.
• Interpretar a documentação técnica (API, manuais, tutoriais) e desenhar a interface com o utilizador antes de a programar.
• Documentar o que fizeste num guião técnico ou manual de utilizador, respeitando normas e convenções.

Cada capítulo alterna blocos curtos, que ilustram uma instrução, com exemplos resolvidos completos, que têm uma classe com main e podes copiar para o teu computador e correr. Escrever o código à mão, em vez de o colar, é a diferença entre reconhecer Java e saber Java.

1. Java em contexto

Características-chave

• Compilado para bytecode: corre na JVM (Java Virtual Machine), funciona em qualquer sistema operativo sem recompilar.
• Tipado estaticamente: os tipos são verificados em compilação, o que evita muitos erros em execução.
• Orientado por objetos: quase tudo é classe (exceto os oito tipos primitivos).
• Com recolha automática de memória (garbage collector): não libertas memória à mão.
• Maduro: cerca de 30 anos de evolução e um ecossistema gigantesco.

Onde se usa Java

• Backend empresarial: Spring Boot, Jakarta EE.
• Android: Java e Kotlin, interoperáveis.
• Big Data: Hadoop, Spark, Kafka.
• Sistemas financeiros: bancos, seguradoras, trading.
• IDEs: IntelliJ IDEA, Eclipse e Android Studio são escritos em Java ou Kotlin.
• Ferramentas de build: Maven e Gradle correm na JVM.

Quando NÃO usar Java

• Scripting rápido: Python.
• Interfaces no navegador: JavaScript.
• Sistemas de baixo nível: C ou Rust.
• Protótipos descartáveis: Python ou Node.

Mas para aplicações grandes, com equipas grandes, que vão durar mais de 10 anos, Java continua a ser uma escolha muito sólida.

Do código-fonte à execução

Escreves ficheiros .java (código-fonte). O compilador javac traduz-os para ficheiros .class com bytecode, uma linguagem intermédia que não é de nenhum processador em concreto. A JVM lê o bytecode e executa-o, traduzindo-o para instruções do processador onde está a correr. É por isto que o mesmo .class corre em Windows, Linux e macOS.

Se o compilador encontra um erro (um ; em falta, um tipo errado), não gera .class. Estes são erros de compilação. Os erros que só aparecem quando o programa já está a correr (dividir por zero, aceder a um índice inexistente) são erros de execução. Os que não rebentam nada mas dão um resultado errado são erros lógicos, os mais difíceis de apanhar.

JDK, JRE e JVM

• JVM: a máquina virtual que executa o bytecode.
• JRE: JVM mais as bibliotecas standard, o necessário para correr aplicações.
• JDK: JRE mais as ferramentas de desenvolvimento (javac, jar, javadoc).

Quem desenvolve instala o JDK. Quem só usa uma aplicação precisa apenas do ambiente de execução.

Memória: stack e heap

A JVM organiza a memória em duas zonas principais:

• Stack (pilha): guarda as variáveis locais e as chamadas de métodos. Cada chamada cria uma "moldura" que desaparece quando o método termina.
• Heap (monte): guarda os objetos. Uma variável de tipo objeto na stack guarda apenas uma referência (uma seta) para o objeto no heap.

Quando um objeto deixa de ter referências a apontar para ele, o garbage collector pode libertar a memória. Não sabes quando acontece, e não precisas de saber.

int idade = 30;              // valor guardado diretamente na stack
String nome = "Ana";         // referência na stack, objeto String no heap
String outro = nome;         // duas referências para o MESMO objeto

2. Pensamento computacional e algoritmos

Antes de escrever código, é preciso saber o que se quer resolver. Programar é, em grande parte, pensar. O pensamento computacional é a forma de resolver problemas de modo que um computador (ou uma pessoa) consiga executar a solução.

Os quatro pilares

O que é um algoritmo

Um algoritmo é uma sequência finita e ordenada de passos que resolve um problema. Tem de ser:

• Não ambíguo: cada passo diz exatamente o que fazer.
• Finito: termina sempre.
• Com entradas e saídas: recebe dados e produz um resultado.
• Eficaz: cada passo é executável.

Um algoritmo pode ser escrito em linguagem natural, em pseudocódigo ou desenhado como fluxograma. Só depois é traduzido para Java.

As três estruturas de qualquer algoritmo

1. Sequência: os passos executam-se por ordem.
2. Seleção: um passo depende de uma condição (se ... então ... senão).
3. Repetição: um conjunto de passos repete-se enquanto uma condição for verdadeira.

Tudo o que vais escrever em Java combina estas três ideias.

Exemplo resolvido · Maior de três números

Problema: dados três números inteiros, indicar o maior.

Pseudocódigo:

INÍCIO
  LER a, b, c
  maior <- a
  SE b > maior ENTÃO maior <- b
  SE c > maior ENTÃO maior <- c
  ESCREVER maior
FIM

Teste de mesa (executar o algoritmo à mão com a = 4, b = 9, c = 7):

Tradução para Java:

public class MaiorDeTres {
    public static void main(String[] args) {
        int a = 4, b = 9, c = 7;
        int maior = a;
        if (b > maior) {
            maior = b;
        }
        if (c > maior) {
            maior = c;
        }
        System.out.println("Maior: " + maior);   // Maior: 9
    }
}

Exemplo resolvido · Número primo

Problema: indicar se um número inteiro n >= 2 é primo.

Ideia: um número é primo se nenhum inteiro entre 2 e a sua raiz quadrada o divide exatamente. Basta testar até à raiz porque, se n tem um divisor maior do que a raiz, tem também um menor.

INÍCIO
  LER n
  primo <- verdadeiro
  PARA d DE 2 ATÉ raiz(n)
     SE n mod d = 0 ENTÃO primo <- falso
  FIM PARA
  ESCREVER primo
FIM

public class Primos {

    static boolean ehPrimo(int n) {
        if (n < 2) {
            return false;
        }
        for (int d = 2; d * d <= n; d++) {
            if (n % d == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int[] testes = {2, 9, 13, 25, 29};
        for (int t : testes) {
            System.out.println(t + " é primo? " + ehPrimo(t));
        }
    }
}

Saída: 2 é primo? true, 9 é primo? false, 13 é primo? true, 25 é primo? false, 29 é primo? true. A condição d * d <= n evita calcular a raiz quadrada.

Complexidade, em duas palavras

Dois algoritmos corretos podem ter custos muito diferentes. Procurar um valor numa lista não ordenada obriga, no pior caso, a olhar para todos os elementos (cresce linearmente com o tamanho). Procurar num conjunto organizado por chave (HashMap) é, em média, quase instantâneo. Mais à frente vais escolher a estrutura de dados certa com este critério.

3. Planeamento e metodologias de desenvolvimento

Porque se planeia

Escrever código sem planear dá programas que funcionam na primeira demonstração e se tornam impossíveis de alterar na terceira. Planear as etapas reduz o retrabalho e permite estimar prazos.

Fases do desenvolvimento de software

Metodologias

Cascata (waterfall): as fases fazem-se uma a uma, sem voltar atrás. Funciona quando os requisitos são estáveis e conhecidos de antemão (um contrato público com especificações fechadas, por exemplo). Falha quando o cliente só percebe o que quer ao ver o produto.

Metodologias ágeis (Scrum, Kanban): o trabalho divide-se em ciclos curtos (em Scrum, os sprints, tipicamente de uma a quatro semanas). No fim de cada ciclo há uma versão utilizável e o cliente dá feedback. Os requisitos mudam sem drama.

Nesta unidade vais trabalhar de forma ágil e simplificada: pequenas entregas, testes à medida que avanças, versões guardadas em Git.

Requisitos e histórias de utilizador

Um requisito funcional descreve o que o sistema faz; um requisito não funcional descreve como (desempenho, segurança, usabilidade). Uma história de utilizador escreve-se numa frase: Como [papel], quero [funcionalidade] para [benefício].

Exemplo resolvido · Planear uma aplicação de biblioteca

Enunciado: a biblioteca da escola quer registar livros e empréstimos.

Passo 1, histórias de utilizador

• Como bibliotecário, quero registar um livro novo para o ter no catálogo.
• Como bibliotecário, quero emprestar um livro a um leitor para saber quem o tem.
• Como bibliotecário, quero listar os livros em atraso para os reclamar.

Passo 2, identificar nomes e verbos. Os nomes sugerem classes (Livro, Leitor, Emprestimo). Os verbos sugerem métodos (registar, emprestar, devolver).

Passo 3, decompor em etapas e estimar

Passo 4, ordenar por dependência e risco. O modelo vem antes das regras; a persistência depende do modelo; os testes acompanham cada etapa e não ficam para o fim.

Diagrama de classes (UML)

O diagrama de classes mostra as classes, os seus atributos, métodos e as relações entre elas. Cada caixa tem três compartimentos: nome, atributos, métodos. Em texto:

+-----------------+       +----------------------+       +-----------------+
|     Leitor      |       |      Emprestimo      |       |      Livro      |
+-----------------+       +----------------------+       +-----------------+
| - nome: String  | 1   * | - data: LocalDate    | *   1 | - titulo: String|
| - numero: int   |-------| - devolvido: boolean |-------| - isbn: String  |
+-----------------+       +----------------------+       +-----------------+
| + pedir(Livro)  |       | + devolver()         |       | + getTitulo()   |
+-----------------+       +----------------------+       +-----------------+

- indica private, + indica public. Os números nas pontas (1 e *) são a multiplicidade: um leitor pode ter muitos empréstimos; cada empréstimo é de um só leitor.

Desenhar a interface

A interface com o utilizador é tudo o que a pessoa vê e escreve: menus, perguntas, resultados e mensagens de erro. Desenha-se antes de programar, num esboço em texto ou no papel, porque é mais barato corrigir um esboço do que um programa. Três regras ajudam: uma ação por opção de menu; feedback claro depois de cada ação; mensagens de erro que dizem o que correu mal e o que fazer a seguir.

Exemplo resolvido · Desenhar a interface da biblioteca

Passo 1, o esboço do menu principal

=== Biblioteca da Escola ===
1. Registar livro
2. Emprestar livro
3. Devolver livro
4. Listar livros em atraso
0. Sair
Opção: _

Passo 2, o fluxo entre ecrãs. Cada opção leva a um pequeno ecrã de perguntas e regressa sempre ao menu principal:

Opção 2 (Emprestar)
  1. Pede o ISBN
       ISBN desconhecido -> mensagem de erro e volta a pedir
  2. Pede o número do leitor
       leitor desconhecido -> mensagem de erro e volta a pedir
  3. Livro já emprestado -> mensagem de erro e volta ao menu principal
  4. Tudo certo -> confirma o empréstimo e volta ao menu principal

Passo 3, mensagens. Escrevem-se à partida, para serem consistentes:

Passo 4, validação. A entrada do utilizador nunca é de confiança: o número do menu lê-se como texto e converte-se com tratamento de erro (capítulo 10), repetindo a pergunta até ser válida.

Normas, regulamentos e licenças

Programar para o mundo real obriga a cumprir regras:

• Convenções de código: o guia de estilo da equipa ou os nomes e formatação habituais de Java (ver capítulo 14).
• RGPD (Regulamento Geral sobre a Proteção de Dados): se a aplicação guarda dados pessoais (nomes, moradas, NIF), é preciso ter fundamento legal, recolher o mínimo necessário e proteger os dados. Uma palavra-passe nunca se guarda em texto simples.
• Licenças de software: cada biblioteca que usas tem uma licença (por exemplo Apache 2.0, MIT, GPL) que define o que podes fazer com ela. Convém conhecê-las antes de distribuir um produto.
• Direitos de autor: não copies código que não podes reutilizar e cita a fonte quando o adaptas.
• Acessibilidade e usabilidade: mesmo numa aplicação de consola, mensagens claras e consistentes.

4. Ambiente de desenvolvimento

Instalar o JDK

JDK = Java Development Kit (compilador + ferramentas). JRE = Java Runtime Environment (só corre, não desenvolve).

Recomendado:

• Adoptium Temurin 21 (LTS), gratuito e de código aberto.
• Amazon Corretto 21, alternativa empresarial gratuita.

Verifica:

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

javac --version
# javac 21.0.x

Se o terminal responder "comando não encontrado", o JDK não está no PATH (a lista de pastas onde o sistema procura programas). Define também a variável JAVA_HOME com a pasta de instalação do JDK; o Maven usa-a para saber qual Java usar.

Editor de texto ou IDE

Um editor de texto (Bloco de Notas, Notepad++, VS Code sem extensões) edita ficheiros mas não compreende Java. Um IDE (ambiente de desenvolvimento integrado) junta editor, compilador, depurador, gestor de dependências e controlo de versões.

IDEs usados:

• IntelliJ IDEA, padrão de facto. A JetBrains tem reorganizado as suas edições; confirma no site oficial as condições de utilização gratuita em vigor.
• Eclipse IDE for Java Developers.
• VS Code com a extensão "Extension Pack for Java".

IntelliJ oferece a melhor experiência: importação automática, refatoração poderosa, navegação inteligente. Mesmo assim, convém saber usar um editor simples e o terminal, porque em servidores e em contexto de teste vais encontrar apenas isso.

Funcionalidades de editor que poupam horas: procurar e substituir (com expressões regulares), edição com vários cursores, atalhos para comentar linhas, indentação automática, ir para a definição, formatar documento.

Hello World sem IDE

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

Compila e corre:

javac HelloWorld.java   # gera HelloWorld.class
java HelloWorld         # corre (sem .class)

O nome do ficheiro tem de coincidir com o da classe pública (HelloWorld.java para public class HelloWorld), incluindo maiúsculas.

Execução de ficheiro único (Java 11 ou superior)

java HelloWorld.java    # compila e corre diretamente

Útil para scripts rápidos.

Anatomia do main

• public: o método é visível a todos, incluindo à JVM que o vai chamar.
• static: pertence à classe, por isso a JVM chama-o sem criar um objeto.
• void: não devolve valor.
• String[] args: os argumentos da linha de comandos (java App um dois dá args[0] igual a "um").

Depurar com o IDE

O depurador deixa executar o programa passo a passo:

1. Clica na margem esquerda de uma linha para pôr um breakpoint (ponto de paragem).
2. Executa em modo Debug: o programa pára nessa linha.
3. Step Over avança uma linha; Step Into entra no método chamado; Step Out sai do método atual.
4. Observa as variáveis e as watches (expressões que escolhes acompanhar).
5. Descobre a linha em que o valor passa de certo a errado. Aí está o defeito.

Depurar é mais fiável do que espalhar System.out.println por todo o lado, e quase sempre mais rápido.

Exemplo resolvido · Ler um erro do compilador

public class Teste {
    public static void main(String[] args) {
        int x = "dez";
        System.out.println(x)
    }
}

O compilador devolve algo como:

Teste.java:4: error: ';' expected
        System.out.println(x)
                             ^
1 error

A mensagem traz o ficheiro, a linha e a descrição, e o ^ aponta o sítio. Na linha 4 falta o ;. O código tem ainda outro erro, na linha 3 (atribuímos texto a um int), mas o compilador não o mostra: um erro de sintaxe é detetado logo na leitura do ficheiro e a compilação pára aí. Corrigido o ponto e vírgula, o compilador passa à análise de tipos e só então mostra:

Teste.java:3: error: incompatible types: String cannot be converted to int
        int x = "dez";
                ^
1 error

Por isso se compila de novo depois de cada correção, começando pelo primeiro erro que aparece.

Ler documentação técnica

Quase tudo o que precisas de saber sobre uma classe de Java está na documentação oficial, a API (em Java 21, docs.oracle.com/en/java/javase/21/docs/api). Uma página de classe segue sempre a mesma ordem: o pacote e a hierarquia no topo, uma descrição geral, depois a lista de construtores (Constructor Summary) e de métodos (Method Summary), cada um com a assinatura, a descrição, os parâmetros, o valor devolvido e as exceções que pode lançar. Os tutoriais (por exemplo em dev.java) explicam o porquê e dão exemplos; os manuais das ferramentas (mvn, javac) listam as opções; um README diz como instalar e correr um projeto; um pom.xml alheio mostra de que bibliotecas o projeto depende.

Exemplo resolvido · Aprender removeIf na documentação

Objetivo: remover de uma lista todas as notas negativas (inferiores a 10) sem escrever um ciclo.

1. Procura na API a classe java.util.ArrayList. Em Constructor Summary há três construtores: ArrayList(), ArrayList(int initialCapacity) e ArrayList(Collection<? extends E> c). O último cria uma lista com cópia dos elementos de outra coleção.
2. Em Method Summary procura removeIf. A assinatura é boolean removeIf(Predicate<? super E> filter). Lê-se: recebe um critério (um Predicate, uma função que devolve true ou false para cada elemento), remove os elementos para os quais o critério dá true e devolve true se removeu algum.
3. Aplica:

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

List<Integer> notas = new ArrayList<>(List.of(8, 15, 6, 12));
boolean mudou = notas.removeIf(n -> n < 10);
System.out.println(notas + " " + mudou);

Resultado: [15, 12] true. Repara que a lista foi criada com new ArrayList<>(List.of(...)), o terceiro construtor: List.of devolve uma lista imutável e removeIf falharia sobre ela com UnsupportedOperationException.

5. Projeto Maven

Para projetos reais, usa Maven (ou Gradle). O Maven trata de três coisas: estrutura do projeto, dependências (bibliotecas de que dependes) e ciclo de build (compilar, testar, empacotar).

pom.xml mínimo

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.exemplo</groupId>
    <artifactId>minha-app</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <!-- Substitui cada marcador pela versão estável mais recente que
             encontrares em central.sonatype.com. Qualquer dependência que
             use uma destas propriedades sem o marcador substituído faz o
             Maven recusar o pom.xml. -->
        <junit.version>VERSAO_ESCOLHIDA</junit.version>
        <mysql.version>VERSAO_ESCOLHIDA</mysql.version>
        <sqlite.version>VERSAO_ESCOLHIDA</sqlite.version>
    </properties>

    <dependencies>
        <!-- dependências aqui -->
    </dependencies>
</project>

As três coordenadas groupId, artifactId e version identificam de forma única o teu projeto (e qualquer biblioteca) no repositório Maven.

Estrutura standard

minha-app/
├── pom.xml
└── src/
    ├── main/
    │   ├── java/
    │   │   └── com/exemplo/App.java
    │   └── resources/
    └── test/
        ├── java/
        │   └── com/exemplo/AppTest.java
        └── resources/

O pacote com.exemplo corresponde às pastas com/exemplo. Seguir a estrutura permite que qualquer programador (e qualquer ferramenta) perceba o projeto sem explicações.

Comandos essenciais

mvn compile         # compila
mvn test            # corre testes
mvn package         # cria .jar em target/
mvn clean install   # limpa, compila, testa, instala localmente
mvn dependency:tree # mostra dependências

Ciclo de vida

validate, compile, test, package, verify, install, deploy. Pedir uma fase executa todas as anteriores: mvn package compila e corre os testes antes de empacotar. Se um teste falhar, o .jar não é criado, e é isto que protege a equipa de entregar código partido.

Dependências

Para usar uma biblioteca, acrescenta-a ao pom.xml; o Maven descarrega-a (e as dependências dela) automaticamente.

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>${junit.version}</version>
    <scope>test</scope>
</dependency>

A propriedade junit.version define-se no bloco <properties> do pom.xml, com a versão estável mais recente de org.junit.jupiter:junit-jupiter que encontrares no repositório Maven Central (central.sonatype.com). Este código usa a API org.junit.jupiter.api, a do JUnit 5; escolhe uma versão que a mantenha. Não copies números de versão de tutoriais antigos. Sem essa linha o Maven nem chega a compilar: recusa o ficheiro com 'dependencies.dependency.version' ... must be a valid version but is '${junit.version}'. O mesmo vale para ${mysql.version} e ${sqlite.version} nos capítulos 12 e 13 e nas fichas.

O scope test diz que a biblioteca só é necessária para testes e não entra no .jar final.

6. Sintaxe básica

Tipos primitivos

Java tem 8 tipos primitivos (com tamanho fixo):

int idade = 25;
long populacao = 8_000_000_000L;    // L para long
double preco = 9.99;
float taxa = 0.21f;                  // f para float
boolean ativo = true;
char letra = 'A';

String não é primitivo, é objeto:

String nome = "Ana";
String saudacao = "Olá, " + nome;
int len = nome.length();
String maiusc = nome.toUpperCase();

Variáveis com var

Java 10 ou superior permite inferência de tipo:

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

Só funciona para variáveis locais (não em campos de classe nem em parâmetros). O tipo continua a ser estático: o compilador deduz-o, não o deixa mudar.

Constantes

Com final, o valor só se atribui uma vez:

final double IVA = 0.23;
// IVA = 0.20;   // erro de compilação

Operadores

// Aritméticos
int soma = 10 + 5;       // 15
int sub = 10 - 5;        // 5
int mul = 10 * 5;        // 50
int div = 10 / 3;        // 3 (truncado!)
int mod = 10 % 3;        // 1
double real = 10.0 / 3;  // 3.333...

// Atribuição composta
int x = 10;
x += 5;   // x = x + 5
x *= 2;   // x = x * 2
x++;      // x = x + 1

// Comparação
boolean eq = (a == b);    // CUIDADO: == em objetos compara referências!
boolean neq = (a != b);

// Lógicos
boolean e = (a && b);
boolean ou = (a || b);
boolean nao = !a;

// Strings: usa .equals(), não ==
String s1 = "Ana";
String s2 = "Ana";
boolean igual = s1.equals(s2);   // correto
boolean iguais = (s1 == s2);     // aqui dá true por causa do pool de strings, mas não é fiável

Os operadores && e || fazem avaliação em curto-circuito: em a != 0 && 10 / a > 1, se a for 0 a segunda parte nem chega a ser calculada, o que evita a divisão por zero.

Conversão de tipos

Converter para um tipo maior é automático (widening). Para um tipo menor, é preciso um cast explícito e pode perder-se informação.

int i = 7;
double d = i;            // automático: 7.0
double pi = 3.99;
int truncado = (int) pi; // 3 (não arredonda, corta)
long grande = 3_000_000_000L;
int perdido = (int) grande;  // overflow: valor sem sentido

Para converter texto em número:

int n = Integer.parseInt("42");
double v = Double.parseDouble("3.14");

Se o texto não for um número, parseInt lança NumberFormatException.

Leitura do teclado

import java.util.Scanner;

Scanner sc = new Scanner(System.in);
System.out.print("Nome: ");
String nome = sc.nextLine();
System.out.print("Idade: ");
int idade = sc.nextInt();

System.out.println("Olá, " + nome + ", " + idade + " anos");
sc.close();

Estruturas de controlo

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

// Switch tradicional
switch (dia) {
    case 1: System.out.println("Segunda"); break;
    case 2: System.out.println("Terça"); break;
    default: System.out.println("Outro");
}

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

No switch tradicional, esquecer o break faz o código "cair" para o caso seguinte. A forma com -> não tem esse problema.

Ciclos

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

// Foreach (enhanced for)
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++;
}

// Do-while (corre pelo menos 1 vez)
int n;
do {
    n = sc.nextInt();
} while (n < 0);

// Break e continue
for (int j = 0; j < 100; j++) {
    if (j == 50) break;        // sai do ciclo
    if (j % 2 == 0) continue;  // salta a iteração
    System.out.println(j);
}

Regra prática: for quando sabes quantas vezes repetes; while quando repetes até uma condição mudar; do-while quando o corpo tem de correr pelo menos uma vez (pedir um valor e validar).

Arrays

// Declaração + inicialização
int[] numeros = new int[5];        // [0, 0, 0, 0, 0]
int[] valores = {1, 2, 3, 4, 5};

// Acesso e modificação
numeros[0] = 10;
int primeiro = valores[0];

// Tamanho
int n = valores.length;

// Iterar
for (int i = 0; i < valores.length; i++) {
    System.out.println(valores[i]);
}

// Multidimensional
int[][] matriz = {
    {1, 2, 3},
    {4, 5, 6}
};
int valor = matriz[1][2];  // 6

Os índices começam em 0 e o último é length - 1. O tamanho de um array é fixo; se precisas de crescer, usa uma ArrayList (capítulo 9). A classe java.util.Arrays traz utilitários: Arrays.toString(v), Arrays.sort(v), Arrays.fill(v, 0).

Métodos

Um método agrupa instruções sob um nome. Recebe parâmetros e pode devolver um valor.

public class Utilitarios {

    static double areaCirculo(double raio) {
        return Math.PI * raio * raio;
    }

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

    static double somar(double a, double b) {   // sobrecarga: mesmo nome, tipos diferentes
        return a + b;
    }

    public static void main(String[] args) {
        System.out.println(somar(2, 3));        // 5
        System.out.println(somar(2.5, 3.5));    // 6.0
        System.out.printf("%.2f%n", areaCirculo(2));  // 12,57 (ou 12.57, conforme a localização)
    }
}

Em Java, os argumentos passam por valor. Para tipos primitivos, o método recebe uma cópia. Para objetos, recebe uma cópia da referência: pode alterar o objeto para onde ela aponta, mas não pode fazer a variável do chamador apontar para outro objeto.

Exemplo resolvido · Média e classificação

Problema: ler três notas (0 a 20), calcular a média e classificar: aprovado se for pelo menos 10, com distinção se for pelo menos 16.

import java.util.Scanner;

public class MediaNotas {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double soma = 0;
        for (int i = 1; i <= 3; i++) {
            System.out.print("Nota " + i + ": ");
            soma += sc.nextDouble();
        }
        double media = soma / 3;
        String estado;
        if (media >= 16) {
            estado = "Aprovado com distinção";
        } else if (media >= 10) {
            estado = "Aprovado";
        } else {
            estado = "Reprovado";
        }
        System.out.printf("Média: %.1f -> %s%n", media, estado);
        sc.close();
    }
}

Com as notas 12, 15 e 18: soma 45, média 15,0, estado "Aprovado". O formato %.1f mostra uma casa decimal e %n muda de linha.

7. Programação orientada por objetos

O paradigma

Na programação orientada por objetos (POO ou OOP), o programa é um conjunto de objetos que guardam estado e colaboram trocando mensagens (chamadas de métodos). Em vez de pensar "que passos executo", pensas "que entidades existem e o que cada uma sabe e faz".

As características fundamentais:

Classe, objeto, atributo, método, mensagem

Uma classe é um molde; um objeto é uma instância dessa classe. Os atributos são o estado; os métodos são o comportamento. Chamar p1.apresentar() é enviar a mensagem apresentar ao objeto p1.

public class Pessoa {
    // Atributos (estado)
    private String nome;
    private int idade;

    // Construtor
    public Pessoa(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }

    // Métodos (comportamento)
    public void apresentar() {
        System.out.println("Olá, sou " + nome + " e tenho " + idade + " anos");
    }

    // Getters
    public String getNome() {
        return nome;
    }

    public int getIdade() {
        return idade;
    }

    // Setters
    public void setNome(String nome) {
        this.nome = nome;
    }

    public void setIdade(int idade) {
        if (idade < 0) {
            throw new IllegalArgumentException("Idade negativa");
        }
        this.idade = idade;
    }
}

Usar:

Pessoa p1 = new Pessoa("Ana", 25);
Pessoa p2 = new Pessoa("Bruno", 30);

p1.apresentar();
System.out.println(p2.getNome());

p1.setIdade(26);

new cria o objeto no heap e chama o construtor; a variável p1 guarda a referência. this é a referência do objeto atual, usada para distinguir o atributo do parâmetro com o mesmo nome.

Encapsulamento

Atributos privados, acesso controlado:

• private: só dentro da classe.
• (sem modificador): só dentro do mesmo pacote.
• protected: o mesmo pacote e as subclasses.
• public: qualquer lado.

Vantagens:

• Validação nos setters (a idade nunca fica negativa).
• Mudar a implementação interna sem partir quem usa a classe.
• Pensar em interfaces de utilização, não em detalhes.

Construtores múltiplos (sobrecarga)

public class Pessoa {
    private String nome;
    private int idade;

    public Pessoa() {
        this("Anónimo", 0);
    }

    public Pessoa(String nome) {
        this(nome, 0);
    }

    public Pessoa(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }
}

// Uso
Pessoa p1 = new Pessoa();
Pessoa p2 = new Pessoa("Ana");
Pessoa p3 = new Pessoa("Bruno", 30);

this(...) chama outro construtor da mesma classe e deve ser a primeira instrução. Assim a lógica de inicialização fica num só sítio.

Membros estáticos

Um membro static pertence à classe, não a cada objeto. É partilhado por todos.

public class Contador {
    private static int total = 0;     // um só valor, partilhado
    private final int numero;         // um por objeto

    public Contador() {
        total++;
        numero = total;
    }

    public int getNumero() { return numero; }
    public static int getTotal() { return total; }
}

Depois de new Contador(); new Contador();, Contador.getTotal() devolve 2. Métodos static não podem usar this nem atributos de instância.

Método toString, equals e hashCode

Toda a classe herda de Object. Três métodos merecem ser sobrepostos nas classes de dados:

import java.util.Objects;

public class Livro {
    private final String isbn;
    private final String titulo;

    public Livro(String isbn, String titulo) {
        this.isbn = isbn;
        this.titulo = titulo;
    }

    @Override
    public String toString() {
        return titulo + " (" + isbn + ")";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Livro)) return false;
        Livro outro = (Livro) o;
        return isbn.equals(outro.isbn);
    }

    @Override
    public int hashCode() {
        return Objects.hash(isbn);
    }
}

Sem equals, dois objetos Livro com o mesmo ISBN seriam considerados diferentes. Quem sobrepõe equals tem de sobrepor hashCode de forma coerente; HashMap e HashSet dependem de ambos.

Relações entre classes

Relações entre objetos

Em execução, os objetos relacionam-se através de referências. Os casos clássicos:

• Um para um: um Aluno tem um CartaoEstudante.
• Um para muitos: um Leitor tem uma lista de Emprestimo.
• Muitos para muitos: vários Alunos inscrevem-se em várias Disciplinas (em geral resolve-se com uma classe intermédia, Inscricao).

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

public class Leitor {
    private final String nome;
    private final List<Livro> emprestados = new ArrayList<>();   // associação: os livros existem independentemente do leitor

    public Leitor(String nome) { this.nome = nome; }

    public void pedir(Livro l) { emprestados.add(l); }
    public int quantos() { return emprestados.size(); }
}

Herança

public class Empregado extends Pessoa {
    private double salario;
    private String cargo;

    public Empregado(String nome, int idade, double salario, String cargo) {
        super(nome, idade);  // chama o construtor da Pessoa
        this.salario = salario;
        this.cargo = cargo;
    }

    @Override
    public void apresentar() {
        super.apresentar();
        System.out.println("Cargo: " + cargo + ", salário: " + salario + "€");
    }

    public double getSalarioAnual() {
        return salario * 14;  // 14 meses em Portugal
    }
}

super = referência à classe pai. @Override = anotação que indica que sobrepões um método (o compilador valida).

A herança é a forma clássica de partilhar comportamento e permite a evolução: acrescentas uma subclasse sem tocar na classe existente. Mas é uma relação forte. Antes de herdar, pergunta: "um Empregado é uma Pessoa?" Se a resposta for "tem uma", usa composição.

Polimorfismo

Pessoa p = new Empregado("Ana", 25, 1000, "Dev");
p.apresentar();  // chama a versão de Empregado (ligação dinâmica)

Uma variável do tipo Pessoa pode referenciar qualquer subclasse. O método chamado é o da classe real do objeto, não o do tipo da variável. Isto permite escrever código que funciona com tipos que ainda nem existem.

Classes abstratas

public abstract class Figura {
    public abstract double area();   // sem implementação

    public void descrever() {
        System.out.println("Área: " + area());
    }
}

public class Circulo extends Figura {
    private double raio;

    public Circulo(double raio) {
        this.raio = raio;
    }

    @Override
    public double area() {
        return Math.PI * raio * raio;
    }
}

Não se pode fazer new Figura(): só serve como base. As subclasses concretas são obrigadas a implementar area().

Interfaces

public interface Veiculo {
    void acelerar();
    void travar();

    // Método default (Java 8 ou superior): opcional sobrescrever
    default void buzinar() {
        System.out.println("Beep!");
    }

    // Constante
    int VELOCIDADE_MAX = 120;
}

public class Carro implements Veiculo {
    @Override
    public void acelerar() { /* ... */ }

    @Override
    public void travar() { /* ... */ }
}

Uma classe implementa múltiplas interfaces mas herda de uma só classe. Uma interface é um contrato: define o que se pode fazer, sem dizer como.

Interfaces com um único método abstrato são interfaces funcionais e podem ser escritas como lambdas, como vais ver nos Comparator e nos streams.

Exemplo resolvido · Polimorfismo com figuras

Problema: guardar figuras diferentes numa só lista e calcular a área total.

import java.util.List;

abstract class Figura {
    abstract double area();
}

class Circulo extends Figura {
    private final double raio;
    Circulo(double raio) { this.raio = raio; }
    @Override double area() { return Math.PI * raio * raio; }
}

class Retangulo extends Figura {
    private final double largura, altura;
    Retangulo(double largura, double altura) {
        this.largura = largura;
        this.altura = altura;
    }
    @Override double area() { return largura * altura; }
}

public class AreaTotal {
    public static void main(String[] args) {
        List<Figura> figuras = List.of(new Circulo(1), new Retangulo(2, 3), new Retangulo(1, 1));
        double total = 0;
        for (Figura f : figuras) {
            total += f.area();     // cada objeto responde à sua maneira
        }
        System.out.printf("Área total: %.2f%n", total);
    }
}

Passos: (1) a lista tem o tipo Figura, mas guarda objetos concretos; (2) em cada volta, f.area() executa a versão da classe real; (3) áreas: 3,14 + 6 + 1 = 10,14. Saída: Área total: 10,14 (ou 10.14, conforme a localização do sistema). Para acrescentar um Triangulo, basta escrever a classe: o ciclo não muda.

Exemplo resolvido · Mini-biblioteca com três classes

Problema: modelar livros, leitores e empréstimos (o cenário planeado no capítulo 3) e impedir que um livro seja emprestado duas vezes.

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;

class Livro {
    private final String titulo;
    private boolean emprestado;

    Livro(String titulo) { this.titulo = titulo; }
    String getTitulo() { return titulo; }
    boolean isEmprestado() { return emprestado; }
    void setEmprestado(boolean emprestado) { this.emprestado = emprestado; }
}

class Emprestimo {
    private final Livro livro;
    private final LocalDate data;

    Emprestimo(Livro livro, LocalDate data) {
        this.livro = livro;
        this.data = data;
    }
    Livro getLivro() { return livro; }
    LocalDate getData() { return data; }
}

class Leitor {
    private final String nome;
    private final List<Emprestimo> emprestimos = new ArrayList<>();

    Leitor(String nome) { this.nome = nome; }
    String getNome() { return nome; }
    int quantos() { return emprestimos.size(); }

    void pedir(Livro livro, LocalDate data) {
        if (livro.isEmprestado()) {
            throw new IllegalStateException("Livro já emprestado: " + livro.getTitulo());
        }
        livro.setEmprestado(true);
        emprestimos.add(new Emprestimo(livro, data));
    }
}

public class Biblioteca {
    public static void main(String[] args) {
        Livro l = new Livro("Java Básico");
        Leitor ana = new Leitor("Ana");
        Leitor carla = new Leitor("Carla");

        ana.pedir(l, LocalDate.of(2026, 10, 1));
        try {
            carla.pedir(l, LocalDate.of(2026, 10, 2));
        } catch (IllegalStateException e) {
            System.out.println(e.getMessage());
        }
        System.out.println(ana.getNome() + " tem " + ana.quantos() + " livro(s)");
    }
}

Passos: (1) Leitor associa-se a Emprestimo (um para muitos) e Emprestimo associa-se a Livro; (2) a regra de negócio vive em pedir, não na interface; (3) o segundo pedido lança IllegalStateException, que o main apanha. Saída: Livro já emprestado: Java Básico e Ana tem 1 livro(s).

Records (Java 16 ou superior)

Para classes simples de dados (DTOs):

public record Ponto(double x, double y) { }

// Equivalente a uma classe imutável com:
// - construtor (x, y)
// - acessores x() e y()
// - equals, hashCode, toString automáticos

Ponto p = new Ponto(1, 2);
System.out.println(p.x());      // 1.0
System.out.println(p);          // Ponto[x=1.0, y=2.0]

Enumerações

Um enum define um conjunto fechado de valores.

public enum Estado {
    DISPONIVEL, EMPRESTADO, PERDIDO
}

Estado e = Estado.DISPONIVEL;
switch (e) {
    case DISPONIVEL -> System.out.println("Pode ser emprestado");
    case EMPRESTADO -> System.out.println("Aguarda devolução");
    case PERDIDO -> System.out.println("Fora do catálogo");
}

É mais seguro do que usar números ou texto soltos ("1" significa o quê?), porque o compilador recusa valores fora do conjunto.

Classes genéricas

Os genéricos permitem escrever classes e métodos que funcionam com vários tipos, mantendo a verificação de tipos em compilação. É o <T> que viste em List<String>.

public class Caixa<T> {
    private T conteudo;

    public Caixa(T conteudo) { this.conteudo = conteudo; }
    public T getConteudo() { return conteudo; }
    public void setConteudo(T conteudo) { this.conteudo = conteudo; }
}

public class Teste {
    public static void main(String[] args) {
        Caixa<String> c1 = new Caixa<>("Olá");
        Caixa<Integer> c2 = new Caixa<>(42);
        String s = c1.getConteudo();     // sem cast
        // Caixa<Integer> errada = new Caixa<>("texto");   // erro de compilação
        System.out.println(s + " " + c2.getConteudo());
    }
}

Um método genérico com limite de tipo (T extends Comparable<T>) só aceita tipos que sabem comparar-se:

static <T extends Comparable<T>> T maior(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;
}

// maior(3, 7) devolve 7; maior("ana", "bruno") devolve "bruno"

Os genéricos só funcionam com tipos de referência: List<int> não existe; usa List<Integer> (a conversão int para Integer, chamada autoboxing, é automática).

8. Strings

As String são imutáveis: cada operação devolve uma nova String, a original nunca muda.

String s = "Hello World";

// Tamanho
int len = s.length();           // 11

// Substring
String sub = s.substring(0, 5); // "Hello"

// Maiúsculas e minúsculas
String upper = s.toUpperCase(); // "HELLO WORLD"
String lower = s.toLowerCase();

// Substituição
String r = s.replace("World", "Java");

// Split
String csv = "Ana,Bruno,Carla";
String[] partes = csv.split(",");

// Concatenação eficiente
StringBuilder sb = new StringBuilder();
sb.append("Olá ");
sb.append("mundo");
sb.append("!");
String resultado = sb.toString();

// Formatação
String formatted = String.format("%s tem %d anos", "Ana", 25);

// Comparação
boolean igual = s.equals("Hello World");
boolean igualIgnoreCase = s.equalsIgnoreCase("HELLO WORLD");

// Pesquisa
boolean contem = s.contains("World");
boolean comeca = s.startsWith("Hello");
boolean termina = s.endsWith("World");
int pos = s.indexOf("World");   // 6, ou -1 se não existir
String limpa = "  texto  ".trim();   // "texto"

Dentro de ciclos longos, concatenar com + cria uma String nova a cada volta; StringBuilder evita esse desperdício.

9. Coleções

O pacote java.util tem o Collections Framework: estruturas de dados padronizadas, todas genéricas (List<String>, Map<String, Integer>).

Qual escolher

List

Lista ordenada, permite duplicados.

import java.util.*;

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

// Acesso
String primeiro = nomes.get(0);
int n = nomes.size();
boolean tem = nomes.contains("Ana");

// Remover
nomes.remove("Bruno");
nomes.remove(0);                // por índice

// Iterar
for (String nome : nomes) {
    System.out.println(nome);
}

// Lista imutável
List<String> fixos = List.of("a", "b", "c");

Programa sempre contra a interface (List<String> x = new ArrayList<>()), não contra a implementação. Se mais tarde precisares de outra implementação, só mudas uma linha.

Map

Chave -> valor.

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

// Acesso
Integer idadeAna = idades.get("Ana");          // 25
Integer naoExiste = idades.get("Carla");        // null
Integer comDefault = idades.getOrDefault("Carla", 0); // 0

// Verificar
boolean tem = idades.containsKey("Ana");

// Remover
idades.remove("Ana");

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

// Só chaves ou só valores
for (String k : idades.keySet()) { /* ... */ }
for (Integer v : idades.values()) { /* ... */ }

Set

Sem duplicados, sem ordem.

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

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

// TreeSet, ordenado
Set<String> ordenados = new TreeSet<>();
ordenados.add("Carla");
ordenados.add("Ana");
ordenados.add("Bruno");
// Ana, Bruno, Carla (ordem alfabética)

Ordenar: Comparable e Comparator

Uma classe é comparável se implementar Comparable<T> (ordem natural). Um Comparator define uma ordem alternativa, sem tocar na classe.

import java.util.*;

record Aluno(String nome, int nota) { }

public class Ordenacao {
    public static void main(String[] args) {
        List<Aluno> turma = new ArrayList<>(List.of(
            new Aluno("Carla", 15),
            new Aluno("Ana", 18),
            new Aluno("Bruno", 15)));

        turma.sort(Comparator.comparing(Aluno::nome));
        System.out.println(turma);

        turma.sort(Comparator.comparingInt(Aluno::nota).reversed()
                             .thenComparing(Aluno::nome));
        System.out.println(turma);
    }
}

A primeira linha mostra [Aluno[nome=Ana, nota=18], Aluno[nome=Bruno, nota=15], Aluno[nome=Carla, nota=15]]; a segunda, por nota decrescente e depois por nome, dá Ana (18), Bruno (15), Carla (15).

Streams API

Programação funcional sobre coleções:

import java.util.stream.*;

List<Integer> numeros = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Filter
List<Integer> pares = numeros.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

// Map
List<Integer> dobrados = numeros.stream()
    .map(n -> n * 2)
    .collect(Collectors.toList());

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

// Count
long quantos = numeros.stream()
    .filter(n -> n > 5)
    .count();

// Cadeias
String resultado = List.of("ana", "bruno", "carla").stream()
    .map(String::toUpperCase)
    .filter(s -> s.length() > 3)
    .collect(Collectors.joining(", "));
// "BRUNO, CARLA"

Um stream não altera a coleção original: produz um resultado novo. Só executa quando chega a operação terminal (collect, count, sum, forEach).

Exemplo resolvido · Contar palavras com Map

Problema: contar quantas vezes cada palavra aparece num texto.

import java.util.*;

public class ContaPalavras {
    public static void main(String[] args) {
        String texto = "java é java e python é python mas java ganha";
        Map<String, Integer> contagem = new TreeMap<>();
        for (String palavra : texto.split(" ")) {
            contagem.merge(palavra, 1, Integer::sum);
        }
        for (Map.Entry<String, Integer> e : contagem.entrySet()) {
            System.out.println(e.getKey() + ": " + e.getValue());
        }
    }
}

Passos: (1) split(" ") parte o texto em palavras; (2) merge insere a palavra com 1 ou, se já existe, soma 1 ao valor existente; (3) o TreeMap percorre as chaves por ordem alfabética. Saída: e: 1, ganha: 1, java: 3, mas: 1, python: 2, é: 2. (A letra acentuada fica no fim porque a ordenação é por código Unicode.)

10. Exceções

Hierarquia

Throwable
├── Error           (não tratar: falhas graves da JVM)
└── Exception
    ├── RuntimeException  (unchecked: tratar é opcional)
    │   ├── NullPointerException
    │   ├── ArithmeticException
    │   └── IndexOutOfBoundsException
    └── IOException        (checked: tratar é obrigatório)

Uma exceção é um objeto que representa uma situação anómala. Quando é lançada, a execução normal pára e a JVM procura um catch que a trate, subindo pela cadeia de chamadas. Se ninguém a trata, o programa termina com uma mensagem e a stack trace.

Try-catch-finally

try {
    int[] arr = {1, 2, 3};
    System.out.println(arr[10]);   // ArrayIndexOutOfBoundsException
    int x = 10 / 0;                 // ArithmeticException (nunca chega aqui)
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Índice inválido: " + e.getMessage());
} catch (ArithmeticException e) {
    System.out.println("Erro aritmético: " + e.getMessage());
} catch (Exception e) {
    System.out.println("Outro erro: " + e.getMessage());
} finally {
    System.out.println("Sempre executa");
}

Os catch leem-se por ordem: o mais específico primeiro, o mais geral (Exception) no fim. O compilador recusa um catch geral antes de um específico.

Multi-catch

try {
    // ...
} catch (IOException | SQLException e) {
    // tratar ambos igual
}

Try-with-resources

Para recursos que precisam de ser fechados (ficheiros, ligações):

try (Scanner sc = new Scanner(new File("dados.txt"))) {
    while (sc.hasNextLine()) {
        System.out.println(sc.nextLine());
    }
}  // sc.close() automático, mesmo se houver exceção

Throw e throws

public void retirar(double valor) {
    if (valor <= 0) {
        throw new IllegalArgumentException("Valor deve ser positivo");
    }
    if (valor > saldo) {
        throw new IllegalStateException("Saldo insuficiente");
    }
    saldo -= valor;
}

throw lança uma exceção; throws na assinatura avisa que o método pode lançar uma exceção checked.

Exceções próprias

public class SaldoInsuficienteException extends Exception {
    public SaldoInsuficienteException(String message) {
        super(message);
    }
}

// Uso (checked: declara-se no throws)
public void sacar(double valor) throws SaldoInsuficienteException {
    if (valor > saldo) {
        throw new SaldoInsuficienteException(
            "Saldo: " + saldo + "€, pedido: " + valor + "€"
        );
    }
    saldo -= valor;
}

Exemplo resolvido · Ler um número com validação

Problema: pedir um inteiro ao utilizador e repetir até ele escrever um valor válido.

import java.util.Scanner;

public class LeInteiro {
    static int lerInteiro(Scanner sc, String pergunta) {
        while (true) {
            System.out.print(pergunta);
            String linha = sc.nextLine();
            try {
                return Integer.parseInt(linha.trim());
            } catch (NumberFormatException e) {
                System.out.println("'" + linha + "' não é um número inteiro. Tenta de novo.");
            }
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int idade = lerInteiro(sc, "Idade: ");
        System.out.println("Registado: " + idade);
    }
}

Passos: (1) lê-se sempre a linha inteira com nextLine, o que evita o problema do \n que fica no buffer; (2) parseInt lança NumberFormatException se o texto não for número; (3) o catch mostra uma mensagem e o ciclo while (true) repete; (4) o return só é alcançado com valor válido.

11. Ficheiros e I/O

NIO.2 (moderno, Java 7 ou superior)

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

Path path = Path.of("dados.txt");

// Ler tudo
String texto = Files.readString(path);

// Ler linhas
List<String> linhas = Files.readAllLines(path);

// Escrever
Files.writeString(path, "Olá mundo!\n");
Files.write(path, List.of("a", "b", "c"));

// Acrescentar no fim
Files.writeString(path, "Nova linha\n", StandardOpenOption.APPEND);

// Verificar
boolean existe = Files.exists(path);
long tamanho = Files.size(path);

// Criar / apagar
Files.createFile(path);
Files.createDirectories(Path.of("pasta/subpasta"));
Files.delete(path);

// Listar diretório
try (var stream = Files.list(Path.of("."))) {
    stream.forEach(System.out::println);
}