a. Fork and clone the repository at https://github.com/Grinnell-CSC207/lab-exceptions-vscode. (You don’t really need to fork the repo, but if you don’t, it’s harder to share your work with your partner.)
b. Import the repository into VSCode.
c. Quickly skim the code to determine the purpose of the various portions.
a. Remove the throws Exception from the main method and determine what, if any, error messages you get. If VSCode permits you to do so, try running the program.
After you finish exploring the effects of that removal, reinsert the throws clause.
b. Remove the throws Exception from the definition of readInt and determine what, if any, error messages you get. If VSCode permits you to do so, try running the program with that warning removed.
Do not reinsert the throws clause.
c. Within readInt, you should have a sequence of lines (or perhaps a single line) that looks something like the following:
String response = br.readLine();
return Integer.parseInt(response);
Enclose those lines in a try/catch clause that returns 0 if an exception is thrown, as in
try {
String response = br.readLine();
return Integer.parseInt(response);
} catch (Exception e) {
return 0;
} // Reading/parsing fails.
d. Verify that VSCode is no longer concerned about errors in your code.
e. Determine what happens when the user enters an invalid value (such as Hello) in response to a request for an integer.
Implement the smallerRoot() method in the Quadratic class. The method should compute the smaller of the two roots of a quadratic expression.
Note that you can use the following formula to compute that root: \((-b - \sqrt{b^2 - 4ac})/2a\)
You will, of course, have to translate that mathematical expression into Java code.
b. Write a few simple unit tests for that procedure. Note that you are likely to find it easier of you choose quadratics for which you know the solution. For example,
a. Write a new main class, QR, which
b. Use your class to compute the smaller root of \(x^2 - x - 2\). (The roots of that quadratic are \(2 and\)-1$$.
a. Determine what happens if the user enters 0 for the coefficient of \(x^2\).
b. Determine what happens if user enters coefficients for which there is no real root.
c. Determine what happens if the user enters values for which the function has only one root (e.g., \(x^2 - 2x + 1\) has only one root).
a. Extend smallerRoot to indicate that it may throw an exception. Note that you’ll need to change the method signature for smallerRoot to something like the following.
public double smallerRoot() throws Exception {
b. Can you successfully compile your modified code? If not, make any changes necessary to permit you to compile it.
c. Can you successfully compile QR? If not, get help from one of the class staff.
d. What now happens if you enter the “erroneous” input described in the previous exercise?
a. Extend smallerRoot so that it throws an exception if a is 0. For example,
if (a == 0) {
throw new Exception("Cannot compute quadratic roots of linear functions.");
} // if (a == 0)
b. Extend smallerRoot so that it throws an exception if the root is not real (i.e., if it has an imaginary component). Note that the root is not real if the expression that you’re taking a square root of is negative.
c. What now happens if you enter the “erroneous” input described above?
If you’ve written your main method using the recommended template, you have a throws Exception clause. Remove that clause.
a. What effect do you expect removing that line will have?
b. Check your answer experimentally. Ask one of the class staff if don’t understand the results of your experiment.
c. Enclose your call to smallerRoot in a try/catch block. For example,
try {
double root = qpoly.smallerRoot();
pen.println("The smaller root of the polynomial is: " + root);
pen.println("Experimentally: " + qpoly.toString(root) + " = " +
qpoly.evaluate(root));
} catch (Exception e) {
pen.println("Sorry, I could not compute a root.");
} // catch (Exception)
d. Determine what happens with the problematic inputs described above.
a. Update smallerRoot so that it tries to throw a DivideByZeroException if the coefficient of the quadratic term is 0. You can still throw a generic exception if the result includes an imaginary component.
b. What do you expect to happen when you try to compile the revised program?
c. Check your answer experimentally.
As you should have determined in the previous exercise, Java does not know by default what a DivideByZeroException is. Hence, you’ll need to create your own Exception. You do so using the strategy described in the corresponding reading.
a. Create and compile a Java file for DivideByZeroException.
b. Verify that the previously-modified code now works.
. Extend QR so that it has a catch clause for your new DivideByZeroException before the catch clause for the generic Exception. For example,
try {
...
} catch (DivideByZeroException dbze) {
pen.println("Cannot compute a result because the coefficient of the quadratic term is 0.");
} catch (Exception e) {
...
} // catch (Exception)
b. Determine what happens in each of the problematic cases.
c. What do your results for this exercise suggest?