Soluzione 3.7


Ecco una possibile soluzione per la classe QuadraticEquation. Piu` sotto si trova una possibile soluzione per la classe QuadraticEquationTester.
Alcune osservazioni sulle scelte di progetto
public class QuadraticEquation  //ATTENZIONE: se la classe QuadraticEquation e la classe
{                               //QuadraticEquationTester sono nello stesso file lo specificatore
                                //di accesso public va rimosso dalla prima riga.
class QuadraticEquation
{
    public QuadraticEquation()
    {
        a = 0;
        b = 0;
        c = 0;
    }
    
    public QuadraticEquation(double acoeff, double bcoeff, double ccoeff)
    {
        a = acoeff;
        b = bcoeff;
        c = ccoeff;
    }
    
    public double getSolution1()
    {
        return getSolution(1);
    }
    
    public double getSolution2()
    {
        return getSolution(-1);
    }
    
    public boolean hasSolutions()
    {
    if(getDelta()>=0 && !( (a == 0) && (b == 0) && (c != 0) ) )
        return true;
    else
        return false;
    }
    
    // ********************** metodi ausiliari privati *********************

    /*
      Calcola una soluzione dell'equazione: se i e` positivo usa il segno "+" 
      nella formula quadratica, se i e` negativo usa il segno "-"
    */
    private double getSolution(int i)
    {
        double solution;
        if(!hasSolutions())  //nessuna soluzione
            solution = Double.NaN;
        else if (a != 0)    // caso a!=0, due soluzioni reali
        {   //la variabile root ha il segno di i
            double root = Math.signum(i) * Math.sqrt(getDelta());
            solution = (-b + root)/(2*a);
        }
        else if (b != 0)    // caso a=0,b!=0, una soluzione reale
            solution = -c/b;// la formula quadratica non e` utilizzabile
        else                // caso a=b=c=0; infinite soluzioni
            solution = Double.NaN;

    return solution;
    }
    
    /*
      Calcola il Delta dell'equazione di secondo grado 
    */
    private double getDelta()
    {
        double delta = b*b -4*a*c;
        return delta;
    }
    
    //********************* campi di esemplare (privati) **************
    private double a;
    private double b;
    private double c;   
}

Ed ecco un programma di collaudo QuadraticEquationTester
import java.util.Scanner;

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

        boolean done = false;
        while (done != true)
        {
            System.out.println("Inserire coeff. a (Q per terminare)");
            String input = in.next();
            if (input.equalsIgnoreCase("Q"))
                done = true;
            else
            {
                double a = Double.parseDouble(input);
                System.out.println("Inserire coeff. b");
                double b = in.nextDouble();
                System.out.println("Inserie coeff. c");
                double c = in.nextDouble();
    
                QuadraticEquation eq = new QuadraticEquation(a,b,c);
                double sol1 = eq.getSolution1();
                double sol2 = eq.getSolution2();
    
                if(eq.hasSolutions())
                {
                    if (Double.isNaN(sol1))
                        System.out.println("Infinite soluzioni!");
                    else
                    {
                        System.out.printf("%-12s%5.2f%n","Soluzione 1:",sol1);
                        System.out.printf("%-12s%5.2f%n","Soluzione 2:",sol2);
                    }
                }
                else
                    System.out.println("Non ha soluzioni!");
            }
        }
    }
}