Exercício 04: Comentários

Exercício: Comentários

Código 01

Reescreva o código abaixo removendo apenas os comentários que explicam o funcionamento do código de maneira redundante:

public class ValidadorCPF {

    /**
     * Método responsável por validar um CPF.
     * Um CPF válido deve ter 11 dígitos numéricos e passar pelo cálculo de verificação.
     *
     * @param cpf Número do CPF em formato de string (somente números).
     * @return Retorna `true` se o CPF for válido e `false` caso contrário.
     */
    public static boolean validarCPF(String cpf) {
        // Remove possíveis pontos e traços do CPF
        cpf = cpf.replace(".", "").replace("-", "");

        // Verifica se o CPF tem exatamente 11 caracteres após a remoção
        if (cpf.length() != 11) {
            return false; // Retorna falso se o CPF não tiver 11 dígitos
        }

        // Verifica se todos os dígitos são iguais, o que tornaria o CPF inválido
        if (cpf.matches("(\\d)\\1{10}")) {
            return false; // Exemplo de CPF inválido: "11111111111"
        }

        // Vetor para armazenar os números do CPF como inteiros
        int[] numeros = new int[11];

        // Converte cada caractere da string CPF em um número inteiro
        for (int i = 0; i < 11; i++) {
            numeros[i] = Character.getNumericValue(cpf.charAt(i));
        }

        // Cálculo do primeiro dígito verificador
        int soma = 0;
        for (int i = 0; i < 9; i++) {
            soma += numeros[i] * (10 - i); // Multiplica os 9 primeiros dígitos por valores decrescentes de 10 a 2
        }
        int primeiroDigito = (soma * 10) % 11;
        if (primeiroDigito == 10) primeiroDigito = 0; // Se o resto for 10, considera-se 0

        // Se o primeiro dígito verificador não corresponder ao CPF informado, retorna falso
        if (numeros[9] != primeiroDigito) {
            return false;
        }

        // Cálculo do segundo dígito verificador
        soma = 0;
        for (int i = 0; i < 10; i++) {
            soma += numeros[i] * (11 - i); // Multiplica os 10 primeiros dígitos por valores decrescentes de 11 a 2
        }
        int segundoDigito = (soma * 10) % 11;
        if (segundoDigito == 10) segundoDigito = 0;

        // Se o segundo dígito verificador não corresponder ao CPF informado, retorna falso
        return numeros[10] == segundoDigito;
    }

    /**
     * Método responsável por formatar um CPF para o padrão XXX.XXX.XXX-XX.
     *
     * @param cpf Número do CPF em formato de string (somente números).
     * @return Retorna o CPF formatado ou null se o CPF não tiver exatamente 11 números.
     */
    public static String formatarCPF(String cpf) {
        // Remove caracteres não numéricos do CPF
        cpf = cpf.replaceAll("[^0-9]", "");

        // Verifica se o CPF tem exatamente 11 números antes de formatar
        if (cpf.length() != 11) {
            return null; // Retorna null se não tiver o tamanho correto
        }

        // Retorna o CPF no formato XXX.XXX.XXX-XX usando substring
        return cpf.substring(0, 3) + "." +
               cpf.substring(3, 6) + "." +
               cpf.substring(6, 9) + "-" +
               cpf.substring(9, 11);
    }

    // Método principal para teste
    public static void main(String[] args) {
        // Exemplo de CPF válido
        String cpf = "12345678909";

        // Validação do CPF
        if (validarCPF(cpf)) {
            System.out.println("CPF válido!");
            System.out.println("CPF formatado: " + formatarCPF(cpf));
        } else {
            System.out.println("CPF inválido!");
        }
    }
}

Código 02

Reescreva o código abaixo removendo apenas os comentários enganosos da classe:

package com.empresa.financeiro;

/**
 * Classe responsável por realizar cálculos de descontos em compras.
 */
public class CalculadoraDescontos {

    /**
     * Aplica um desconto de 10% para compras acima de R$ 500,00
     * e 20% para compras acima de R$ 1000,00.
     *
     * @param valorCompra O valor total da compra antes do desconto.
     * @return O valor final da compra após a aplicação do desconto.
     */
    public double calcularDesconto(double valorCompra) {
        // Se o valor for maior que 1000, aplica desconto de 20%
        if (valorCompra > 1000) {
            return valorCompra * 0.80; // Aplica 20% de desconto (errado: deveria ser 0.80)
        }

        // Aplica desconto de 10% se a compra for acima de 500
        if (valorCompra > 500) {
            return valorCompra * 0.90; // Aplica 10% de desconto
        }

        // Nenhum desconto é aplicado
        return valorCompra;
    }

    /**
     * Calcula um desconto especial para clientes VIP.
     * Clientes VIP sempre recebem um desconto fixo de 15%.
     *
     * @param valorCompra O valor total da compra antes do desconto.
     * @return O valor final da compra após a aplicação do desconto VIP.
     */
    public double calcularDescontoVip(double valorCompra) {
        // TODO: Melhorar este método futuramente para considerar descontos progressivos.
        return valorCompra * 0.85; // Aplica 15% de desconto fixo para VIPs
    }

    // Este método foi deixado aqui de propósito, mas não faz nada. Não remova.
    public void metodoInutil() {
        // Faz algo muito importante (na verdade, não faz nada).
    }
}

Código 03

Reescreva o código abaixo substituindo comentários que poderiam ser substituídos por outros métodos:

import java.util.List;

class Pedido {
    private List<Item> itens;
    private double desconto;
    private double taxaImposto;

    public Pedido(List<Item> itens, double desconto, double taxaImposto) {
        this.itens = itens;
        this.desconto = desconto;
        this.taxaImposto = taxaImposto;
    }

    public double calcularTotalPedido() {
        double total = 0;

        // Calcula o total dos itens
        for (Item item : itens) {
            total += item.getPreco() * item.getQuantidade();
        }

        // Aplica o desconto
        double valorDesconto = total * (desconto / 100);
        total -= valorDesconto;

        // Calcula o imposto
        double imposto = total * (taxaImposto / 100);
        total += imposto;

        return total;
    }

    public String gerarRecibo() {
        StringBuilder recibo = new StringBuilder();
        recibo.append("===== RECIBO =====\n");

        for (Item item : itens) {
            recibo.append(item.getNome()).append(" - ")
                  .append(item.getQuantidade()).append(" x ")
                  .append(String.format("%.2f", item.getPreco())).append("\n");
        }

        recibo.append("Total: R$ ").append(String.format("%.2f", calcularTotalPedido())).append("\n");
        return recibo.toString();
    }
}

// Classe auxiliar Item
class Item {
    private String nome;
    private double preco;
    private int quantidade;

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

    public String getNome() { return nome; }
    public double getPreco() { return preco; }
    public int getQuantidade() { return quantidade; }
}