Pular para o conteúdo principal

Questão de Programação — Plataforma Java — Quadrix 2025

ProgramaçãoPlataforma Java
Código
qg603658
Banca
Quadrix
Órgão
SEDF
Ano
2025
Nível
Superior
Cargo
Professor de Educação Básica: Informática
O professor André ministra uma disciplina de Desenvolvimento Web em Java EE para alunos de nível superior. Ele solicita que os estudantes implementem um sistema simplificado de cadastro de produtos, utilizando J2EE, que inclui tipos de dados elementares e estruturados, métodos (funções e procedimentos) e estruturas de controle de fluxo. Parte do código desenvolvido é apresentada a seguir.


public class Produto {
    private String nome;
    private int quantidade;
    private double preco;
 
public Produto(String nome, int quantidade, double preco) {
    this.nome = nome;
    this.quantidade = quantidade;
    this.preco = preco;
 }

public double calcularValorTotal() {
 return quantidade * preco;
 }

  public void aplicarDesconto(double percentual) {
      if(percentual > 0 & percentual < 100) {
        preco ‑= preco * percentual / 100;
     } else {
         System.out.println(“Percentual inválido”);
   }
 }

  public static void main(String[] args) {
       Produto p = new Produto(“Notebook”, 5, 4500.00);
       p.aplicarDesconto(10);
       System.out.println(“Valor total: “ + p.calcularValorTotal());
    }
}
A respeito do código Java apresentado, julgue o item seguinte.O tipo double utilizado para o atributo preco é adequado para representar valores monetários em Java, garantindo precisão absoluta nos cálculos financeiros.
  1. CCerto
  2. EErrado
Revelar gabarito e comentário

GabaritoE — Errado

Comentário gerado por IA. É um apoio ao estudo, ancorado em fontes, mas pode conter imprecisões — confira sempre na fonte oficial (lei, súmula, edital e gabarito da banca). Encontrou um erro? Use “Reportar”.

Tipos primitivos em Java: double e precisão monetária

Gabarito: ERRADO. O tipo double é um ponto flutuante de precisão dupla (IEEE 754) e, por isso, não garante precisão absoluta em cálculos financeiros — ele sofre de erros de arredondamento inerentes à representação binária de números decimais. Para valores monetários, a prática recomendada em Java é usar BigDecimal (ou int/long com centavos), conforme o próprio contexto da linguagem e boas práticas de mercado.

O double é um tipo primitivo de ponto flutuante, assim como o float. A diferença entre eles é a precisão: o double ocupa 64 bits e o float 32 bits. Ambos seguem o padrão IEEE 754, que representa números em binário (mantissa e expoente). O problema é que nem todo número decimal finito em base 10 é finito em base 2. Por exemplo, o número 0.1 em decimal é uma dízima periódica em binário (0.0001100110011...). Ao armazenar esse valor em um double, ele é truncado/arredondado para caber nos 64 bits, introduzindo um pequeno erro.

Esse erro é imperceptível em operações isoladas, mas acumula-se em cálculos repetidos — exatamente o que acontece em sistemas financeiros com somas, multiplicações e descontos. No código da questão, o método calcularValorTotal() multiplica quantidade * preco, e aplicarDesconto() faz preco -= preco * percentual / 100. Cada operação com double pode introduzir um erro de arredondamento, e o resultado final pode divergir do valor exato esperado.

Para ilustrar, considere o cálculo 0.1 + 0.2 em Java:

double a = 0.1;
double b = 0.2;
System.out.println(a + b); // imprime 0.30000000000000004

O resultado não é exatamente 0.3, mas sim 0.30000000000000004. Esse é o clássico exemplo do erro de ponto flutuante. Em um sistema financeiro, essa diferença de centavos (ou frações de centavos) pode se acumular e causar problemas de conciliação.

A alternativa correta para representar valores monetários em Java é a classe BigDecimal, que permite controle total sobre a precisão e o arredondamento. Ela é imutável e representa números decimais com precisão arbitrária, sendo a escolha recomendada pela documentação oficial da Oracle para cálculos financeiros. Outra abordagem é usar int ou long para armazenar o valor em centavos (ou a menor unidade monetária), evitando completamente o ponto flutuante.

A pegadinha da questão está em afirmar que o double "garante precisão absoluta". A palavra "absoluta" é o gatilho: nenhum tipo de ponto flutuante (nem float, nem double) garante precisão absoluta. A banca explora exatamente essa confusão entre "precisão suficiente para a maioria dos casos" e "precisão absoluta".

NÃO CAIA NESSA!

A banca troca "adequado para representar" (que pode até ser discutível em contextos simples) por "garantindo precisão absoluta" — a palavra "absoluta" é o termo que torna a afirmação falsa. O candidato que sabe que double é usado para decimais pode marcar "Certo" sem perceber que a afirmação vai além do que o tipo oferece. Em questões de Java, desconfie sempre de termos como "absoluto", "sempre", "nunca" — eles costumam indicar uma generalização indevida.

Tipos para valores monetários em Java
  • 1double (ponto flutuante, IEEE 754)
    • Não garante precisão absoluta
    • Erro de arredondamento (0.1 + 0.2 ≠ 0.3)
    • Erro acumula em cálculos repetidos
  • 2BigDecimal (precisão arbitrária)
    • Controle total de precisão
    • Controle de arredondamento
    • Recomendado para cálculos financeiros
  • 3int/long (centavos)
    • Evita ponto flutuante
    • Precisão exata
LEVEL · soulevel.com.br

Alternativa E — ✅ Correta (gabarito)

A afirmação é ERRADA porque o double não garante precisão absoluta em cálculos financeiros. O tipo double é um ponto flutuante de precisão dupla (64 bits, IEEE 754), e sua representação binária introduz erros de arredondamento em números decimais. Para valores monetários, a prática recomendada é usar BigDecimal, que oferece precisão arbitrária e controle de arredondamento, ou int/long com centavos. O erro da alternativa está na palavra "absoluta": o double é adequado para muitos cálculos, mas não para aqueles que exigem exatidão total, como os financeiros.

Gabarito: letra E (ERRADO).

Link permanente: /questoes/qg603658