You are going to write a program which solves for the roots of a quadratic equation using the well know formula:

In this assignment you will do a number of things:

The completed assignment will consist of two things:

A method is a name given to one or more statements that performs some work on behalf of the code that calls it. To use it, the calling code simply uses its name() and the statements in the method are executed. Methods provide abstraction in the code, replacing the details of how the method does its work (the actual code) by a name which conveys what the method does. Choosing good names for variables and methods is important.

Methods are useful because they allow the writer to decompose a problem into smaller parts (the methods), then call them to complete the necessary work. Methods may be reused over and over again, simplifying the creation of more complex programs. Furthermore, one can call a method and defer the actual details of its implementation until later. One can concentrate on the big picture first, then take care of details later.

Methods may have parameter(s). For example the method Math.sqrt() takes a single parameter (a number), then calculates its square root. The user need not be concerned with how Math.sqrt() actually does its work. The user only cares what Math.sqrt() does.

Methods may return values (e.g. Math.sqrt()) or be void (e.g. System.out.println()). Methods that return values are "answering questions".

In your main() method declare three double variables. You may give them any names you want (foo, bar, baz). BUT, as we are working on quadratic equations, it is probably better if you name them a, b, and c because that is the nomenclature used in the formula.

Notice how the call to radical(a, b, c) is underlined in red. This is because Eclipse understands that you are making a method call, but it can not find any method named radical(). If you put the mouse over the underlined method name, Eclipse will explain the problem and offer you a quick fix. Take the suggested fix.

You are now ready to calculate and print the roots of the quadratic equation. Again, you are going to delegate the work to a method.

At this point, you have a complete program, but the two methods have only skeleton implementations. This means that they will execute but will not do their intended job. The importance of this is that you can actually run your program and incrementally implement/test the methods one at a time.

You are now ready to implement radical(). The purpose of this method is to calculate the square root of the expression under the square root sign.

Now test your program by running it. Your program should print the value radical() → 36.0. What you are doing is testing what you just completed. A best practice is to write a little code, test it until it is correct, and then repeat. At the end you will have a working program because you have tested each part along the way. Once you are certain your method works, you may comment out or remove the System.out.println().

This routine will calculate a single root and print it.

Now run your program again. You should see Root: 2.0 and Root: -4.0.

You are DONE! However, your program only calculates the roots of a single quadratic equation. To calculate the roots of a different equation, you must modify the program and rerun it. Not very friendly for the user. So, lets fix that.

Did you notice that the main() method has parameters? We can easily take advantage of this to calculate the roots of any quadratic equation. We can pass the coefficients of the quadratic equation to main() so it is more useful. The declaration of main() is

The notation String[] means that the variable args is an array. An array is a type of variable that hold multiple values. Individual values in the array are accessed using an integer index. For example, if one considers a list of planets ordered by their distance from the sun, Mercury is the 1^st and Earth is the 3^rd planet. In computer arrays, the index starts at 0 rather than the 1 that humans typically use to denote the 1^st element in a list. The syntax for accessing an individual value is variable[index] where index can be a number (e.g. 0), a variable (e.g. i), or even an expression (e.g. i+1).

Since values are passed into main(), how do we actually use them in the method?

The problem is that a is a double, but args[0] is a String. So, you need to convert the string containing the characters 6 . 0 into the number 6.0. Fortunately, Java has a class Double (capital D intensional) that can help us. Find a method in the documentation that takes a String as an argument and return a double. Use the method you found and call it passing the parameter args[0]. Since this method is a static method in a different class, you need to preface the call with the class name (e.g. Double.methodName(args[0]).

Now fix the assignments for variables b and c.

To pass values to the main() method in Eclipse do the following:

Run your program multiple times with different parameters. There are at least three situations that will produce unexpected results. Some may result in Exception. Others may produce strange output.

Now add an Answers section to your code as a Java block comment.

Use the Checkin tab on the class web site and turn in the file QuadEqn.java.

In order to read from the keyboard, you must use the methods of an object designed to do just that. One way is to use a class called Scanner. Add the following line as the first line of main().

This statement is declaring a variable of type Scanner, named kbd. It is then initializing it by creating a new one and initializing this using the value System.in. One we have created kbd we can use it to access things that the user typed in. You can create a Scanner to read the contents of a text file or to read other sources of information. In Java the variable System.in represents the keyboard. It is used for input. System.out is used for output to the screen. You used this when you wrote System.out.println(). The method println() is a method of the variable System.in.

So now you need to use the Scanner to actually get values from the users. This is a good place for a method. Add the following line to main() just after your declaration of kbd. What you are doing is saying that args will be initialized by reading from the keyboard, rather that externally.

Again you will see that getCoefficients() is underlined in red. As you did earlier, place the mouse over the underlined code, and see what quick fix is available. Allow Eclipse to create the method for you.

Notice that getCoefficients() is responsible for returning an array of String. We can tell that by the [] notation. Furthermore, we know that our program requires three strings, each of which contains one of the coefficients for the quadratic equation. So this method will build the array of values, but delegate the actual input to yet another method.

Notice that when Eclipse created the empty implementation of getCoefficient() that it named the first parameter string (note lower case). Since your call passed a literal (e.g. "a"), instead of a variable, Eclipse chose a simple name that really doesn’t convey what the parameter is used for. The parameter will be used to prompt the user which coefficient to enter. To make this clearer, change the name of the first parameter to prompt.

A prompt like "a" is not, by itself, very useful. Wouldn’t it be better to give a more complete prompt to the user? There are two ways you might do this:

You will do the latter to print a prompt for the user like the following. Note that the prompt should be on the same line as what the user types.

To complete the routine, you will use the kbd.nextLine() method to take a value from the keyboard and assign it to a String variable. You will then modify the return statement to actually return the variable.

The idea of a usage statement is to give the user a brief description of how to run the program. It is not a replacement for a manual, but serves to remind the user how to use the program. After the usage is given, the program normally terminates itself. To implement the usage() method:

Run your program, but use a non-numeric value for a coefficient. What did you observe and where did the error occur? A crashing program is not very friendly to the user. That is why the check for a non-zero value of the coefficient a is important.

To handle this type of error, you must do some checking before invoking the code to convert the String to a double. This most easily done by adding a level of indirection in the code. Instead of calling Double.parseDouble() directly, replace it by a call to a new method you write. Name this method getDouble() and create an empty implementation. Note that in doing this, the basic structure of main() has not changed at all. Only the detail of numeric conversion has changed.

Like the method Double.parseDouble() your method getDouble() takes a String as a parameter and returns a double. As part of its implementation it will actually use Double.parseDouble() to do the work. But, before that it needs to validate that the input parameter (a String) really does represent a double.

The Jave Scanner class that you used earlier provides this capability. The general flow of the function is:

Your program terminates whenever an error condition is encountered. In the case of interactive use, it would be useful to allow the user to correct the mistake, rather that having to start over. Recall that interactive input uses the method getCoefficient().

Add some code to getCoefficient() to verify that what the user entered is valid. Notice that this will be almost identical to what you did in getDouble(), except that you don’t want to terminate the program. Instead, print the error for the user, then print a new prompt and get a revised value.

Perhaps you can take most of the code out of getDouble() and put it in a boolean method the determines if the String is really a double and return a true/false result. Boolean methods often begin with the prefix is so that an if statement invoking it looks like if (isXXX()). You may invoke your new method from both getDouble() and getCoefficient(). Each of these method will ultimately do something different depending on the return value, but use a common method to determine if there are any errors.