package annualcompensationfinal;

import java.text.DecimalFormat; import java.util.Scanner;

// Starts the controlling class public class AnnualCompensationFinal {

/**
* @param args the command line arguments
*/

// Starts the main method public static void main(String[] args) {
/*
* The following lines create the SalesClass object called SalesClass.
* This will use the output of a double method, "Utils.getDoubleInput".
* The creation of the the SalesObject is through the execution of the
* SalesClass constructor that is dependent on a nested call to the
* Utils.getDoubleInput method which needs a string input to run. The
* string in this case is "Enter the annual sales:"
* The variable salesDouble is retruned and displayed as the calculated

* total annual compensation amount.
* A new object is then created with the PotentialClass. This will use
* the salesDouble value to create a table of potential annual
* compensation adding $5,000 to to the salespersons total annual
* compensation and keep adding $5,000 until the calculation reaches
* 150% of annual sales.
*
*/

SalesClass SalesObject = new
SalesClass(Utils.getDoubleInput("Enter "
+ "annual sales: $"));
System.out.println("Total annual "
+ "compensation: $" + Utils.numFormat(SalesObject.salesDouble));

// PotentialClass PotentialObject = new
//
}// End of main method
}// End of controlling class

class Utils { // Begin class Utils
/*
* Method numFormat formats number to ##,##0.00.
* Input: single argument of type double.

* Output: return value of type String containing formatted input
*/

static String numFormat(double dec) { return new DecimalFormat("##,##0.00").format(dec);
} // End of numFormat method within class Utils
/*
* Method getDoubleInput queries user for input and receives a double.
* Input: single argument of type String (the prompt to the user).
* Output: return value of type double containing the user's input.
*/

static double getDoubleInput(String message) {
/*
* Declaration of goodInput, which will contain the valid user input
* that will be the return value of the getDoubleInput method.
*/

double goodInput = 0;

/*
* A "try" statement means the program is going to do something that
* may create an error. Errors will terminate the execution of a
* program (that is bad). The programmer attempts to predict the

* errors the "try" statement may generate, and writes code to
* handle these errors as "exceptions" instead of unhandled errors,
* because the programmer is smart enough to predict them, and is
* therefore able to catch the problem when it happened. Exception
* handling is discussed further in the comments following the
* "catch" statement below.
*/
try {
/*
* Prompt the user with the same string as was an input to the
* getDoubleInput method, which is the content of a String
* called "message".
*/

System.out.print(message);
/*
* The next three lines are actually just one line, broken
* into smaller parts so the end of the line can be seen without
* scrolling to the right
*
* There are several concepts going on in this line of code:
* 1. Starting with the "System.in" System.in is the input
* device for the user's computer (the keyboard) and the
* "new Scanner" statement is saying that the programmer is

* creating a new Scanner object that will receive input from
* the keyboard.
* 2. The scanner object created below reads the next line
* of input from the user into a String (String is the return
* type of method nextLine).
* 3. The String return value of the nextLine method is
* examined to find the double it contains (assuming the user
* actually input a number) by using the parseDouble method of
* the Double class, which returns that double value and then
* the code below stores this information to the goodInput
* variable.
*/
goodInput = Double.parseDouble( new Scanner(System.in).nextLine()
);// THis must have a check for $400,000 sales target !!!!!!
/*
* If the user does what is asked, one should never reach the catch
* statement. Assuming the user is an idiot and entered something
* like "five" instead of "5" when prompted for a number, the try
* statement above will fail. In this case, the user will have
* created a NumberFormatException, which the programmer will handle
* with the catch statement block below.
* In this line of code we catch a NumberFormatException with an
* object "ex" of type NumberFormatException that exists only for

* the catch statement block below.
*/

} catch (NumberFormatException ex) {
/*
* The next line of code notifies the user that the input was
* not a number. What should the programmer do next? Well, it
* does not make sense to have the program end just because the
* user made a single mistake, so it would be better if the user
* were asked to do it over (and hopefully this time correctly.)
* What's the most efficient way to do that? Well, the method
* getDoubleInput is designed to do that exact thing. The method
* is called in the "getDoubleInput" statement two lines down.
*/

System.out.println("Sorry. Please enter numbers only.");
/*
* In looking at the next line, the astute programmer might
* question that since the program is already executing the
* getDoubleInput() method at this point, how can it be executed
* twice at the same time? The answer is simple. When a method
* is called recursively (as in this scenario) the first
* instance spawns a separate second instance, and if the user
* messes up again, the second will spawn a third and so on

* until the user finally inputs a valid number. Once this
* happens the instances of the method will close in the
* reverse order from that in which they were created.
*/

goodInput = getDoubleInput(message);
}// End of try/catch statement return goodInput;
}// End of getDoubleInput method within class Utils
}// End of class Utils

class SalesClass
{
protected double salesDouble = 0.0d;
SalesClass(double InstanceVariable)
{
// This step will calculate (commission of 8% on sales) + (annual salary) $30,000
// The step will now change for the following conditions:
//

< $320,000 (or 0.8 * $400,000) = 0% commission

//

$320,000 to < $400,000 = 8% commission

//

>= $400,000 = 10% commission

salesDouble = InstanceVariable;

if (salesDouble =320000)
{
if (salesDouble