Escreva uma classe Calculadora que tenha os seguintes métodos: somar, subtrair, multiplicar, dividir e elevar à potência n (todos os métodos recebem dois números como argumento). Desenvolva um programa para testar essa classe. (Detalhe: os métodos dessa classe devem ser estáticos).

Passo 1

O enunciado pede que eu escreva uma classe chamada “Calculadora” que tenha os seguintes métodos: somar, subtrair, multiplicar, dividir e elevar à potência n. Cada um desses métodos deve receber dois números como argumentos. Além disso, os métodos dessa classe devem ser estáticos. Depois, devo desenvolver um programa para testar essa classe.
Informações fornecidas pelo enunciado:
  • Nome da classe: Calculadora.
  • Métodos exigidos: somar, subtrair, multiplicar, dividir, elevar à potência n.
  • Cada método recebe dois números como argumento.
  • Os métodos devem ser estáticos.
  • Deve haver um programa (ponto de entrada) que teste a classe.

Passo 2

Decisão de linguagem e formato do programa (sem complicar): vou usar Java. Motivos simples e úteis para prova:
  • Em Java fica bem explícito o que é “estático” com a palavra-chave static.
  • É muito comum em tarefas de graduação e provas de programação em exatas.
  • Dá pra colocar a classe Calculadora e um main de teste na mesma classe, facilitando compilação/execução em um único arquivo.
Se você prefere outra linguagem (por exemplo Python), depois a gente pode adaptar, mas aqui vou seguir com Java para ser direto e claro.

Passo 3

Escolha dos tipos dos argumentos e do valor retornado:
  • Usar double como tipo para os parâmetros e para o valor retornado. Por quê? Porque double aceita inteiros e reais (números com casa decimal) e é suficiente para operações aritméticas básicas que geralmente aparecem em provas.
  • Assinatura genérica de cada método em Java (explicação, sem colocar o código final ainda): public static double nomeMetodo(double a, double b) onde a e b são os dois números que o método vai receber.
  • Nome dos métodos em português para ficar conforme o enunciado: somar, subtrair, multiplicar, dividir, potencia (ou elevar — vou usar potencia).

Passo 4

O que cada método faz — explicando passo a passo e dando a “fórmula” mental:
  • somar(a, b): soma os dois números. Operação simples: resultado = a + b.
  • subtrair(a, b): subtrai b de a. Operação: resultado = a - b.
  • multiplicar(a, b): multiplica a por b. Operação: resultado = a * b.
  • dividir(a, b): divide a por b. Operação: resultado = a / b. Atenção importante: se b for zero, a divisão é inválida — precisamos tratar esse caso para evitar comportamento indesejado. Em Java, double divide por zero dá Infinity ou NaN dependendo do caso, mas em programas é bom avisar o usuário. Então vou lançar uma exceção IllegalArgumentException se b == 0.0 para deixar explícito o erro.
  • potencia(a, b): calcula a elevado a b. Em Java usamos Math.pow(a, b). Notas didáticas: b pode ser inteiro, negativo ou fracionário; para b negativo o resultado é 1 / (a^{|b|}) (se a ≠ 0); para base negativa e expoente fracionário pode ocorrer NaN (porque raízes pares de números negativos não são reais), mas Math.pow já cuida disso retornando NaN quando apropriado. Não vou tratar todos os casos numéricos extremos na prova — basta usar Math.pow.

Passo 5

Regras sobre métodos estáticos (explicação didática e prática para a prova):
  • static significa que o método pertence à classe, não a uma instância. Ou seja, não preciso criar new Calculadora() para usar Calculadora.somar(1,2).
  • Em uma prova isso é prático: você escreve public static double somar(double a, double b) e chama diretamente Calculadora.somar(3, 4).
  • Vantagem em questões rápidas: evita código extra para criar objetos; deixa claro que a calculadora é apenas um conjunto de utilitários.

Passo 6

Como tratar o caso da divisão por zero (passo a passo):
  • Antes de fazer a / b, verifico se b == 0.0. Em Java, com double, verificar igualdade com zero é aceitável para esse propósito porque estamos checando um caso explícito pedido pela especificação (divisor exatamente zero).
  • Se b for zero, lanço IllegalArgumentException com mensagem que explique o problema, por exemplo: "Divisor não pode ser zero".
  • Isso torna o comportamento previsível no teste e evita resultados do tipo Infinity que podem confundir.

Passo 7

Como testar a classe na prática (programa de teste):
  • Vou colocar um método main dentro da mesma classe Calculadora. Assim, basta compilar um arquivo Calculadora.java e executar java Calculadora para ver os testes.
  • No main vou chamar cada método estático com valores de exemplo e imprimir os resultados no console usando System.out.println.
  • Também vou incluir um teste do caso de divisão por zero dentro de um bloco try/catch para mostrar como a exceção é disparada e capturada — isso é útil para a prova, porque demonstra tratamento de erro.

Passo 8

Dicas rápidas para escrever isso na prova (o que você deve lembrar quando tiver pouco tempo):
  • Declare a classe Calculadora.
  • Faça os métodos public static com retorno double e dois parâmetros double.
  • Use Math.pow para a potência.
  • Verifique if (b == 0.0) antes de dividir e lance IllegalArgumentException.
  • Coloque um main curto com System.out.println para testar; mostre um exemplo de cada operação.
  • Evite detalhes extras (como entrada do teclado) se a questão pede apenas a classe e um programa de teste simples — mantenha direto.

Passo 9

Preparando para submeter/compilar localmente:
  • Salve o código final num arquivo chamado Calculadora.java.
  • Compile: javac Calculadora.java
  • Execute: java Calculadora
  • Você verá os resultados impressos. Se ocorrer divisão por zero no teste, verá a mensagem tratada no catch.

Resposta

public class Calculadora {

    /**
     * Soma dois números.
     * @param a primeiro número
     * @param b segundo número
     * @return a + b
     */
    public static double somar(double a, double b) {
        return a + b;
    }

    /**
     * Subtrai o segundo número do primeiro.
     * @param a primeiro número
     * @param b segundo número
     * @return a - b
     */
    public static double subtrair(double a, double b) {
        return a - b;
    }

    /**
     * Multiplica dois números.
     * @param a primeiro número
     * @param b segundo número
     * @return a * b
     */
    public static double multiplicar(double a, double b) {
        return a * b;
    }

    /**
     * Divide o primeiro número pelo segundo.
     * Lança IllegalArgumentException se o divisor for zero.
     * @param a numerador
     * @param b denominador
     * @return a / b
     */
    public static double dividir(double a, double b) {
        if (b == 0.0) {
            throw new IllegalArgumentException("Divisor não pode ser zero");
        }
        return a / b;
    }

    /**
     * Eleva a base a um expoente (a^b).
     * Usa Math.pow para tratar expoentes negativos e fracionários.
     * @param a base
     * @param b expoente
     * @return Math.pow(a, b)
     */
    public static double potencia(double a, double b) {
        return Math.pow(a, b);
    }

    /**
     * Programa de teste simples.
     */
    public static void main(String[] args) {
        double x = 10.0;
        double y = 3.0;

        System.out.println("Testes da Calculadora:");
        System.out.println("somar(" + x + ", " + y + ") = " + somar(x, y));
        System.out.println("subtrair(" + x + ", " + y + ") = " + subtrair(x, y));
        System.out.println("multiplicar(" + x + ", " + y + ") = " + multiplicar(x, y));
        System.out.println("potencia(" + x + ", " + y + ") = " + potencia(x, y));

        // Teste de divisão normal
        System.out.println("dividir(" + x + ", " + y + ") = " + dividir(x, y));

        // Teste de divisão por zero com tratamento de exceção
        try {
            double z = 0.0;
            System.out.println("Tentando dividir por zero: dividir(" + x + ", " + z + ")");
            System.out.println("Resultado: " + dividir(x, z));
        } catch (IllegalArgumentException e) {
            System.out.println("Exceção capturada: " + e.getMessage());
        }
    }
}

Exercícios relacionados