Equação do segundo grau em Java

Uma equação do segundo grau é uma expressão algébrica no formato ax² + bx + c = 0, onde a, b e c são constantes e x é a variável. A solução para uma equação quadrática pode ser encontrada usando a famosa fórmula de Bhaskara. Neste post, aprenda a equação do segundo grau em Java.

Fórmula de Bhaskara

O termo b² - 4ac é chamado de discriminante e indica o número e o tipo de raízes:

• Se Δ > 0, existem duas raízes reais diferentes.
• Se Δ = 0, existe uma raiz real dupla (ou duas raízes iguais).
• Se Δ < 0, as raízes são complexas (não reais).

Implementação em Java

Vamos implementar um programa em Java que calcula as raízes de uma equação do segundo grau, utilizando a fórmula de Bhaskara para avaliar os valores de x.

import java.util.Scanner;

public class EquacaoSegundoGrau {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Digite o valor de a: ");
        double a = scanner.nextDouble();
        
        System.out.print("Digite o valor de b: ");
        double b = scanner.nextDouble();
        
        System.out.print("Digite o valor de c: ");
        double c = scanner.nextDouble();

        double delta = (b * b) - (4 * a * c); // Calcula o discriminante

        if (a == 0) {
            System.out.println("O valor de 'a' deve ser diferente de zero para ser uma equação do segundo grau.");
        } else if (delta > 0) {
            double x1 = (-b + Math.sqrt(delta)) / (2 * a);
            double x2 = (-b - Math.sqrt(delta)) / (2 * a);
            System.out.println("As raízes são reais e diferentes.");
            System.out.println("x1 = " + x1);
            System.out.println("x2 = " + x2);
        } else if (delta == 0) {
            double x = -b / (2 * a);
            System.out.println("As raízes são reais e iguais.");
            System.out.println("x = " + x);
        } else {
            System.out.println("As raízes são complexas e não reais.");
            double realPart = -b / (2 * a);
            double imaginaryPart = Math.sqrt(-delta) / (2 * a);
            System.out.println("x1 = " + realPart + " + " + imaginaryPart + "i");
            System.out.println("x2 = " + realPart + " - " + imaginaryPart + "i");
        }
        
        scanner.close();
    }
}

Explicação do código

1. Entrada dos Coeficientes: O programa pede ao usuário que insira os valores de a, b e c.
   
   
2. Verificação do Valor de a: Verificamos se a é diferente de zero. Se a = 0, a equação deixa de ser do segundo grau.
   
   
3. Cálculo do Discriminante (delta): Calcula b² - 4ac para decidir o tipo de raízes.
   
   
4. Condicionais para o Discriminante:
   
   
   • delta > 0: Duas raízes reais e diferentes.
   • delta == 0: Uma raiz real dupla.
   • delta < 0: Raízes complexas e não reais, usando i para representar a unidade imaginária.

Exemplo de saída

Entrada:

a = 1
b = -3
c = 2

Saída:

As raízes são reais e diferentes.
x1 = 2.0
x2 = 1.0

Outro exemplo prático

import java.util.Scanner;

 public class equacao2grau {
    public static void main(String[] args) {
    float a, b, c, //coeficientes
    delta,         //delta
    sqrtdelta,     //raiz quadrada de delta
    raiz1,raiz2;   //raízes
    Scanner entrada = new Scanner(System.in);
        
    //Passo 1: Recebendo os coeficientes
    System.out.println("Equação do 2o grau: ax² + bx + cx = 0");
    System.out.print("Entre com o valor de a: ");
    a = entrada.nextFloat();
    System.out.print("Entre com o valor de b: ");
    b = entrada.nextFloat();
    System.out.print("Entre com o valor de c: ");
    c = entrada.nextFloat();
        
    //Passo 2: Checando se a equação é válida
    if(a != 0){
    //Passo 3: recebendo o valor de delta e calculando sua raiz quadrada
      delta = (b*b) - (4*a*c);
      sqrtdelta = (float)Math.sqrt(delta);
    //Passo 4: se a raiz de delta for maior que 0, as raízes são reais    
     if(delta >=0){
      raiz1 = ((-1)*b + sqrtdelta)/(2*a);
      raiz2 = ((-1)*b - sqrtdelta)/(2*a);
      System.out.printf("Raízes: %.2f e %.2f", raiz1, raiz2);
     }  
      //Passo 5: se delta for menor que 0, as raízes serão complexas
     else {
      delta = -delta;
      sqrtdelta = (float)Math.sqrt(delta);
      System.out.printf("Raíz 1: %.2f + i.%.2f\n", (-b)/(2*a), (sqrtdelta)/(2*a));
      System.out.printf("Raíz 2: %.2f - i.%.2f\n", (-b)/(2*a), (sqrtdelta)/(2*a));             
    }            
   }
    else {
     System.out.println("Coeficiente 'a' inválido. Não é uma equação do 2o grau");
   }
  } 
} 

Resolver uma equação do segundo grau em Java é simples e pode ser feito com algumas operações matemáticas básicas.

Ao utilizar a fórmula de Bhaskara, conseguimos tratar os três tipos de soluções possíveis (duas raízes reais diferentes, uma raiz real dupla, ou raízes complexas) de maneira eficiente.

Dúvidas ou sugestões? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: bhaskara java