Java Glossário

Os 120 termos que aparecem no guia, em ordem alfabética, explicados em uma ou duas frases. Cada um tem o link para a aula em que é explicado com calma. Os nomes em inglês que o Java usa (como overriding e stack trace) estão aqui com a tradução.

Dica

Use Ctrl+F no navegador para achar um termo, ou o índice de letras abaixo. Palavras reservadas da linguagem têm a sua própria página: Palavras-chave.

A · B · C · D · E · F · G · H · I · J · L · M · N · O · P · R · S · T · U · V · W · Y

A

Abstrata (classe): Classe marcada com abstract: não pode virar objeto direto e pode ter métodos sem corpo, que as filhas são obrigadas a escrever. Veja: Classes Abstratas.
Anotação: Uma etiqueta com @ que dá informação extra ao compilador ou a ferramentas: @Override, @Test, @FunctionalInterface. Veja: Anotações.
API: Application Programming Interface: o conjunto de classes e métodos que uma biblioteca oferece para você usar. "A API do Java" é a biblioteca padrão inteira. Veja: A Biblioteca Padrão.
args: O parâmetro String[] args do main: as palavras digitadas depois do nome do programa na linha de comando. Veja: Argumentos da Linha de Comando.
Argumento: O valor que você passa ao chamar um método: em somar(2, 3), 2 e 3 são argumentos. Não confunda com parâmetro (a variável que recebe). Veja: Parâmetros e Argumentos.
Array: Uma sequência de tamanho fixo de valores do mesmo tipo, acessados por índice a partir de 0: int[] notas = {7, 8, 9};. Veja: Arrays.
ArrayList: A lista mais usada do Java: cresce sozinha, guarda a ordem e aceita repetidos. Veja: ArrayList.
Atributo: Uma variável que pertence a um objeto (ou à classe, se for static): o saldo de uma Conta. Também chamado de campo. Veja: Atributos.
Autoboxing: A conversão automática entre um primitivo e o seu wrapper: int vira Integer ao entrar numa List<Integer> (e o contrário, unboxing). Veja: Wrappers e Autoboxing.

B

Biblioteca padrão: As milhares de classes que já vêm com o JDK (String, ArrayList, Files, LocalDate…), organizadas em pacotes. Veja: A Biblioteca Padrão.
BigDecimal: Classe para números decimais exatos, usada para dinheiro: 0.1 + 0.2 dá exatamente 0.3. Veja: BigDecimal e Dinheiro.
Bloco: Um trecho de código entre chaves { }. Variáveis declaradas num bloco só existem dentro dele. Veja: Escopo.
boolean: Tipo primitivo com dois valores: true e false. É o resultado das comparações. Veja: char e boolean.
Build: O processo de transformar o código-fonte no programa pronto: compilar, testar e empacotar. Ferramentas de build: Maven e Gradle. Veja: Maven.
Bytecode: O código intermediário que o javac gera nos arquivos .class. Não é código de máquina: é lido pela JVM, em qualquer sistema. Veja: JDK, JRE e JVM.

C

Casting (conversão): Converter um valor para outro tipo, explicitamente: (int) 7.9 dá 7. Também vale para objetos: (Gato) animal. Veja: Conversão de Tipos.
char: Tipo primitivo para um caractere Unicode, entre aspas simples: 'A'. Por dentro, é um número. Veja: char e boolean.
Checked exception: Exceção que o compilador obriga a tratar (try/catch) ou declarar (throws), como IOException. Filhas de Exception que não são RuntimeException. Veja: Checked × Unchecked.
Classe: O "molde" de um tipo de objeto: diz que dados (atributos) e que ações (métodos) cada objeto tem. class Conta { … }. Veja: Classes e Objetos.
Classpath: A lista de pastas e JARs onde a JVM procura as classes: java -cp target/classes …. Veja: Empacotar em JAR.
Coleção: Um objeto que guarda vários outros: listas (List), conjuntos (Set), mapas (Map), filas (Deque). Veja: Visão Geral das Coleções.
Comentário: Texto no código que o compilador ignora: // linha, /* bloco */ e /** Javadoc */. Veja: Comentários.
Comparable / Comparator: Comparable: a ordem "natural" de uma classe (compareTo). Comparator: uma ordem extra, escolhida na hora de ordenar. Veja: Comparable e Comparator.
Compilador: Programa que traduz o código-fonte em outra forma. O do Java é o javac, que gera bytecode e recusa código com erros. Veja: javac e java.
Concatenação: Juntar textos com +: "Olá, " + nome. Veja: Concatenação.
Concorrência: Várias tarefas andando ao mesmo tempo (threads). Exige cuidado com dados compartilhados. Veja: Threads.
Constante: Um valor com nome que não muda: static final double TAXA = 0.05;. Por costume, em MAIÚSCULAS. Veja: Constantes (final).
Construtor: O "método" especial, com o nome da classe e sem tipo de retorno, que roda no new para preparar o objeto. Veja: Construtores.

D

Dependência: Uma biblioteca de terceiros que o seu projeto usa (JUnit, Gson…). O Maven baixa e organiza as dependências declaradas no pom.xml. Veja: Maven.
Depurar (debug): Investigar um defeito rodando o programa passo a passo, olhando os valores das variáveis. Veja: Depurar.
Diamante: O <> vazio em new ArrayList<>(): o compilador repete o tipo declarado à esquerda. Veja: Generics.
double: Tipo primitivo para números com casas decimais (64 bits). É o padrão para decimais, mas não é exato: 0.1 + 0.2 dá 0.30000000000000004. Veja: double e float.

E

Encapsulamento: Esconder os dados de um objeto (private) e só permitir mudanças por métodos que respeitam as regras. Veja: Encapsulamento.
enum: Um tipo com uma lista fechada de constantes: enum Nivel { FACIL, MEDIO, DIFICIL }. Pode ter atributos e métodos. Veja: Enums.
equals: O método que compara o conteúdo de dois objetos. Para String, use sempre equals, nunca ==. Veja: A Classe Object.
Escopo: A região do código em que uma variável existe: do ponto em que foi declarada até o fim do seu bloco. Veja: Escopo.
Exceção: Um objeto que representa um problema durante a execução (ArithmeticException, NullPointerException…). Se ninguém trata, o programa para e mostra o stack trace. Veja: O que são Exceções.
Expressão: Qualquer pedaço de código que produz um valor: 2 + 3, nome.length(), idade >= 18. Veja: Operadores Aritméticos.

F

final: Modificador que "trava": variável que não muda, método que não pode ser sobrescrito, classe que não pode ser herdada. Veja: final.
for-each: O laço for (Tipo x : colecao), que passa por cada item de um array ou coleção sem índice. Veja: for-each.

G

Garbage collector: O "coletor de lixo" da JVM: apaga sozinho da memória os objetos que ninguém mais usa. Por isso não existe free em Java. Veja: JDK, JRE e JVM.
Generics: Parâmetros de tipo entre < >: List<String> é uma lista que só aceita String, conferida pelo compilador. Veja: Generics.
Getter e setter: Métodos que leem (getSaldo()) e alteram (setNome(…)) um atributo privado. Veja: Encapsulamento.
Gradle: Ferramenta de build, alternativa ao Maven, configurada com um script (build.gradle.kts). Veja: Gradle.

H

hashCode: Um número calculado do conteúdo do objeto, usado por HashMap e HashSet. Quem sobrescreve equals deve sobrescrever hashCode. Veja: A Classe Object.
HashMap: O mapa mais usado: guarda pares chave → valor e acha pela chave muito rápido, sem ordem garantida. Veja: HashMap.
Heap: A área de memória onde ficam os objetos. Se acabar: OutOfMemoryError: Java heap space. Veja: Exceções Comuns.
Herança: Uma classe filha (extends) recebe os atributos e métodos da classe mãe e pode acrescentar ou mudar comportamentos. Veja: Herança.

I

IDE: Integrated Development Environment: editor com compilador, depurador e ajudas integrados (IntelliJ IDEA, Eclipse, VS Code). Veja: Editores e IDEs.
import: Instrução no topo do arquivo que permite usar uma classe de outro pacote pelo nome curto: import java.util.Scanner;. Veja: Pacotes e import.
Imutável: Um objeto que não muda depois de criado: String, records, BigDecimal, List.of(…). Métodos devolvem um objeto novo. Veja: Strings.
Instância: Um objeto criado a partir de uma classe. "Instanciar" = criar com new. Veja: Classes e Objetos.
Interface: Um contrato: a lista de métodos que uma classe promete ter (implements). Permite tratar objetos diferentes do mesmo jeito. Veja: Interfaces.
Interface funcional: Interface com um único método abstrato (Function, Predicate, Runnable…). Pode ser implementada por uma lambda. Veja: Interfaces Funcionais.
Iterator: Objeto que percorre uma coleção item por item (hasNext(), next()) e permite remover com segurança. Veja: Iterator.

J

JAR: Java ARchive: um arquivo (um zip) com as classes de um programa ou biblioteca. Um JAR executável roda com java -jar. Veja: Empacotar em JAR.
javac: O compilador do Java: lê os .java e gera os .class. Veja: javac e java.
Javadoc: Comentários /** … */ que documentam classes e métodos, e a ferramenta que gera páginas HTML com eles. Veja: Javadoc.
JDK: Java Development Kit: tudo para programar em Java: o compilador (javac), a JVM, o JShell e a biblioteca padrão. Veja: JDK, JRE e JVM.
JIT: Just-In-Time compiler: a parte da JVM que, durante a execução, traduz o bytecode mais usado para código de máquina, deixando o programa rápido. Veja: JDK, JRE e JVM.
JRE: Java Runtime Environment: só o necessário para rodar programas (JVM + biblioteca). Hoje vem dentro do JDK. Veja: JDK, JRE e JVM.
JShell: O console interativo do Java: você digita uma linha e vê o resultado na hora (jshell> 2 + 3). Veja: JShell.
JUnit: A biblioteca de testes automáticos mais usada no Java: @Test, assertEquals, assertThrows. Veja: Testes com JUnit.
JVM: Java Virtual Machine: o programa que executa o bytecode. Existe uma JVM para cada sistema; o mesmo .class roda em todas. Veja: JDK, JRE e JVM.

L

Laço (loop): Uma estrutura que repete código: while, do-while, for, for-each. Veja: while e do-while.
Lambda: Uma função curta escrita no lugar onde é usada: n -> n * 2. Implementa uma interface funcional. Veja: Lambdas.
List: A interface das listas: sequência com posições, que aceita repetidos. Implementações: ArrayList, LinkedList. Veja: Visão Geral das Coleções.
LTS: Long-Term Support: versão com suporte por muitos anos. LTS do Java: 8, 11, 17, 21 e 25 (a deste guia). Veja: Versões e LTS.

M

main: O método por onde o programa começa: public static void main(String[] args). Veja: Olá, Mundo.
Map: A interface dos mapas: pares chave → valor, chaves sem repetição. Implementações: HashMap, TreeMap, LinkedHashMap. Veja: HashMap.
Maven: Ferramenta de build e de dependências: lê o pom.xml, baixa bibliotecas, compila, testa (mvn test) e empacota (mvn package). Veja: Maven.
Método: Um bloco de código com nome, que pode receber parâmetros e devolver um valor. É uma "ação" de uma classe ou objeto. Veja: Métodos.
Modificador de acesso: public, protected, private (ou nenhum): quem pode ver uma classe, atributo ou método. Veja: Modificadores de Acesso.
Módulo: Um conjunto de pacotes com nome e regras de dependência (module-info.java). O JDK é dividido em módulos. Veja: Módulos (JPMS).

N

null: O valor de uma referência que não aponta para objeto nenhum. Usar um null causa NullPointerException. Veja: Exceções Comuns.

O

Object: A classe mãe de todas as classes do Java. Dela vêm equals, hashCode e toString. Veja: A Classe Object.
Objeto: Uma "coisa" concreta criada a partir de uma classe, com os seus próprios valores: new Conta("Ana"). Veja: Classes e Objetos.
Operador: Símbolo que faz uma operação: aritméticos (+ - * / %), de comparação (== < >=), lógicos (&& || !), de atribuição (= +=). Veja: Operadores Aritméticos.
Optional: Uma "caixa" que pode ter um valor ou estar vazia, para métodos que podem não ter resposta, no lugar de devolver null. Veja: Optional.
Overflow: Quando o resultado não cabe no tipo e "dá a volta": Integer.MAX_VALUE + 1 vira um número negativo. Veja: int, long, short, byte.

P

Pacote: Uma pasta lógica de classes, com nome invertido de domínio: java.util, br.com.ana.banco. Veja: Pacotes e import.
Parâmetro: A variável declarada na assinatura do método que recebe o argumento: em somar(int a, int b), a e b. Veja: Parâmetros e Argumentos.
Pattern matching: Testar o formato de um valor e já extrair as partes: if (obj instanceof String s), case Circulo c -> …. Veja: Pattern Matching.
Polimorfismo: "Muitas formas": a mesma chamada (animal.som()) se comporta de um jeito em cada tipo de objeto. Veja: Polimorfismo.
pom.xml: O arquivo que descreve um projeto Maven: nome, versão do Java, dependências e plugins. Veja: Maven.
POO: Programação Orientada a Objetos: organizar o programa em objetos que juntam dados e comportamento. Veja: O que é POO.
Primitivo (tipo): Os 8 tipos básicos, que guardam o valor direto: byte, short, int, long, float, double, char, boolean. Veja: Tipos Primitivos.

R

record: Uma classe só de dados, declarada numa linha: record Ponto(int x, int y) {}. Ganha construtor, acessores, equals e toString. Veja: Records.
Recursão: Um método que chama a si mesmo, com um caso base que para a repetição. Veja: Recursão.
Referência (tipo de): Todo tipo que não é primitivo (classes, arrays, interfaces). A variável guarda o "endereço" do objeto, não o objeto. Veja: Tipos Primitivos.
Referência de método: Atalho para uma lambda que só chama um método: String::toUpperCase, System.out::println. Veja: Referências de Métodos.
Reflexão: A capacidade de um programa examinar e usar classes, métodos e atributos em tempo de execução, pelo nome. Veja: Reflexão.
Regex: Expressão regular: um padrão para procurar e validar textos ("[0-9]+"). Veja: Expressões Regulares.

S

Scanner: A classe que lê do teclado (ou de um texto): nextLine(), nextInt(), hasNextInt(). Veja: Ler do Teclado (Scanner).
Selada (classe): Classe ou interface sealed que só pode ser estendida pelas classes listadas em permits. Veja: Classes Seladas.
Set: A interface dos conjuntos: coleções sem repetidos. Implementações: HashSet, TreeSet, LinkedHashSet. Veja: HashSet.
Sobrecarga (overloading): Vários métodos com o mesmo nome e parâmetros diferentes: somar(int, int) e somar(double, double). Veja: Sobrecarga.
Sobrescrita (overriding): A classe filha reescreve um método herdado, com a mesma assinatura (@Override). Veja: Sobrescrita (@Override).
Stack trace: A lista de chamadas mostrada junto com uma exceção (at Main.main(Main.java:5)): onde o problema aconteceu e quem chamou quem. Veja: Exceções Comuns.
static: Modificador que faz o atributo ou método pertencer à classe, e não a cada objeto: Math.sqrt, main. Veja: static.
Stream: Uma sequência de itens processada em etapas (filter, map, toList), no estilo funcional. Não confundir com fluxos de arquivo. Veja: Streams.
String: O tipo para textos: "Olá". É uma classe (com métodos) e é imutável. Veja: Strings.
StringBuilder: Um texto que pode ser alterado (append, insert, reverse), mais eficiente que juntar muitas String com +. Veja: StringBuilder.
super: Palavra que se refere à classe mãe: super(…) chama o construtor dela; super.metodo(), um método dela. Veja: super.
switch: Escolhe um caminho pelo valor. Com setas (case 1 -> …), pode devolver um valor. Veja: switch com Setas.

T

Teste automático: Código que verifica outro código, rodado com um comando (mvn test). Um teste unitário confere uma pequena parte isolada. Veja: Testes com JUnit.
Text block: Texto de várias linhas entre três aspas ("""). Java 15+ Veja: Text Blocks.
this: Referência ao próprio objeto: this.nome = nome separa o atributo do parâmetro. Veja: this.
Thread: Uma linha de execução. Um programa pode ter várias threads trabalhando ao mesmo tempo. Veja: Threads.
Thread virtual: Thread leve, gerenciada pela JVM, que permite milhares de tarefas simultâneas. Java 21+ Veja: Threads Virtuais.
throw / throws: throw lança uma exceção agora; throws, na assinatura, avisa que o método pode lançá-la. Veja: throw e throws.
toString: O método que transforma um objeto em texto; é chamado pelo println e pela concatenação. Veja: A Classe Object.
try / catch / finally: Blocos para tratar exceções: try tenta, catch trata, finally roda sempre. Veja: try e catch.

U

Unchecked exception: Exceção que o compilador não obriga a tratar: RuntimeException e filhas (NullPointerException, ArithmeticException…). Veja: Checked × Unchecked.
Unicode: O padrão que dá um número a cada caractere de todas as línguas. O char e a String do Java usam Unicode. Veja: char e boolean.

V

var: Deixa o compilador deduzir o tipo de uma variável local: var lista = new ArrayList<String>();. Java 10+ Veja: var.
Variável: Um nome que guarda um valor de um tipo: int idade = 29;. Veja: Variáveis.
void: "Vazio": indica que um método não devolve nada. Veja: Métodos.

W

Wrapper: A classe que "embrulha" um primitivo: Integer para int, Double para double… Necessária em coleções. Veja: Wrappers e Autoboxing.

Y

yield: Entrega o valor de um bloco { } num switch que devolve valor. Veja: switch com Setas.

Experimente dois termos

record: declare record Ponto(int x, int y) {} no JShell e crie new Ponto(1, 2). Repare no toString que o record ganhou de graça.

record Ponto(int x, int y) {}
new Ponto(1, 2)

Imutável: o programa chama toUpperCase(), mas continua mostrando ana, porque String é imutável e o resultado foi jogado fora. Guarde o resultado em nome para mostrar ANA.

public class Main {
    public static void main(String[] args) {
        String nome = "ana";
        nome.toUpperCase();
        System.out.println(nome);
    }
}

public class Main {
    public static void main(String[] args) {
        String nome = "ana";
        nome = nome.toUpperCase();
        System.out.println(nome);
    }
}

Qual a diferença entre JDK e JVM?

Nenhuma, são sinônimos. A JVM executa o bytecode; o JDK é o kit completo para programar, que inclui a JVM, o javac e o JShell. O JDK executa e a JVM compila. A JVM só existe no Windows.

Sobrecarga (overloading) é…

a classe filha reescrever um método da mãe. passar do limite de um int. ter vários métodos com o mesmo nome e parâmetros diferentes. chamar um método dentro dele mesmo.

Para se testar em todos os assuntos, faça o Quiz.