O que é Java?

Java é uma linguagem de programação de propósito geral, orientada a objetos e fortemente tipada, lançada pela Sun Microsystems em 1995, que compila para um bytecode executado por uma máquina virtual, a JVM. É por esse arranjo que o mesmo programa compilado roda em qualquer sistema com uma JVM instalada. Neste guia você entende como a linguagem Java funciona por dentro, para que ela serve, quanto custa de verdade, quando ela atrapalha e o que mudou com as versões 25, 26 e 27. Em outubro de 2026, a versão LTS em vigor é o Java 25, e a 27 é a mais recente.

• 29,4% de todos os respondentes do Stack Overflow Developer Survey de 2025 usam Java, e 29,6% entre os desenvolvedores profissionais
• 18 JEPs entraram no Java 25, a LTS em vigor, lançada em 16/09/2025 segundo o anúncio de disponibilidade geral do OpenJDK
• Duas versões em 2026: Java 26 em 17/03/2026 e Java 27 em 15/09/2026, conforme as páginas de projeto do OpenJDK
• Setembro de 2027 é a data da próxima LTS, o Java 29, de acordo com o roadmap de suporte do Java SE da Oracle

O que é Java e por que a linguagem continua entre as mais usadas do mundo

Java é uma linguagem de programação de propósito geral, orientada a objetos e fortemente tipada, lançada pela Sun Microsystems em 1995, que vem acompanhada de uma máquina virtual própria. A especificação oficial da linguagem, na edição para o Java SE 25, a descreve como “general-purpose, concurrent, class-based, object-oriented” e acrescenta que ela foi desenhada para ser simples o bastante para muitos programadores atingirem fluência. A tipagem é estática e forte, então boa parte dos erros aparece quando você compila, antes de o programa rodar.

Dizer “Java” é dizer duas coisas ao mesmo tempo. Num time de engenharia em São Paulo, a palavra pode se referir à sintaxe que você escreve no arquivo .java ou à máquina virtual que roda o resultado no servidor. Cada metade tem uma especificação formal separada (a JLS para a linguagem, a JVMS para a máquina virtual), e as duas ganham edição nova a cada versão do Java SE.

Em uso, a linguagem Java segue entre as maiores do mundo. No Stack Overflow Developer Survey de 2025, 29,4% de todos os respondentes disseram usar Java, e 29,6% entre os desenvolvedores profissionais. Para efeito de escala, no mesmo levantamento:

• JavaScript: 66% dos respondentes
• SQL: 58,6%
• Python: 57,9%
• Java: 29,4%

Uma ressalva que quase todo artigo pula: a pesquisa do Stack Overflow é de autosseleção. Responde quem frequenta o site e tem vontade de responder, e quem já trabalhou em time de sistemas internos sabe que esse pessoal raramente preenche questionário de comunidade. Os 29,4% são uma fotografia da parte visível da profissão. O número que roda em produção é outro, e ninguém o mediu.

Por que a linguagem durou três décadas? As metas de projeto que a Sun fixou em 1996, no documento em que apresentou a linguagem ao mercado, estão organizadas em cinco grupos, e a lista envelheceu bem:

1. “Simple, Object Oriented, and Familiar”
2. “Robust and Secure”
3. “Architecture Neutral and Portable”
4. “High Performance”
5. “Interpreted, Threaded, and Dynamic”

O slogan “Write Once, Run Anywhere”, que você ainda vê em camiseta de evento, é marketing nascido do terceiro item: compilar uma vez e rodar o mesmo programa em qualquer sistema que tenha uma JVM. Na minha leitura, é esse item, mais do que a sintaxe, que explica os 29% depois de 31 anos. Linguagem bonita existe aos montes. Linguagem cujo binário de 2005 ainda sobe num servidor de 2026 é raridade.

Como funciona a linguagem Java: da JVM ao bytecode

A linguagem Java funciona em duas etapas: o compilador javac transforma o código-fonte em bytecode independente de máquina, e a Java Virtual Machine (JVM) carrega, liga, otimiza e executa esse bytecode no computador de destino. É esse arranjo que permite compilar um programa uma única vez e rodá-lo em qualquer sistema que tenha uma JVM instalada.

O exemplo mínimo tem dois comandos. javac Test.java lê o arquivo-fonte e gera Test.class, um arquivo binário que não contém instruções do seu processador, e sim instruções de uma máquina abstrata. java Test sobe a JVM, que então faz o trabalho pesado:

1. Carrega as classes a partir dos arquivos .class.
2. Liga essas classes entre si, conferindo as referências de uma para a outra.
3. Gera código de máquina, opcionalmente, e otimiza o programa enquanto ele roda.
4. Executa o programa.

O formato do .class e o conjunto de instruções do bytecode estão fixados na Especificação da Máquina Virtual Java (JVMS). É por isso que o mesmo arquivo roda em qualquer JVM que siga a especificação, seja no seu notebook, seja num servidor Linux na nuvem. Quem padroniza cada versão é o Java Community Process (JCP): o Java SE 25, por exemplo, está definido na JSR 400, cuja versão final saiu em 09/09/2025.

O item 3 da lista surpreende quem vem de linguagens compiladas direto para código nativo. Como a JVM pode gerar código de máquina durante a execução, ela escolhe o que otimizar com base no que o programa de fato faz, e um serviço Java costuma responder mais rápido depois de aquecido do que nos primeiros instantes após subir. Quem opera esse tipo de serviço aprende isso na primeira vez que compara a latência logo após um deploy com a latência de uma hora depois.

Três siglas se misturam o tempo todo, e vale separar:

Componente	O que contém	Quem precisa
JVM	A máquina virtual que executa o bytecode	Todo programa Java em execução
JRE	JVM, classes centrais e bibliotecas da plataforma	Quem só vai rodar programas prontos
JDK	Tudo do JRE mais o javac e as ferramentas de desenvolvimento	Quem escreve e compila código

Na prática, você instala o JDK. O JRE sozinho é herança de uma época em que o usuário final instalava Java no desktop para rodar um programa pronto, e esse cenário praticamente sumiu do dia a dia de quem desenvolve.

A especificação é uma, as implementações são várias. Oracle, Temurin, Azul e Corretto são alguns dos nomes de JDK que você vai encontrar ao instalar. Eles diferem em suporte e licença, e o seu .class roda igual em qualquer um deles.

Para que serve Java? Aplicações mais comuns no mercado

Java serve para construir backends corporativos e serviços web, aplicativos Android, sistemas de grande porte com muitos usuários simultâneos e plataformas de processamento de dados. A linguagem foi definida como de propósito geral, então nada impede um utilitário de linha de comando, mas o mercado a concentrou onde o programa precisa rodar por anos, em vários servidores, mantido por times que se renovam.

Os domínios em que você mais vai encontrar programação em Java:

• Backend corporativo e web: APIs e serviços que atendem muitas requisições ao mesmo tempo, com a concorrência tratada pela própria linguagem, que é concorrente por especificação.
• Android: a plataforma móvel do Google foi construída sobre APIs do Java SE, e os apps escritos em Java chamam essas interfaces.
• Sistemas de grande porte: processamento de pedidos, cobrança, logística e sistemas de governo, em que o custo de reescrever é alto e a portabilidade do bytecode entre servidores pesa na decisão.
• Serviços distribuídos e processamento de dados: o mesmo artefato compilado roda em máquinas diferentes de um cluster sem recompilar, o que simplifica subir dezenas de instâncias do mesmo serviço.

O caso do Android merece um parágrafo próprio. Em 2021, a Suprema Corte dos EUA decidiu, no caso Google v. Oracle, que a cópia de APIs do Java SE pelo Google ao construir o Android foi fair use. A Corte assumiu, sem decidir, que o código seria protegido por direito autoral e resolveu a disputa pela exceção de uso justo. Para quem desenvolve, a briga mostra o tamanho da presença de Java no celular: o litígio girou em torno das interfaces que todo app Android em Java chama.

No Brasil, a evidência institucional mais antiga é de 2005, quando o Serpro entrou no Java Community Process, o órgão que padroniza as versões da plataforma. Estatística oficial sobre uso de Java nas empresas brasileiras não existe, nem no IBGE nem no Cetic.br. O que existe é o atrito do dia a dia: se o seu projeto de implementação de IA precisa conversar com um sistema de cobrança ou de logística que já está no ar há anos, prepare-se para encontrar Java do outro lado da API. Quem já integrou um modelo a um sistema legado sabe que a primeira semana vai embora entendendo contratos de serviço escritos em outra década.

Quais as principais características da programação em Java

As principais características da programação em Java são cinco: tudo é classe e objeto, os tipos são conferidos antes de o programa rodar, várias threads convivem no mesmo processo por desenho da linguagem, o bytecode roda em qualquer JVM e a memória é devolvida por um coletor de lixo, sem você liberar nada à mão. Nenhuma delas depende de biblioteca de terceiros. Todas vêm da especificação da linguagem ou da especificação da máquina virtual.

Em detalhe:

• Orientação a objetos baseada em classes: você descreve o programa como um conjunto de classes, e cada objeto nasce de uma delas. A JLS classifica a linguagem como “class-based, object-oriented”, e isso molda até o Hello World, que durante décadas exigiu declarar uma classe antes de imprimir uma linha.
• Tipagem estática e forte: todo valor tem tipo conhecido quando você compila, e a JLS separa os erros que o compilador pega dos que só aparecem com o programa no ar. Um campo que muda de int para long quebra o build no terminal, em vez de quebrar a cobrança de sexta à noite.
• Concorrência dentro da linguagem: a especificação define Java como “concurrent”, então threads fazem parte do modelo desde a primeira versão. O Java 25 reforçou esse modelo ao tornar final a API de Scoped Values (JEP 506), que passa valores entre threads com escopo delimitado.
• Portabilidade do bytecode: o arquivo .class segue o formato fixado na JVMS, e o mesmo binário sobe em qualquer máquina virtual que respeite a especificação, do seu notebook ao servidor na nuvem.
• Memória gerenciada: quem libera objetos é o coletor de lixo da JVM. Desde o Java 27, o G1 é o coletor padrão em todos os ambientes, e o Java 25 entregou a versão geracional do Shenandoah (JEP 521) para quem quer outro coletor com o mesmo modelo de gerações.
• Erros barrados em camadas: o compilador recusa tipos incompatíveis, e a JVM confere as referências entre classes ao ligar o programa. É assim que a plataforma entrega as metas de segurança e tolerância a falhas que a Sun fixou em 1996, por mecanismo e sem depender da disciplina de cada programador.

O preço dessa combinação sempre foi a cerimônia. Para imprimir uma linha, o programador declarava uma classe pública, um método main estático com assinatura fixa e só então a chamada de impressão. Quem ensinou Java para iniciantes sabe como é explicar public static void main(String[] args) para alguém que ainda nem entendeu o que é uma variável.

Essa crítica perdeu força em 2025. O Java 25 trouxe arquivos-fonte compactos e métodos main de instância (JEP 512), que cortam a classe obrigatória e o modificador estático do primeiro programa, e as versões seguintes continuam reduzindo a sintaxe com pattern matching e outras mudanças. A tipagem forte, por outro lado, ninguém quer que afrouxe: renomeie um campo num serviço com cinco anos de código e o compilador aponta cada lugar que quebrou. Em linguagem de tipagem dinâmica, você descobre isso com o cliente.

Qual a diferença entre Java, JavaScript e outras linguagens populares

Java e JavaScript são linguagens diferentes, sem parentesco além do nome: Java é compilada para bytecode, roda na JVM e confere tipos antes de executar, enquanto JavaScript nasceu para rodar dentro do navegador e só verifica tipos em tempo de execução. A semelhança para por aí. Um recrutador que escreve “vaga Java” numa descrição de frontend vai receber currículo errado o dia inteiro.

A confusão entre as duas aparece em quatro pontos, e em todos a resposta é oposta:

Critério	Java	JavaScript
Tipagem	estática e forte	dinâmica
Onde roda	na JVM, a partir de bytecode	no navegador e em runtimes de servidor próprios
Compilação	javac gera .class antes de rodar	o código-fonte é lido e executado pelo motor da linguagem
Uso mais comum	backend corporativo, Android, sistemas de grande porte	interfaces web, lógica de página, frontend

Fora o homônimo, as comparações que aparecem numa decisão de arquitetura são com Python, C# e Kotlin. As três se parecem com Java em algum eixo e diferem em outro:

• Python: tipagem dinâmica e execução por interpretador próprio. Domina ciência de dados, scripts e automação, onde o ciclo escrever-rodar-corrigir importa mais do que pegar erro de tipo antes de executar.
• C#: tipagem estática como Java, mas com runtime próprio, a plataforma .NET. É a escolha de quem já opera no ecossistema .NET e quer aplicações corporativas e de desktop dentro dele.
• Kotlin: tipagem estática, compila para o mesmo bytecode e roda na mesma JVM. Um projeto pode misturar classes Java e Kotlin no mesmo build, e é por isso que a troca de uma pela outra no Android raramente é uma troca de plataforma.

Em adoção, o Stack Overflow Developer Survey de 2025 mostra a distância entre os grupos. Entre os desenvolvedores profissionais, JavaScript aparece em 68,8% das respostas, SQL em 61,3%, Python em 54,8% e Java em 29,6%.

Esses números medem presença, e presença engana. JavaScript roda em quase toda página da web, então quase todo profissional encosta nele em algum momento, mesmo quem passa o dia num backend em Java. Os 29,6% de Java contam quem escreve a linguagem com frequência, e esse recorte pesa mais em sistema interno de empresa grande, que é justo o perfil menos propenso a responder pesquisa de comunidade.

Acontece que a diferença que decide projeto não está na tabela. Está no que acontece quando o código erra: em Java, uma parte dos erros morre no compilador, e em JavaScript e Python o mesmo erro chega ao usuário. Cada time escolhe em que ponto prefere pagar essa conta.

Quanto custa usar Java: licenças, JDKs gratuitos e infraestrutura

Usar Java não custa licença: a linguagem, as duas especificações e o OpenJDK, projeto de código aberto em que cada versão da plataforma é desenvolvida, podem ser baixados e usados sem pagar, e builds de terceiros como Temurin, Corretto e Azul distribuem o mesmo OpenJDK sem cobrar pelo direito de uso. O dinheiro entra por três portas, e nenhuma delas é a linguagem em si.

Onde o custo aparece de verdade:

1. O JDK da Oracle em cenários específicos. O roadmap de suporte do Java SE publicado pela Oracle informa que, a partir do Critical Patch Update (CPU) de outubro de 2026, as atualizações do JDK 21 passam para a licença OTN. Quem baixa os patches do Java 21 direto da Oracle a partir desse mês opera sob outros termos, e precisa lê-los antes de aplicar a atualização em produção. O bytecode continua o mesmo. O contrato muda.
2. Suporte contratado. O mesmo roadmap define janelas de Premier Support e Extended Support por versão LTS, e são essas janelas que um contrato com a Oracle compra. Outros distribuidores vendem suporte sobre os próprios builds. Se ninguém no seu time precisa de um fornecedor para ligar às 3h da manhã, esse custo é zero.
3. Infraestrutura. É o item que falta na planilha e sobra na fatura da nuvem.

A saída que a maioria dos times adota é mecânica: rodar um build do OpenJDK de outro distribuidor, que entrega o mesmo bytecode e a mesma JVM conforme à especificação, e só contratar suporte quando a operação exigir. Nenhuma linha de código precisa mudar para trocar de distribuidor.

O custo de infraestrutura tem duas origens que o manual não destaca. A primeira é o aquecimento: como a JVM otimiza o programa enquanto ele roda, um serviço leva alguns minutos para chegar à latência de regime, e quem escala por demanda paga instâncias que ainda estão esquentando. A segunda é memória por objeto, porque cada objeto na JVM carrega um cabeçalho. A plataforma atacou esse ponto com os Compact Object Headers, que entraram no Java 25 (JEP 519) e ficaram ligados por padrão no Java 27 (JEP 534).

Quanto isso representa em reais por mês ninguém consegue dizer sem medir o seu serviço, com o seu tráfego, no seu provedor. Um trabalho de consultoria DevOps sobre uma frota Java costuma começar exatamente por aí: tamanho de heap por instância, tempo até a latência estabilizar e quantas réplicas sobram ociosas depois do pico. Só depois de ter esses três números é que vale discutir contrato de suporte.

Quando Java não é a melhor escolha

Java não é a melhor escolha para scripts de uma tarde, análise exploratória de dados, interface de página web, dispositivos com memória contada em kilobytes e processos que precisam responder no primeiro milissegundo depois de subir. Em cada um desses casos, o que a plataforma entrega (tipos conferidos antes de rodar, uma máquina virtual que otimiza o programa em execução, bytecode portável) custa mais do que rende.

Os cinco cenários, com o motivo mecânico de cada um:

• Script rápido e protótipo descartável: escrever, compilar com javac e subir a JVM são passos a mais num programa que vai viver uma hora. Em linguagem de tipagem dinâmica, você edita e executa.
• Ciência de dados: o trabalho é exploratório, feito em trechos curtos que o analista roda, olha e refaz. Python concentra esse uso, e a tipagem estática de Java, que compensa quando o código vive anos, atrapalha quando o código vive minutos.
• Frontend web: o navegador executa JavaScript. Java não roda ali.
• Embarcado com memória mínima: a JVM ocupa espaço para si mesma, e cada objeto carrega um cabeçalho. O Java 25 removeu o porte x86 de 32 bits (JEP 503), um sinal claro de para onde a plataforma olha.
• Inicialização crítica: a JVM sobe, carrega classes, liga tudo e só depois começa a otimizar. Uma função que nasce, responde uma requisição e morre nunca chega ao regime em que Java rende mais.

A plataforma reagiu em dois desses pontos. Os arquivos-fonte compactos do Java 25 encurtam o primeiro programa, e os Compact Object Headers, ligados por padrão desde o Java 27, reduzem o que cada objeto ocupa na memória. São respostas de verdade. Só que nenhuma delas muda a natureza de um ambiente pensado para processos que ficam no ar por meses, e é essa natureza que decide a escolha.

O erro que mais vejo em arquitetura tem outra forma. O time acerta ao escolher Java para o serviço de cobrança e depois insiste em escrever em Java o script de migração que roda uma vez, o notebook de análise e a automação do deploy. Cada uma dessas tarefas tem ferramenta melhor, e usar a mesma linguagem para tudo só parece economia até a segunda semana.

Para quem vale a pena aprender programação em Java

Aprender programação em Java vale a pena para quatro perfis: quem quer vaga em backend de empresa grande, quem desenvolve ou pretende desenvolver para Android, estudantes de computação que precisam entender tipos, classes, threads e memória com clareza, e iniciantes que preferem um compilador apontando o erro antes de o programa rodar. Para quem mira ciência de dados ou frontend, o tempo rende mais em outra linguagem.

O que cada perfil ganha:

• Backend corporativo: os sistemas em que Java vive (cobrança, logística, governo, serviços que atendem muitas requisições ao mesmo tempo) são mantidos por times que se renovam. Enquanto esses sistemas estiverem no ar, alguém precisa ler e alterar esse código.
• Android: a plataforma móvel do Google nasceu sobre APIs do Java SE, e Kotlin, a outra linguagem do Android, compila para o mesmo bytecode e roda na mesma JVM. Quem entende Java lê os dois lados de um projeto misto.
• Estudante de computação: a linguagem e a máquina virtual têm especificações formais separadas, com edição nova a cada versão do Java SE. Poucas plataformas deixam o aluno ler, em documento oficial, exatamente o que acontece entre o código-fonte e o processador.
• Iniciante: a especificação diz que a linguagem foi desenhada para que muitos programadores atinjam fluência, e o Java 25 cortou a classe obrigatória e o main estático do primeiro programa (JEP 512). O compilador faz o papel de tutor que recusa o código errado.

Sobre a curva de aprendizado, vale ser honesto: a parte difícil raramente é a sintaxe. É a primeira semana de ferramentas, com instalação de JDK, build e a descoberta de que o programa compila no seu notebook e falha no do colega por diferença de versão. Quem supera essa semana costuma seguir sem sustos.

Sobre empregabilidade no Brasil, não existe estatística oficial de vagas ou salários para a linguagem Java, então qualquer número que você vir em anúncio de curso veio de amostra que ninguém auditou. O que dá para afirmar é o mecanismo: sistema que vive anos gera manutenção por anos, e Java domina justamente esse tipo de sistema.

O que mudou no Java em 2026: versões LTS e novos recursos

Em 2026 o Java ganhou duas versões novas, a 26 em 17/03/2026 e a 27 em 15/09/2026, nenhuma delas de suporte longo. A versão LTS em vigor continua sendo o Java 25, lançado em 16/09/2025, e a próxima LTS, o Java 29, chega em setembro de 2027.

O ritmo é visível nas datas: uma versão em março, outra em setembro, e uma LTS a cada dois anos. As versões de suporte longo são 8, 11, 17, 21 e 25. Para o Java 25, o roadmap de suporte da Oracle marca Premier Support até setembro de 2030 e Extended Support até setembro de 2033. Esses prazos mudam de edição em edição do roadmap, então confira a página antes de fechar um plano de migração.

O que cada versão trouxe:

Versão	GA	LTS	Destaques
Java 25	16/09/2025	sim	18 JEPs: arquivos-fonte compactos (JEP 512), Scoped Values (JEP 506), Flexible Constructor Bodies (JEP 513)
Java 26	17/03/2026	não	10 JEPs: HTTP/3 no cliente HTTP (JEP 517), remoção da API de Applets (JEP 504)
Java 27	15/09/2026	não	G1 padrão em todos os ambientes (JEP 523), criptografia pós-quântica no TLS 1.3 (JEP 527), Compact Object Headers por padrão (JEP 534)

O Java 25 é a versão que importa para quem decide o que vai para produção. O anúncio de disponibilidade geral do JDK 25, publicado por Mark Reinhold em 16/09/2025, lista 18 JEPs. Além dos três da tabela, entraram as declarações de importação de módulo (JEP 511), que trazem um módulo inteiro com uma linha, os Compact Object Headers como opção (JEP 519), o Shenandoah geracional (JEP 521) e a remoção do porte x86 de 32 bits (JEP 503). Os Flexible Constructor Bodies permitem executar código antes da chamada ao construtor da superclasse, uma restrição que incomodava desde a primeira versão da linguagem.

O Java 26 fechou um capítulo. A lista de JEPs do JDK 26 inclui a remoção da API de Applets, a interface que um dia fez Java rodar dentro do navegador, e o suporte a HTTP/3 no cliente HTTP da plataforma. Dez JEPs no total, e nenhum deles muda a sintaxe que você escreve.

O Java 27 mexeu em infraestrutura. O G1 virou o coletor de lixo padrão em todo ambiente, os Compact Object Headers passaram de opcionais a ligados, e o TLS 1.3 ganhou troca de chaves híbrida pós-quântica. Esse último item é o que mais interessa a quem opera serviço financeiro: o algoritmo de troca de chaves muda sem que o código do serviço precise saber disso. Várias funcionalidades do Java 27 seguem em preview ou incubator, o que significa que podem mudar antes de virar definitivas.

A tendência de 2025 para cá é uma só: menos cerimônia no código e mais trabalho feito pela JVM sem que o programador peça. Pattern matching, arquivos-fonte compactos e structured concurrency em preview atacam a verbosidade pela sintaxe. G1 por padrão e cabeçalhos compactos atacam o custo pela máquina virtual. Se o seu serviço ainda roda no Java 17 ou no 21, o salto para o 25 é o que vale planejar em 2026.

Perguntas frequentes sobre a linguagem Java

As dúvidas mais buscadas sobre a linguagem Java no Brasil são seis, e todas têm resposta curta: custo, se ainda vale a pena, dificuldade, a confusão com JavaScript, qual versão instalar e se a linguagem é compilada ou interpretada.

Java é gratuito?

Sim. A linguagem, as duas especificações e o OpenJDK são abertos e podem ser usados sem pagar nada, e builds como Temurin, Corretto e Azul distribuem o mesmo OpenJDK sem cobrar licença. O que pode custar é suporte contratado e, em cenários específicos, o JDK da Oracle: a partir do Critical Patch Update de outubro de 2026, as atualizações do JDK 21 distribuídas pela Oracle passam para a licença OTN. Leia os termos antes de aplicar um patch em produção.

Java ainda vale a pena em 2026?

Vale, para backend corporativo, Android e qualquer sistema que vai ficar anos no ar. Em 2025, 29,6% dos desenvolvedores profissionais que responderam ao Stack Overflow usavam Java, e a plataforma entregou duas versões em 2026, a 26 em março e a 27 em setembro. Para ciência de dados ou frontend web, o seu tempo rende mais em Python ou JavaScript.

Java é difícil de aprender?

Menos do que era. A especificação define a linguagem como simples o bastante para muitos programadores atingirem fluência, e desde o Java 25 o primeiro programa dispensa a classe pública e o main estático (JEP 512). O que trava iniciante é a primeira semana de ferramentas: instalar o JDK, entender o build e descobrir que a versão do colega é outra. Depois disso, o compilador vira um tutor que recusa o código errado e aponta a linha.

Java e JavaScript são a mesma coisa?

Não, e o nome é a única coisa que as duas compartilham. Java compila para bytecode com o javac, roda na JVM e confere tipos antes de executar. JavaScript roda no navegador, verifica tipos só em tempo de execução e domina interfaces web. Uma vaga que pede “Java” para frontend quase sempre quis dizer JavaScript.

Qual versão do Java instalar?

Java 25, a versão LTS em vigor, lançada em 16/09/2025 e com Premier Support da Oracle até setembro de 2030. As versões 26 e 27 trazem recursos novos, mas não são LTS e cada uma é substituída seis meses depois de sair. Para estudar, qualquer versão serve. Para produção, fique na 25 até o Java 29 chegar, em setembro de 2027.

Java é linguagem compilada ou interpretada?

As duas coisas, em fases diferentes. O javac compila o código-fonte para bytecode, um formato independente de máquina, e a JVM executa esse bytecode. Durante a execução, a JVM pode gerar código de máquina para os trechos mais usados e otimizar o programa enquanto ele roda. A Sun listou “Interpreted” entre as metas de 1996, mas um serviço que está no ar há uma hora já pode estar rodando boa parte do caminho em código nativo gerado pela própria máquina virtual.

Por onde começar a programar em Java

Para começar a programar em Java, instale um JDK 25 gratuito, escreva o primeiro programa num arquivo-fonte compacto e siga a trilha oficial do dev.java. São três ações para a primeira tarde, e uma quarta para a primeira semana.

1. Instale o JDK 25. Escolha um build do OpenJDK (Temurin, Corretto ou Azul) ou o da Oracle, e confirme no terminal que a versão instalada é a 25. Pule o JRE: quem escreve código precisa do javac, e ele só vem no JDK.
2. Escreva o primeiro programa sem cerimônia. Com os arquivos-fonte compactos do Java 25, você declara um método main sem classe pública e sem static, compila com javac e roda com java. Se aparecer public static void main(String[] args) no seu material de estudo, ele é anterior a 2025.
3. Estude pela fonte. O portal oficial de aprendizado dev.java organiza o conteúdo em torno das especificações da linguagem e da máquina virtual, e a documentação do JDK 25 traz as duas edições correspondentes.
4. Escolha um projeto que vive mais de um dia. Uma API pequena, que recebe requisições e grava em banco, exercita classes, tipos e threads no terreno em que Java rende.

O compilador vai recusar seu código muitas vezes na primeira semana, e cada recusa é um erro que não chegou a produção. Se o seu Java já está em produção e precisa conversar com um modelo de IA, fale com o time da AlphaCorp AI sobre integrar o sistema legado sem reescrever o que funciona.