Resolvedor de Baskara que usa algumas coisas do Java 8. Resposta para: http://www.guj.com.br/18520-programa-para-calculo-de-equacao-de-2-grau

Programa.java

package baskara;

import java.util.Scanner;

import baskara.ResolvedorBaskara.ResultadoBaskara;

public class Programa {
	public static void main(String[] args) {
		
		try(Scanner sc = new Scanner(System.in)){
			System.out.println("Seja bem vindo a Calculadora de Equações do 2º Grau !");
			
			// Capturando variáveis
			System.out.print("Digite o termo \"a\": ");
			int a = sc.nextInt();
			System.out.print("Digite o termo \"b\": ");
			int b = sc.nextInt();
			System.out.print("Digite o termo \"c\": ");
			int c = sc.nextInt();
			
			ResolvedorBaskara resolvedor = new ResolvedorBaskara();
			ResultadoBaskara resultado = resolvedor.resolve(a, b, c);
			System.out.println(resultado);
			/*
			Para a=1, b=-2 e c=-3, imprime:
				Resultado: x' = 3.0, x'' = -1.0
				Cálculos efetuados: 
				b² = 4.0
				4ac = -12.0
				Δ = b² - 4ac = 16.0
				√Δ = 4.0
				-b = 2.0
				-b + √Δ = 6.0
				-b - √Δ = -2.0
				2a = 2.0
				x' = (-b + √Δ) / 2a = 3.0
				x'' = (-b - √Δ) / 2a = -1.0
			*/

		}

	}
}

ResolvedorBaskara.java

package baskara;

import java.util.ArrayList;
import java.util.List;
import java.util.function.DoubleSupplier;
import java.util.stream.Collectors;

public class ResolvedorBaskara {
	
	List<CalculoIntermediarioBaskara> calculos = new ArrayList<>();

	public ResultadoBaskara resolve(double a, double b, double c) {
		double bAoQuadrado = calcula("b²", () -> Math.pow(b, 2));
		
		double quatroAC = calcula("4ac", () -> 4 * a * c);
		
		double delta = calcula("Δ = b² - 4ac", () -> bAoQuadrado - quatroAC);
		
		if(delta < 0) {
			throw new BaskaraException("Não existe raiz real para Δ negativo: " + delta);
		}
		
		double raizDeDelta = calcula("√Δ", () -> Math.sqrt(delta));
		
		double menosB = calcula("-b", () -> -b);

		double menosBMaisRaizDeDelta = calcula("-b + √Δ", () -> menosB + raizDeDelta);

		double menosBMenosRaizDeDelta = calcula("-b - √Δ", () -> menosB - raizDeDelta);

		double doisA = calcula("2a", () -> 2 * a);
		
		double x1 = calcula("x' = (-b + √Δ) / 2a", () -> menosBMaisRaizDeDelta / doisA);
		
		double x2 = calcula("x'' = (-b - √Δ) / 2a", () -> menosBMenosRaizDeDelta / doisA);
		
		return new ResultadoBaskara(x1, x2, calculos);
	}

	private double calcula(String descricao, DoubleSupplier calculo) {
		double valor = calculo.getAsDouble();
		calculos.add(new CalculoIntermediarioBaskara(descricao, valor));
		return valor;
	}

	public static class CalculoIntermediarioBaskara {
		private final String descricao;
		private final double valor;

		public CalculoIntermediarioBaskara(String descricao, double valor) {
			this.descricao = descricao;
			this.valor = valor;
		}

		public String getDescricao() {
			return descricao;
		}

		public double getValor() {
			return valor;
		}

		@Override
		public String toString() {
			return descricao + " = " + valor;
		}

	}

	public static  class ResultadoBaskara {
		private final double x1;
		private final double x2;
		private List<CalculoIntermediarioBaskara> calculos;

		public ResultadoBaskara(double x1, double x2, List<CalculoIntermediarioBaskara> calculos) {
			this.x1 = x1;
			this.x2 = x2;
			this.calculos = calculos;
		}

		public double getX1() {
			return x1;
		}

		public double getX2() {
			return x2;
		}

		@Override
		public String toString() {
			String texto = "Resultado: x' = " + x1 + ", x'' = " + x2 + "\n"; 
			texto += "Cálculos efetuados: \n"; 
			texto += String.join("\n", calculos.stream().map(CalculoIntermediarioBaskara::toString).collect(Collectors.toList()));
			return texto;
		}
	}

	
	public static class BaskaraException extends RuntimeException {
		private static final long serialVersionUID = 1L;

		public BaskaraException(String mensagem) {
			super(mensagem);
		}
	}
}

ResolvedorBaskaraTest.java

package baskara;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import org.junit.Before;
import org.junit.Test;

import baskara.ResolvedorBaskara.BaskaraException;
import baskara.ResolvedorBaskara.ResultadoBaskara;


public class ResolvedorBaskaraTest {

	private ResolvedorBaskara resolvedor;
	
	@Before
	public void antes(){
		resolvedor = new ResolvedorBaskara();
	}

	@Test
	public void deveCalcularFormulaComDoisResultados() {
		ResultadoBaskara resultado = resolvedor.resolve(1, -2, -3);
		
		assertEquals(3.0, resultado.getX1(), 0.0001);
		assertEquals(-1.0, resultado.getX2(), 0.0001);
	}

	
	@Test
	public void deveCalcularFormulaComApenasUmResultado() {
		ResultadoBaskara resultado = resolvedor.resolve(1, 8, 16);
		
		assertTrue(resultado.getX1() == resultado.getX2());

		assertEquals(-4.0, resultado.getX1(), 0.0001);
		assertEquals(-4.0, resultado.getX2(), 0.0001);
	}

	@Test(expected=BaskaraException.class)
	public void deveLancarExcecaoComFormulaSemResultado() {
		resolvedor.resolve(10, 6, 10);
	}

}