Questão de Programação — Conceitos básicos de programação — INSTITUTO AOCP 2025

Compilação e Interpretação: Java vs. Python

Gabarito: letra C (corretos os itens I e II). A divisão por zero é um erro de tempo de execução (exceção) tanto em Java quanto em Python — jamais um erro de compilação. O Java compila o código-fonte para bytecode sem avaliar expressões aritméticas (a exceção ArithmeticException só surge ao executar), enquanto o Python, por ser interpretado, executa linha por linha e interrompe o programa no exato momento em que encontra a divisão inválida, antes de chegar ao print. É essa diferença entre os modelos de execução que a questão explora.

Para entender a questão, é preciso dominar a distinção fundamental entre compilação e interpretação. Um compilador (como o javac do Java) traduz o código-fonte inteiro para uma representação executável (no caso do Java, o bytecode .class) em uma etapa separada, chamada de tempo de compilação. Nessa fase, o compilador verifica a sintaxe (se as regras gramaticais da linguagem foram seguidas) e a semântica estática (como tipos de variáveis), mas não executa o código. Por isso, uma expressão como 10 / 0 é perfeitamente válida sintaticamente — o compilador não tem como saber que o divisor é zero, pois isso só seria descoberto ao calcular o valor. O erro de divisão por zero é um erro semântico de execução, que só se manifesta quando a JVM (Java Virtual Machine) interpreta o bytecode e tenta realizar a operação, lançando a exceção ArithmeticException.

Já o Python é uma linguagem interpretada: não há uma fase de compilação separada que gere um arquivo executável. O interpretador lê o código-fonte e o executa linha por linha, em tempo real. Isso significa que, ao encontrar a linha x = 10 / 0, o interpretador tenta avaliar a expressão imediatamente e, ao detectar a divisão por zero, lança uma exceção (ZeroDivisionError) e interrompe a execução do programa naquele ponto. As linhas seguintes — incluindo o print("Fim do programa") — nunca são executadas. Essa é a essência do comportamento descrito no item II.

Um ponto que costuma gerar confusão é achar que, por ser compilada, a linguagem Java "pega" todos os erros antes de executar. Isso é verdade apenas para erros de sintaxe e alguns de semântica estática (como usar uma variável não declarada). Erros de lógica e de execução (como divisão por zero, acesso a índice fora dos limites de um array, ou tentativa de converter uma string inválida para número) só aparecem quando o programa roda. O compilador Java não avalia expressões aritméticas; ele apenas as traduz para instruções de bytecode. Portanto, a afirmação III, que diz que o Java detectaria o erro na compilação, está incorreta.

A pegadinha central desta questão é justamente a inversão do momento do erro: o candidato pode ser levado a pensar que, por ser compilada, a linguagem Java "pega" todos os erros antes de executar, enquanto o Python, por ser interpretado, só descobriria o erro depois de passar por todas as linhas. Na verdade, é o oposto: o Java compila com sucesso e só falha ao executar a linha problemática; o Python falha imediatamente na linha problemática, sem executar as posteriores. Guarde essa fronteira: erro de compilação = sintaxe/estática; erro de execução = semântica dinâmica (como divisão por zero). É exatamente nela que as assertivas se dividem.

Item I — ✅ Correto

O código Java será compilado com sucesso, pois 10 / 0 é uma expressão sintaticamente válida. O compilador javac não avalia o valor da expressão; ele apenas verifica se a sintaxe está correta e se os tipos são compatíveis (aqui, dois inteiros). O erro de divisão por zero só ocorrerá em tempo de execução, quando a JVM executar a instrução e lançar a exceção ArithmeticException. O item descreve exatamente esse fluxo: compilação bem-sucedida + erro em tempo de execução como exceção.

Item II — ✅ Correto

O Python é uma linguagem interpretada: o interpretador lê e executa o código linha por linha. Ao chegar na linha x = 10 / 0, ele tenta realizar a divisão, detecta a impossibilidade e lança a exceção ZeroDivisionError, interrompendo imediatamente a execução. A linha seguinte (print("Fim do programa")) não é executada. O item descreve corretamente esse comportamento.

Item III — ❌ Incorreto

Afirma que o Java detectaria o erro de divisão por zero durante a compilação, impedindo a geração do bytecode .class. Isso é falso: o compilador Java não avalia expressões aritméticas. A divisão por zero é um erro de tempo de execução, não de compilação. O arquivo .class seria gerado normalmente, e a exceção ArithmeticException seria lançada apenas quando a JVM executasse a instrução. O item inverte o momento do erro.

Item IV — ❌ Incorreto

Afirma que, tanto em Java quanto em Python, a instrução "Fim do programa" seria exibida antes da exceção. Isso é falso nos dois casos. Em Java, a exceção ArithmeticException é lançada na linha int x = 10 / 0;, que vem antes do System.out.println("Fim do programa"); como a exceção não é tratada, o programa é encerrado e o print nunca é executado. Em Python, o ZeroDivisionError é lançado na linha x = 10 / 0, também antes do print, interrompendo a execução. Em nenhuma das duas linguagens a mensagem seria exibida.

Conclusão: Corretos apenas os itens I e II → gabarito: letra C.

Gabarito: letra C