- Sintaxe, Identificadores e Convenções de Nomenclatura
Em Java, identificadores são nomes criados pelo desenvolvedor para representar classes, métodos, variáveis e pacotes. O compilador reserva um conjunto de palavras-chave (keywords) que possuem significado sintático próprio e não podem ser utilizadas como identificadores. A linguagem define aproximadamente 50 tokens reservados, como class, interface, public, static e void.
As regras para nomes válidos incluem: uso de letras (A-Z, a-z), dígitos (0-9), cifrão ($) e sublinhado (_). Nomes não podem iniciar com dígitos, conter espaços ou ser iguais a palavras reservadas. A convenção oficial recomenda:
- Classes/Interfaces: PascalCase (ex:
GerenciadorPedido) - Métodos e Variáveis: camelCase (ex:
calcularTotal(),estoqueAtual) - Constantes: UPPER_SNAKE_CASE (ex:
TAXA_JUROS)
- Tipos de Dados e Conversões
O sistema de tipos em Java divide-se em primitivos e de referência. Os tipos primitivos são oito: byte, short, int, long (integrais), float, double (ponto flutuante), char (caractere Unicode de 16 bits) e boolean (verdadeiro/falso). Os demais tipos são referências a objetos, arrays ou coleções.
Conversões ocorrem implicitamente quando há promoção de faixa de armazenamento (ex: int para long). O processo inverso exige cast explícito e pode resultar em perda de dados ou troncamento. Literais numéricos decimais são tratados como double por padrão; para float, utiliza-se o sufixo F. Literais inteiros são int; para long, usa-se L.
// Exemplo de conversão e tipos
double valorPreciso = 12.95;
int valorInteiro = (int) valorPreciso; // Troncamento: resulta em 12
long quantidadeGlobal = 5_000_000L;
float margemLucro = 0.15F;
- Constantes, Variáveis e Escopo
Variáveis são espaços nomeados na memória para armazenar valores mutáveis. Constantes são valores imutáveis após a inicialização, geralmente marcadas com final. O ciclo de vida e a visibilidade de uma variável dependem do escopo onde foi declarada:
- Variáveis de Instância: Pertencem ao objeto, vivem na heap, inicializadas com valores padrão (
0,null,false). - Variáveis Locais: Declaram-se dentro de métodos ou blocos, residem na pilha (stack) e exigem inicialização explícita antes do uso.
- Strings e Buffers de Caractere
A classe java.lang.String representa sequências imutáveis de caracteres. Qualquer operação de concatenação ou modificação gera um novo objeto, o que pode impactar performence em loops extensos. Para mutação eficiente, utilizam-se StringBuilder (não thread-safe) e StringBuffer (thread-safe, com sincronização interna).
StringBuilder construtor = new StringBuilder("Início");
construtor.append("-Processo").append("-Fim");
String resultado = construtor.toString();
// Comparação correta de conteúdo
String fraseA = "Java";
String fraseB = new String("Java");
boolean conteudoIgual = fraseA.equals(fraseB); // true
boolean referenciaIgual = fraseA == fraseB; // false
- Arrays e Operadores
Arrays são objetos de tamanho fixo que armazenam elementos do mesmo tipo. Podem ser inicializados com declaração estática ou dinâmica. O acesso ocorre via índice base zero, e a propriedade .length retorna o tamanho total. Operadores aritméticos, relacionais, lógicos e bit a bit seguem regras de precedência padronizadas, com suporte a auto-incremento/decremento (++, --) e operadores compostos (+=, &=).
- Estruturas de Controle de Fluxo
Java suporta decisões condicionais (if/else, switch) e repetições (for, while, do-while). O switch moderno aceita strings, enums e permite expressões sem necessidade de break explícito quando usando sintaxe de flecha (->). Para interromper ciclos ou pular iterações, utilizam-se break e continue, respectivamente.
// Estrutura switch moderna
int diaSemana = 3;
String nomeDia = switch (diaSemana) {
case 1 -> "Segunda";
case 2 -> "Terça";
case 3 -> "Quarta";
default -> "Outro dia";
};
- Fundamentos de Orientação a Objetos
Classes, Objetos e Modelo de Memória
Uma classe define um molde com atributos (estado) e métodos (comportamento). Objetos são instâncias materializadas na heap, enquanto referências apontam para esses endereços. O carregamento de classes ocorre sob demanda pelo JVM, passando por verificação, preparação e inicialização na área de métodos (ou Metaspace, a partir do JDK 8+).
Encapsulamento e Modificadores de Acesso
O encapsulamento restringe o acesso direto aos atributos, expondo-os via métodos get/set. Os níveis de visibilidade são:
public: acessível universalmente.protected: visível no mesmo pacote e subclasses.default(sem modificador): restrito ao pacote.private: exclusivo da classe declarante.
Herança e Polimorfismo
Java adota herança simples (extends), permitindo que subclasses herdem membros não privados. O polimorfismo permite tratar objetos de subclasses através de referências de superclasses ou interfaces. O binding de métodos é dinâmico: a implementação executada corresponde ao tipo real do objeto em tempo de execução.
class Veiculo {
void acelerar() { System.out.println("Movendo genericamente"); }
}
class CarroEletrico extends Veiculo {
@Override
void acelerar() { System.out.println("Torque instantâneo"); }
}
// Polimorfismo
Veiculo opcao = new CarroEletrico();
opcao.acelerar(); // Executa a versão de CarroEletrico
Classes Abstratas e Interfaces
Classes abstratas (abstract class) podem conter métodos concretos e abstratos, mas não são instanciáveis. Interfaces definem contratos de comportamento. Desde o Java 8, suportam métodos default (com implementação) e static. Uma classe pode implementar múltiplas interfaces, contornando a limitação de herança simples.
- Classes Internas e Modificadores Específicos
Classes internas (inner classes) vivem dentro de outra classe e acessam seus membros, inclusive privados. Classes anônimas eliminam a necessidade de nomear implementações simples de interfaces. O modificador static associa membros à classe (não a instâncias), enquanto final impede mutação de variáveis, sobrescrita de métodos ou herança de classes.
- Sobrecarga, Substituição e Classes Wrapper
Sobrecarga (overloading) ocorre quando métodos compartilham nome mas diferem em assinatura (número/tipo de parâmetros). Substituição (overriding) exige mesma assinatura, mesmo ou mais amplo nível de acesso e compatibilidade de tipo de retorno, sendo facilitada pela anotação @Override. Classes wraper (Integer, Double, etc.) encapsulam tipos primitivos como objetos, habilitando conversão automática (autoboxing/unboxing).
- Generics, Varargs e Reflexão
Generics (<T>) garantem segurança de tipo em tempo de compilação, eliminando casts explícitos. O mecanismo utiliza type erasure em tempo de execução, substituindo parâmetros por Object ou limites superiores. Varargs (Tipo... nome) aceitam número variável de argumentos, tratados internamente como arrays. Reflexão permite inspecionar classes, métodos, campos e anotações em runtime via java.lang.reflect e Class<?>.
// Uso básico de Reflexão
Class<?> modelo = Class.forName("com.exemplo.Servico");
Object instancia = modelo.getDeclaredConstructor().newInstance();
Method metodo = modelo.getMethod("processar", String.class);
metodo.invoke(instancia, "dado_teste");
- Anotações e Testes Unitários
Anotações são metadados processáveis por compiladores, frameworks ou em runtime. Metadados como @Target e @Retention controlam onde e quando uma anotação é visível. Para testes, o JUnit fornece anotações como @Test, @BeforeEach e @AfterEach, estruturando a validação de unidades de código de forma isolada e repetível.
- APIs REST, BigDecimal e Proxies Dinâmicos
APIs RESTful seguem princípios de statelessness, identificadores de recursos via URI e uso semântico de verbos HTTP. Para cálculos financeiros ou científicos, java.math.BigDecimal evita erros de precisão binária de double. Proxies dinâmicos geram implementações em tempo de execução: o JDK utiliza interfaces e InvocationHandler, enquanto bibliotecas como CGLIB criam subclasses byte-coded para classes concretas, ampliendo a capacidade de interceptação (ex: transações, logging).
- Tratamento de Exceções
A hierarquia Throwable divide-se em Error (falhas críticas do VM) e Exception. Exceções verificadas exigem tratamento ou declaração via throws; as não verificadas (RuntimeException) ocorrem em tempo de execução. Blocos try-catch-finally isolam código de risco, garantem limpeza de recursos e suportam multi-catch. Exceções customizadas estendem Exception ou RuntimeException para domínios específicos.
- Complexidade Algorítmica e Geradores de ID
Notação Big O descreve escalabilidade temporal/espacial. O(1) indica acesso constante (ex: array por índice), enquanto O(log n) representa crescimento logarítmico (ex: busca binária), ambos superiores a O(n) ou O(n²) em cenários de grande volume. Para geração de identificadores distribuídos, UUID garante unicidade global sem coordenação central, mas pode fragmentar índices de banco de dados. O algoritmo Snowflake (64 bits) produz IDs monotonicamente crescentes com timestamp, worker ID e sequência, otimizando performance de inserts em bancos relacionais, embora exija cuidado com sincronismo de relógio.
- Expressões Cron e Fundamentos Binários
Expressões Cron definem agendamentos temporais usando seis ou sete campos (segundos, minutos, horas, dia do mês, mês, dia da semana, ano opcional). Operadores como * (qualquer), / (intervalo), - (faixa) e ? (sem especificação) flexibilizam a definição de tarefas recorrentes. Em nível底层, computadores representam dados em binário (0/1) por estabilidade elétrica e compatibilidade com álgebra booleana. Áudio e vídeo são convertidos via amostragem e quantização, posteriormente comprimidos por codecs que exploram redundância temporal e espacial para otimizar armazenamento e transmissão.