Atividade Calculadora em Java

2 respostas Resolvido
programaçãojava
OlimpiaC

Boa tarde pessoal! Na minha aula de Java estamos aprendendo orientação a objetos, e meu prof. pediu uma calculadora. Nesta calculadora, o usuário vai digitar a expressão inteira, por exemplo 10+10, e o algoritmo precisa reconhecer qual expressão está sendo executada e mostrar o resultado na tela, ou seja, 10+10 = 20. Até aí eu fiz e entreguei.

Porém, ele pediu para complementarmos essa calculadora, de forma que, após a exibição do resultado 10+10 = 20, o usuário digite, por exemplo, +10, e o resultado então será = 30. Se o usuário informar outras operações elas precisam “agregar” no resultado também.

Porém estou com bastante dúvidas e até agora o que tentei não deu certo, gostaria de verificar se alguém poderia me dar alguma dica ou ajudar a fazer, por gentileza!

Segue o que eu já fiz:

CLASSE CalculadoraV2:

package testes;

public class CalculadoraV2 {

private String expressao;
private String[] separador = {};
private String[] resultado = {};
private Double valorCalculado;
private Double valorUm;
private Double valorDois;


public Double calculaValores(String expressao) {

    if(isSoma(expressao)) {

        resultado = expressao.split("\\+");     

        valorUm = Double.parseDouble(resultado[0]);
        valorDois = Double.parseDouble(resultado[1]);
        valorCalculado = calculaSoma(expressao);

    }else if(isSub(expressao)) {

        resultado = expressao.split("\\-");

        valorUm = Double.parseDouble(resultado[0]);
        valorDois = Double.parseDouble(resultado[1]);
        valorCalculado = calculaSub(expressao);

    }else if(isMult(expressao)) {

        resultado = expressao.split("\\*");

        valorUm = Double.parseDouble(resultado[0]);
        valorDois = Double.parseDouble(resultado[1]);
        valorCalculado = calculaMult(expressao);

    }else if(isDiv(expressao)) {

        resultado = expressao.split("\\/");

        valorUm = Double.parseDouble(resultado[0]);
        valorDois = Double.parseDouble(resultado[1]);
        valorCalculado = calculaDiv(expressao);

    }else {
        System.out.println("Informe um operador válido");
        expressao = "";
    }
    return valorCalculado;
}
public Boolean isSoma(String expressao) {

    separador = expressao.split("\\+");

    Boolean isSoma = false;

    if(separador.length == 2) {

        isSoma = true;
    }
    return isSoma;
}

public Boolean isSub(String expressao) {

    separador = expressao.split("\\-");

    Boolean isSub = false;

    if(separador.length == 2) {

        isSub = true;
    }
    return isSub;
}

public Boolean isMult(String expressao) {

    separador = expressao.split("\\*");

    Boolean isMult = false;

    if(separador.length == 2) {

        isMult = true;
    }
    return isMult;
}

public Boolean isDiv(String expressao) {

    separador = expressao.split("\\/");

    Boolean isDiv = false;

    if(separador.length == 2) {

        isDiv = true;
    }
    return isDiv;
}

/*     */

public Double calculaSoma(String expressao) {

    return valorUm + valorDois;
}

public Double calculaSub(String expressao) {

    return valorUm - valorDois;
}

public Double calculaMult(String expressao) {

    return valorUm * valorDois;
}

public Double calculaDiv(String expressao) {

    return valorUm / valorDois;
}

public String getExpressao() {
    return expressao;
}
public Double getValorUm() {
    return valorUm;
}
public void setValorUm(Double valorUm) {
    this.valorUm = valorUm;
}
public Double getValorDois() {
    return valorDois;
}
public void setValorDois(Double valorDois) {
    this.valorDois = valorDois;
}
public String[] getSeparador() {
    return separador;
}
public void setSeparador(String[] separador) {
    this.separador = separador;
}
public String[] getResultado() {
    return resultado;
}
public void setResultado(String[] resultado) {
    this.resultado = resultado;
}
public void setExpressao(String expressao) {
    this.expressao = expressao;
}
public Double getValorCalculado() {
    return valorCalculado;
}
public void setValorCalculado(Double valorCalculado) {
    this.valorCalculado = valorCalculado;
}
}

CLASSE CalculadoraV2Test

package testes;

import java.util.Scanner;

public class CalculadoraV2Test {

private static Scanner entrada;

public static void main(String[] args) {

    entrada = new Scanner(System.in);
    Boolean continuar = false;
    String expressao;

    do {
    System.out.println("Informe o cálculo: ");
    expressao = entrada.next();

    CalculadoraV2 calculadora = new CalculadoraV2();
    calculadora.setExpressao(expressao);

    Double operacao = calculadora.calculaValores(expressao);
    System.out.println(operacao);
    continuar = true;

}while(continuar);
}
}

Agradeço a ajuda!

2 Respostas

wldomiciano
Solucao aceita

Olhei seu código e tive uma ideia, vê se resolve:

Este é o código responsável por executar a calculadora:

class Teste {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);
    Boolean continuar = false;
    String expressao;

    CalculadoraV2 calculadora = new CalculadoraV2();

    do {
      System.out.println("Informe o cálculo: ");
      expressao = entrada.nextLine();

      calculadora.setExpressao(expressao);

      Double operacao = calculadora.calculaValores(expressao);
      System.out.println(operacao);
      continuar = true;
    } while (continuar);
  }
}

Note que movi a linha abaixo pra fora do loop infinito.

CalculadoraV2 calculadora = new CalculadoraV2();

Aí, na classe CalculadoraV2, basta fazer a seguinte alteração no método calculaValores:

public Double calculaValores(String expressao) {
    if (isSoma(expressao)) {
      resultado = expressao.split("\\+");

      try {
        valorUm = Double.parseDouble(resultado[0]);
      } catch (NumberFormatException e) {
        valorUm = valorCalculado;
      }

      valorDois = Double.parseDouble(resultado[1]);
      valorCalculado = calculaSoma(expressao);
    } else if (isSub(expressao)) {
      resultado = expressao.split("\\-");

      try {
        valorUm = Double.parseDouble(resultado[0]);
      } catch (NumberFormatException e) {
        valorUm = valorCalculado;
      }

      valorDois = Double.parseDouble(resultado[1]);
      valorCalculado = calculaSub(expressao);
    } else if (isMult(expressao)) {
      resultado = expressao.split("\\*");

      try {
        valorUm = Double.parseDouble(resultado[0]);
      } catch (NumberFormatException e) {
        valorUm = valorCalculado;
      }

      valorDois = Double.parseDouble(resultado[1]);
      valorCalculado = calculaMult(expressao);
    } else if (isDiv(expressao)) {
      resultado = expressao.split("\\/");

      try {
        valorUm = Double.parseDouble(resultado[0]);
      } catch (NumberFormatException e) {
        valorUm = valorCalculado;
      }

      valorDois = Double.parseDouble(resultado[1]);
      valorCalculado = calculaDiv(expressao);
    } else {
      System.out.println("Informe um operador válido");
      expressao = "";
    }
    return valorCalculado;
  }

O segredo está em 2 pontos:

  1. Movendo a instanciação da calculadora pra fora do loop, ganhamos a capacidade de manter o estado dela ao longo das iterações.

  2. O trecho abaixo vai tentar converter o resultado[0] pra double igual vc já estava fazendo.

try {
  valorUm = Double.parseDouble(resultado[0]);
} catch (NumberFormatException e) {
  valorUm = valorCalculado;
}

Só que se o usuário entrar com a expressão “+ 10”, por exemplo, resultado[0] será uma string vazia e uma exceção será lançada. Se isso acontecer, significa que ele está adicionando mais 10 à um resultado anteriormente calculado e este valor será usado como valorUm.

OlimpiaC

Fala wldomiciano, tudo bem?

Cara, era super simples hahaha, muito obrigada pela ajuda!!!

Criado 2 de agosto de 2019
Ultima resposta 3 de ago. de 2019
Respostas 2
Participantes 2